From 02992b874b5ddd3d08303d1951cb4ff1d45a8e64 Mon Sep 17 00:00:00 2001
From: Aleksandar Grbic <ag@dreamdata.io>
Date: Tue, 28 Jul 2026 14:40:04 +0200
Subject: [PATCH 1/2] fix(acceptance): seed parent BEFORE navigating + wait for
 the FK <option> (child-slice e2e)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The generated child-slice acceptance (e.g. Contact belongsTo Company) seeded the parent
Company via API AFTER navigating to the child page and opening the form, then immediately
selectOption(companyId) on the company <select>. But that <select> is populated by an async
list query on the child page's mount (navigate) — which ran BEFORE the seed and was never
refetched — so the <option value={seededId}> never entered the DOM and selectOption waited
the full 30s → e2e timeout → the whole slice false-PARKED. (Company/single-entity slices
were fine; only relational CHILD slices with a parent-FK <select> hit this.)

Fix (generateEntitySpec, all 4 mutating tests — create/persist/update/delete):
- Emit parentSeedingCode BETWEEN dashboard.goto() and navigateTo<Child>() so the child page's
  initial (fresh, per-test reload) parent-list fetch already includes the seeded parent —
  independent of the model's React-Query refetch behavior.
- generateFieldFillSteps: before selectOption on an FK field, waitFor option[value="${id}"]
  { state: attached } (belt-and-suspenders against the async fetch race).
- generateParentSeedingCode prepends the rationale note only when parents exist (parentless
  slices stay clean).
Negatives are API-only (no <select>) — unchanged.

Regression tests: seed precedes form-open, waitFor precedes selectOption, and a parentless
slice emits no FK wait/select. Full suite 3191/0; typecheck+lint+format clean.
---
 .../boringstack/acceptance/e2e-generator.ts   | 37 ++++++++----
 .../tests/boringstack-e2e-generator.test.ts   | 60 +++++++++++++++++++
 2 files changed, 85 insertions(+), 12 deletions(-)

diff --git a/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts b/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts
index 41999cad..655458f9 100644
--- a/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts
+++ b/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts
@@ -224,7 +224,18 @@ function generateParentSeedingCode(
     emitParentSeeding(parent.key, parent.entity, 0);
   }
 
-  return codeBlocks.join("\n");
+  if (codeBlocks.length === 0) {
+    return "";
+  }
+
+  // Callers place this BEFORE navigating to the child page: the child's parent <select> is
+  // filled by an async list query on mount, so seeding first means that fetch already includes
+  // the parents. An API seed AFTER navigation isn't reflected in the fetched list, so the
+  // <option> never appears and selectOption times out (30s) → false park.
+  const note =
+    "    // Seed parent(s) up front so the child page's async parent-<select> lists them.";
+
+  return [note, ...codeBlocks].join("\n");
 }
 
 /**
@@ -367,8 +378,14 @@ function generateFieldFillSteps(
 
         if (parent) {
           const varName = `${parent.key}Id`;
-
-          return `    await page.getByTestId("${ids.field(field.name)}").selectOption(${varName});`;
+          const sel = `page.getByTestId("${ids.field(field.name)}")`;
+
+          // The parent <select> is populated by an ASYNC list query (the child page fetches its
+          // parents). Wait for the SEEDED option to attach before selecting — otherwise
+          // selectOption races the in-flight fetch and Playwright waits the full 30s for an
+          // <option value="{seededId}"> that isn't in the DOM yet → timeout → false park.
+          return `    await ${sel}.locator(\`option[value="\${${varName}}"]\`).waitFor({ state: "attached", timeout: 10000 });
+    await ${sel}.selectOption(${varName});`;
         }
       }
 
@@ -672,6 +689,7 @@ test.describe(${JSON.stringify(name)}, () => {
 
   test(${JSON.stringify(stepTitle("create", entity.key, name))}, async ({ page, authedPage }) => {
     await authedPage.dashboard.goto();
+${parentSeedingCode}
     await navigateTo${entity.id}(page);
 
     // Capture WHY a create can silently fail: the api client throws on non-2xx and React Query
@@ -707,9 +725,7 @@ test.describe(${JSON.stringify(name)}, () => {
     // Wait for form to appear (form may be inline, no URL change)
     await page.getByTestId("${ids.form}").waitFor({ state: "visible", timeout: 5000 });
 
-${parentSeedingCode}
-
-    // Fill all fields
+    // Fill all fields (parents were seeded before navigation, above)
 ${fieldFillSteps}
 ${fillFirstFieldCode}    // Fill identity field with unique value
     await page.getByTestId("${ids.field(identityFieldName)}").fill(unique);
@@ -736,6 +752,7 @@ ${rowCellAssertions}
 
   test(${JSON.stringify(stepTitle("persist", entity.key, name))}, async ({ page, authedPage }) => {
     await authedPage.dashboard.goto();
+${parentSeedingCode}
     await navigateTo${entity.id}(page);
 
     const unique = ${uniqueValueConstruction};
@@ -744,8 +761,6 @@ ${rowCellAssertions}
     await page.getByTestId("${ids.create}").click();
     await page.getByTestId("${ids.form}").waitFor({ state: "visible", timeout: 5000 });
 
-${parentSeedingCode}
-
 ${fieldFillSteps}
 ${fillFirstFieldCode}    await page.getByTestId("${ids.field(identityFieldName)}").fill(unique);
 
@@ -794,6 +809,7 @@ ${entity.parents
 
   test(${JSON.stringify(stepTitle("update", entity.key, name))}, async ({ page, authedPage }) => {
     await authedPage.dashboard.goto();
+${parentSeedingCode}
     await navigateTo${entity.id}(page);
 
     // Create a record stamped with a unique value (identity field, not first field)
@@ -811,8 +827,6 @@ ${entity.parents
     await page.getByTestId("${ids.create}").click();
     await page.getByTestId("${ids.form}").waitFor({ state: "visible", timeout: 5000 });
 
-${parentSeedingCode}
-
 ${fieldFillSteps}
 ${fillFirstFieldCode}    await page.getByTestId("${ids.field(identityFieldName)}").fill(unique);
 
@@ -849,6 +863,7 @@ ${fillFirstFieldCode}    await page.getByTestId("${ids.field(identityFieldName)}
 
   test(${JSON.stringify(stepTitle("delete", entity.key, name))}, async ({ page, authedPage }) => {
     await authedPage.dashboard.goto();
+${parentSeedingCode}
     await navigateTo${entity.id}(page);
 
     const unique = ${uniqueValueConstruction};
@@ -857,8 +872,6 @@ ${fillFirstFieldCode}    await page.getByTestId("${ids.field(identityFieldName)}
     await page.getByTestId("${ids.create}").click();
     await page.getByTestId("${ids.form}").waitFor({ state: "visible", timeout: 5000 });
 
-${parentSeedingCode}
-
 ${fieldFillSteps}
 ${fillFirstFieldCode}    await page.getByTestId("${ids.field(identityFieldName)}").fill(unique);
 
diff --git a/packages/core/tests/boringstack-e2e-generator.test.ts b/packages/core/tests/boringstack-e2e-generator.test.ts
index 376be3ee..ce2e3e7d 100644
--- a/packages/core/tests/boringstack-e2e-generator.test.ts
+++ b/packages/core/tests/boringstack-e2e-generator.test.ts
@@ -2221,3 +2221,63 @@ describe("PART C: negative check hardening tests", () => {
     expect(spec).not.toContain('payload["email"] = false');
   });
 });
+
+describe("child-entity acceptance: parent-FK <select> ordering (Contact belongsTo Company)", () => {
+  // A child entity whose form has a company parent-FK rendered as a native <select>.
+  const contact: IEntityAcceptance = {
+    id: "Contact",
+    key: "contact",
+    nav: "Contacts",
+    fields: [
+      {
+        name: "companyId",
+        type: "string",
+        optional: false,
+        valid: "",
+        invalid: [],
+      },
+      {
+        name: "name",
+        type: "string",
+        optional: false,
+        valid: "Jane",
+        invalid: [],
+      },
+    ],
+    shows: ["name", "company"],
+    screens: ["list", "form"],
+    parents: [{ entity: "Company", key: "company", fkField: "companyId" }],
+    negatives: [{ field: "name", value: "", why: "name is required" }],
+    acceptanceCheck: "create a contact under a company",
+  };
+
+  test("seeds the parent via API BEFORE opening the create form (so the async company <select> already contains it)", () => {
+    // The bug this guards: seeding AFTER navigation left the child page's already-fetched
+    // company list without the seed, so the <option value={seededId}> never appeared and
+    // selectOption timed out (30s) → false park. The seed POST must precede the form-open.
+    const spec = generateEntitySpec(contact);
+    const seedIdx = spec.indexOf("/api/v1/company");
+    const formOpenIdx = spec.indexOf('getByTestId("contact-create")');
+
+    expect(seedIdx).toBeGreaterThan(-1);
+    expect(formOpenIdx).toBeGreaterThan(-1);
+    expect(seedIdx).toBeLessThan(formOpenIdx);
+  });
+
+  test("waits for the seeded <option> to attach before selectOption (no async-fetch race)", () => {
+    const spec = generateEntitySpec(contact);
+    const waitIdx = spec.indexOf('option[value="${companyId}"]');
+    const selectIdx = spec.indexOf(".selectOption(companyId)");
+
+    expect(waitIdx).toBeGreaterThan(-1);
+    expect(selectIdx).toBeGreaterThan(-1);
+    expect(waitIdx).toBeLessThan(selectIdx);
+  });
+
+  test("a single-entity slice (no parents) emits no FK <select> wait/selection — the fix is scoped to relational children", () => {
+    const spec = generateEntitySpec(company); // company has parents: []
+
+    expect(spec).not.toContain('option[value="${'); // no FK option-attached wait
+    expect(spec).not.toContain(".selectOption("); // no parent-FK selection at all
+  });
+});

From c47f32fdefb1ab077f6a225ef2c89ec201cc8303 Mon Sep 17 00:00:00 2001
From: Aleksandar Grbic <ag@dreamdata.io>
Date: Tue, 28 Jul 2026 15:54:17 +0200
Subject: [PATCH 2/2] fix(acceptance): stop the child-slice <select> note
 leaking into API-only negatives + strengthen ordering test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up to the seed-before-navigate fix (kept scoped to the per-entity spec, which is
what the build's slice acceptance uses):

- generateParentSeedingCode takes withSelectNote (default true). The negative blocks POST
  directly to the API (no navigation, no parent <select>), so generateEntitySpec seeds them
  with withSelectNote=false — the '<select>' rationale note would be misleading there.

- Strengthened the ordering regression test: assert the parent seed precedes navigateToContact
  in EVERY form-driven block (create/persist/update/delete), not just the first spec-wide
  occurrence. Added a test that the note is present in form tests but absent from the API-only
  negative block (which still seeds the parent). Reordered the Contact fixture so the FK is
  appended last (mirrors planToAcceptanceSpec.addParentFkFields) → identity resolves to name.

Deferred to task #84: FK-aware identity/first-field selection and chain-spec dangling-parent
hardening — a class of generator fragility for inputs planToAcceptanceSpec never produces
(FK-first ordering, dangling parents, all-FK entities). WIP preserved in git at cc5fcb73.

typecheck clean, lint clean, format clean, 3192/3205 suite green.
---
 .../boringstack/acceptance/e2e-generator.ts   | 23 +++++-
 .../tests/boringstack-e2e-generator.test.ts   | 77 ++++++++++++++++---
 2 files changed, 87 insertions(+), 13 deletions(-)

diff --git a/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts b/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts
index 655458f9..ed7eef2c 100644
--- a/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts
+++ b/packages/core/src/loop/boringstack/acceptance/e2e-generator.ts
@@ -175,7 +175,11 @@ function emitSpecParentSeed(
 function generateParentSeedingCode(
   parents: IParentRef[],
   entityId: string,
-  spec?: IAcceptanceSpec
+  spec?: IAcceptanceSpec,
+  // Prepend the "seed before navigate" rationale. Only the form-driven tests navigate to the
+  // child page and select from its async <select>; the API-only negative blocks POST directly
+  // and never render a select, so the <select> note would be misleading there → opt-out.
+  withSelectNote = true
 ): string {
   if (parents.length === 0) {
     return "";
@@ -228,6 +232,10 @@ function generateParentSeedingCode(
     return "";
   }
 
+  if (!withSelectNote) {
+    return codeBlocks.join("\n");
+  }
+
   // Callers place this BEFORE navigating to the child page: the child's parent <select> is
   // filled by an async list query on mount, so seeding first means that fetch already includes
   // the parents. An API seed AFTER navigation isn't reflected in the fetched list, so the
@@ -606,7 +614,18 @@ export function generateEntitySpec(
     entity.id,
     spec
   );
-  const negativeBlocks = generateNegativeBlocks(entity, parentSeedingCode);
+  // Negatives POST directly to the API (no navigation, no parent <select>), so seed without the
+  // form-oriented "<select>" rationale note — it would be misleading in an API-only block.
+  const negativeParentSeedingCode = generateParentSeedingCode(
+    entity.parents,
+    entity.id,
+    spec,
+    false
+  );
+  const negativeBlocks = generateNegativeBlocks(
+    entity,
+    negativeParentSeedingCode
+  );
 
   // FIX E/FIX 3: Type-aware unique identity value
   // Find the first field with a string/text type (NOT email by type or name) for the unique marker
diff --git a/packages/core/tests/boringstack-e2e-generator.test.ts b/packages/core/tests/boringstack-e2e-generator.test.ts
index ce2e3e7d..246c75e4 100644
--- a/packages/core/tests/boringstack-e2e-generator.test.ts
+++ b/packages/core/tests/boringstack-e2e-generator.test.ts
@@ -2224,23 +2224,26 @@ describe("PART C: negative check hardening tests", () => {
 
 describe("child-entity acceptance: parent-FK <select> ordering (Contact belongsTo Company)", () => {
   // A child entity whose form has a company parent-FK rendered as a native <select>.
+  // Field order mirrors a real derived spec: domain fields first, FK appended LAST
+  // (planToAcceptanceSpec's addParentFkFields pushes FK fields to the end), so the identity
+  // field resolves to `name` and the generated create test fills `name` (not the FK <select>).
   const contact: IEntityAcceptance = {
     id: "Contact",
     key: "contact",
     nav: "Contacts",
     fields: [
       {
-        name: "companyId",
+        name: "name",
         type: "string",
         optional: false,
-        valid: "",
+        valid: "Jane",
         invalid: [],
       },
       {
-        name: "name",
+        name: "companyId",
         type: "string",
         optional: false,
-        valid: "Jane",
+        valid: "",
         invalid: [],
       },
     ],
@@ -2251,17 +2254,69 @@ describe("child-entity acceptance: parent-FK <select> ordering (Contact belongsT
     acceptanceCheck: "create a contact under a company",
   };
 
-  test("seeds the parent via API BEFORE opening the create form (so the async company <select> already contains it)", () => {
+  // Extract one test block by a substring of its title, up to the next top-level `  test(`.
+  const extractBlock = (spec: string, titleMarker: string): string => {
+    const start = spec.indexOf(titleMarker);
+
+    if (start === -1) {
+      return "";
+    }
+
+    const rest = spec.slice(start);
+    const next = rest.indexOf("\n  test(", 1);
+
+    return next === -1 ? rest : rest.slice(0, next);
+  };
+
+  // Every test that navigates to the child page and fills its parent-FK <select>.
+  const formDrivenMarkers = [
+    "create Contact: form fill",
+    "Contact persists after page reload",
+    "update Contact: edit form",
+    "delete Contact: row delete",
+  ];
+
+  test("EVERY form-driven test seeds the parent via API BEFORE navigating to the child page (per-test, not just the first block)", () => {
     // The bug this guards: seeding AFTER navigation left the child page's already-fetched
     // company list without the seed, so the <option value={seededId}> never appeared and
-    // selectOption timed out (30s) → false park. The seed POST must precede the form-open.
+    // selectOption timed out (30s) → false park. Asserting only the first spec-wide occurrence
+    // would miss a persist/update/delete block that still seeds late — so check each block.
     const spec = generateEntitySpec(contact);
-    const seedIdx = spec.indexOf("/api/v1/company");
-    const formOpenIdx = spec.indexOf('getByTestId("contact-create")');
 
-    expect(seedIdx).toBeGreaterThan(-1);
-    expect(formOpenIdx).toBeGreaterThan(-1);
-    expect(seedIdx).toBeLessThan(formOpenIdx);
+    for (const marker of formDrivenMarkers) {
+      const block = extractBlock(spec, marker);
+
+      expect(block, `missing test block: ${marker}`).not.toBe("");
+
+      const seedIdx = block.indexOf("/api/v1/company");
+      const navIdx = block.indexOf("navigateToContact(page)");
+
+      expect(seedIdx, `${marker}: no parent seed`).toBeGreaterThan(-1);
+      expect(navIdx, `${marker}: no navigateToContact`).toBeGreaterThan(-1);
+      expect(
+        seedIdx,
+        `${marker}: parent seed must precede navigateToContact`
+      ).toBeLessThan(navIdx);
+    }
+  });
+
+  test("the parent-<select> rationale note appears in form-driven tests but NOT in the API-only negative block (which still seeds the parent)", () => {
+    const spec = generateEntitySpec(contact);
+    const note = "async parent-<select>";
+
+    // Present in the form-driven seeding (child page navigates + selects the <select>).
+    expect(spec).toContain(note);
+
+    // The negative block POSTs directly (no navigation, no <select>): it must still seed the
+    // parent for the FK payload, but omit the misleading <select> note.
+    const negIdx = spec.indexOf("negative: Contact rejects");
+
+    expect(negIdx).toBeGreaterThan(-1);
+
+    const negBlock = spec.slice(negIdx);
+
+    expect(negBlock).toContain("/api/v1/company"); // still seeds the parent for the FK payload
+    expect(negBlock).not.toContain(note); // but no misleading <select> rationale
   });
 
   test("waits for the seeded <option> to attach before selectOption (no async-fetch race)", () => {