@cosmicdrift/kumiko-renderer-web 0.193.0 → 0.194.0

package/src/__tests__/render-edit.test.tsx

@@ -1,4 +1,4 @@
-import { describe, expect, mock, test } from "bun:test";
+import { describe, expect, mock, spyOn, test } from "bun:test";
 import type {
   EntityDefinition,
   EntityEditScreenDefinition,
@@ -724,6 +724,39 @@ describe("RenderEdit — controlled mode (#1887)", () => {
     expect(controls?.getValues().count).toBe("Acme".length);
   });
 
+  test("onControlsReady fires before the mount-time onChange call (fw#1899)", () => {
+    // A prefilled `initial` derives a dependent field on mount via
+    // controls.patch() from inside onChange — this only works if controls
+    // are already handed out by the time onChange fires for the first time.
+    let mountTimeControlsWereDefined = false;
+    let onChangeCalls = 0;
+    let controls: RenderEditControls<TestValues> | undefined;
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <RenderEdit<TestValues>
+          screen={makeScreen()}
+          entity={orderEntity}
+          featureName="orders"
+          initial={{ title: "Acme", count: 0, isUrgent: false }}
+          writeCommand="order:create"
+          onChange={(state) => {
+            onChangeCalls += 1;
+            if (onChangeCalls === 1) {
+              mountTimeControlsWereDefined = controls !== undefined;
+              controls?.patch({ count: state.values.title.length });
+            }
+          }}
+          onControlsReady={(c) => {
+            controls = c;
+          }}
+        />
+      </DispatcherProvider>,
+    );
+
+    expect(mountTimeControlsWereDefined).toBe(true);
+    expect(controls?.getValues().count).toBe("Acme".length);
+  });
+
   test("controls.patch sets values from outside without losing edits already made in other fields", () => {
     let controls: RenderEditControls<TestValues> | undefined;
     render(
@@ -946,9 +979,9 @@ describe("RenderEdit — FieldConditions react to extension patch() (#1916)", ()
     );
   }
 
-  function renderVehicleForm(): void {
+  function renderVehicleForm(writeFn?: Dispatcher["write"], schema?: z.ZodType): void {
     render(
-      <DispatcherProvider dispatcher={makeDispatcher()}>
+      <DispatcherProvider dispatcher={makeDispatcher(writeFn)}>
         <ExtensionSectionsProvider value={{ VinDecodeSection }}>
           <RenderEdit<VehicleValues>
             screen={makeVehicleScreen()}
@@ -956,6 +989,7 @@ describe("RenderEdit — FieldConditions react to extension patch() (#1916)", ()
             featureName="vehicles"
             initial={{ title: "Listing", vin: "" }}
             writeCommand="vehicle:create"
+            {...(schema !== undefined && { schema })}
           />
         </ExtensionSectionsProvider>
       </DispatcherProvider>,
@@ -963,15 +997,13 @@ describe("RenderEdit — FieldConditions react to extension patch() (#1916)", ()
   }
 
   function isRequired(testId: string): boolean {
-    const label = screen.getByTestId(testId).querySelector("label");
-    return (label?.textContent ?? "").includes("*");
+    return screen.getByTestId(testId).querySelector("[data-required]") !== null;
   }
 
   function isDisabled(testId: string): boolean {
-    return (
-      (screen.getByTestId(testId).querySelector("input") as HTMLInputElement | null)?.disabled ??
-      false
-    );
+    const input = screen.getByTestId(testId).querySelector("input");
+    if (!input) throw new Error(`${testId} has no input`);
+    return (input as HTMLInputElement).disabled;
   }
 
   test("provider delivers a value: the gated field becomes visible and required, the source field locks", () => {
@@ -1021,6 +1053,44 @@ describe("RenderEdit — FieldConditions react to extension patch() (#1916)", ()
     expect(screen.queryByTestId("field-trim")).toBeNull();
     expect(isDisabled("field-vin")).toBe(false);
   });
+
+  // #1916's required condition must reach the validation record, not just
+  // the rendered asterisk — a regression where the extension patch() lands
+  // in the render model but not the values the schema validates against
+  // would stay green without this: the field would look required but submit
+  // would go through anyway. Mirrors buildFormSchema's conditional-required
+  // shape (form-schema.ts) with an inline schema, same as the other
+  // RenderEdit tests in this file — RenderEdit itself takes `schema` as a
+  // prop and does not derive one from the layout on its own.
+  test("clearing trim after a decode-hit blocks submit — the required condition is enforced, not just displayed", async () => {
+    const write = mock(async () => ({ isSuccess: true, data: { id: "1" } }) as never);
+    const schema = z
+      .object({ title: z.string().min(1) })
+      .passthrough()
+      .superRefine((values, ctx) => {
+        const v = values as { decodeStatus?: string; trim?: string };
+        if (v.decodeStatus === "hit" && (v.trim === undefined || v.trim === "")) {
+          ctx.addIssue({ code: "custom", path: ["trim"], message: '"trim" is required.' });
+        }
+      });
+    renderVehicleForm(write as unknown as Dispatcher["write"], schema);
+
+    act(() => {
+      fireEvent.click(screen.getByTestId("decode-hit"));
+    });
+    const trimInput = screen.getByTestId("field-trim").querySelector("input") as HTMLInputElement;
+    expect(isRequired("field-trim")).toBe(true);
+
+    fireEvent.change(trimInput, { target: { value: "" } });
+
+    await act(async () => {
+      fireEvent.submit(screen.getByTestId("render-edit-form"));
+      await Promise.resolve();
+    });
+
+    expect(write).not.toHaveBeenCalled();
+    expect(screen.getByTestId("field-trim-errors")).toBeTruthy();
+  });
 });
 
 describe("RenderEdit wizard mode", () => {
@@ -1326,6 +1396,10 @@ describe("RenderEdit wizard mode", () => {
 });
 
 describe("RenderEdit wizard draft", () => {
+  // Mirrors render-edit.tsx's own PATCH_DRAFT_SAVE_DEBOUNCE_MS (not
+  // exported) — tests below wait out a full window to catch stragglers.
+  const PATCH_DRAFT_SAVE_DEBOUNCE_MS = 500;
+
   function makeDraftWizardScreen(draft: boolean): EntityEditScreenDefinition {
     return {
       id: "orders:screen:order-wizard-draft",
@@ -1506,6 +1580,59 @@ describe("RenderEdit wizard draft", () => {
     expect(calls.some((c) => c.startsWith("form-draft:"))).toBe(false);
   });
 
+  // The restore effect's `if (controller.getSnapshot().isDirty) return;`
+  // guard (render-edit.tsx) — a user who starts typing before the
+  // form-draft:query:get round-trip resolves must not have their input
+  // clobbered by the stored draft landing afterwards.
+  test("typing while the restore query is in flight — the typed value wins over the stored draft", async () => {
+    let resolveRestore: (result: {
+      readonly isSuccess: true;
+      readonly data: { readonly draft: DraftBlob | null };
+    }) => void = () => {};
+    const restorePromise = new Promise<{
+      readonly isSuccess: true;
+      readonly data: { readonly draft: DraftBlob | null };
+    }>((resolve) => {
+      resolveRestore = resolve;
+    });
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "form-draft:query:get") return restorePromise;
+        return { isSuccess: true, data: {} };
+      }) as Dispatcher["query"],
+      write: (async () => ({ isSuccess: true, data: { id: "1" } })) as Dispatcher["write"],
+    });
+
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <RenderEdit<TestValues>
+          screen={makeDraftWizardScreen(true)}
+          entity={orderEntity}
+          featureName="orders"
+          initial={{ title: "", count: 0 }}
+          entityId="order-1"
+          writeCommand="order:update"
+        />
+      </DispatcherProvider>,
+    );
+
+    const titleInput = screen.getByTestId("field-title").querySelector("input") as HTMLInputElement;
+    fireEvent.change(titleInput, { target: { value: "Typed while loading" } });
+
+    resolveRestore({
+      isSuccess: true,
+      data: { draft: { values: { title: "From storage", count: 9 }, stepIndex: 1 } },
+    });
+    // The step advancing to 2 only happens once setValues/setRawStep from
+    // the restore effect actually ran — waiting for it proves the restore
+    // fully landed before asserting the title was left untouched.
+    await waitFor(() =>
+      expect(screen.getByTestId("render-edit-wizard-step-label").textContent).toContain("2"),
+    );
+
+    expect(titleInput.value).toBe("Typed while loading");
+  });
+
   // Issue #1914: patch() (controlled mode / extension sections) previously
   // never triggered a draft save — only handleWizardNext/Back did. A patch()
   // on the last step (no further Next click coming) or on a step abandoned
@@ -1609,6 +1736,38 @@ describe("RenderEdit wizard draft", () => {
     );
   });
 
+  test("a draftKey over the server's 256-char limit is not sent — warns and skips instead of failing silently server-side (fw#1903)", async () => {
+    const { dispatcher, calls } = makeDraftDispatcher();
+    let controls: RenderEditControls<TestValues> | undefined;
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      render(
+        <DispatcherProvider dispatcher={dispatcher}>
+          <RenderEdit<TestValues>
+            screen={{ ...makeDraftWizardScreen(true), id: `orders:screen:${"x".repeat(300)}` }}
+            entity={orderEntity}
+            featureName="orders"
+            initial={{ title: "", count: 0 }}
+            writeCommand="order:create"
+            onControlsReady={(c) => {
+              controls = c;
+            }}
+          />
+        </DispatcherProvider>,
+      );
+
+      act(() => {
+        controls?.patch({ count: 1 });
+      });
+
+      await waitFor(() => expect(warnSpy).toHaveBeenCalled(), { timeout: 3000 });
+      expect(calls.filter((c) => c === "form-draft:write:save").length).toBe(0);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
   test("a burst of patch() calls collapses into a single debounced draft save", async () => {
     const { dispatcher, calls } = makeDraftDispatcher();
     let controls: RenderEditControls<TestValues> | undefined;
@@ -1641,6 +1800,63 @@ describe("RenderEdit wizard draft", () => {
 
     await waitFor(() => expect(savesSoFar()).toBe(before + 1), { timeout: 3000 });
     expect(savesSoFar()).toBe(before + 1);
+
+    // The debounce collapses bursts into one save, but a save landing in a
+    // LATER window (the burst's tail re-arming the timer, or an unrelated
+    // second burst) would slip past an assertion taken right after the
+    // first save. Wait out a full extra debounce window to prove there is
+    // no straggler.
+    await new Promise((resolve) => setTimeout(resolve, PATCH_DRAFT_SAVE_DEBOUNCE_MS + 200));
+    expect(savesSoFar()).toBe(before + 1);
+  });
+
+  // #1914's debounce must not resurrect a draft after it was intentionally
+  // ended: discardDraft() clears the pending timer (render-edit.tsx:735-738)
+  // specifically so a patch() immediately followed by submit can't have its
+  // debounced save land AFTER the discard and leave an orphaned row behind.
+  test("a pending debounced patch-save is killed by submit's discard, not resurrected later", async () => {
+    const { dispatcher, store, calls } = makeDraftDispatcher();
+    let controls: RenderEditControls<TestValues> | undefined;
+
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <RenderEdit<TestValues>
+          screen={makeDraftWizardScreen(true)}
+          entity={orderEntity}
+          featureName="orders"
+          initial={{ title: "Acme", count: 0 }}
+          writeCommand="order:create"
+          onControlsReady={(c) => {
+            controls = c;
+          }}
+        />
+      </DispatcherProvider>,
+    );
+
+    fireEvent.click(screen.getByTestId("render-edit-wizard-next"));
+    expect(screen.getByTestId("field-count")).toBeTruthy();
+
+    // patch() arms a 500ms debounced draft save, then submit fires well
+    // inside that window — before the timer could ever run on its own.
+    act(() => {
+      controls?.patch({ count: 9 });
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByTestId("render-edit-submit"));
+      await Promise.resolve();
+    });
+
+    expect(calls).toContain("form-draft:write:discard");
+    const savesAtSubmit = calls.filter((c) => c === "form-draft:write:save").length;
+    expect(store.current).toBeNull();
+
+    // Wait past the debounce window the patch() call armed. If discard
+    // hadn't cleared the timer, a straggling save would land here and
+    // resurrect the just-discarded draft.
+    await new Promise((resolve) => setTimeout(resolve, PATCH_DRAFT_SAVE_DEBOUNCE_MS + 200));
+
+    expect(calls.filter((c) => c === "form-draft:write:save").length).toBe(savesAtSubmit);
+    expect(store.current).toBeNull();
   });
 
   // A rejected discard write (network error) must be best-effort: the entity
@@ -1864,6 +2080,71 @@ describe("RenderEdit create-mode draftId (issue #1913)", () => {
     expect(titles).toEqual(["Session A", "Session B"]);
   });
 
+  // Same-tab variant of the test above: two RenderEdit instances sharing
+  // ONE DraftStorage AND one dispatcher — the layout a single browser tab
+  // with two open create forms actually has (a fresh DraftStorage per
+  // session only happens across tabs). The mint keys off each component's
+  // own `draftId` React state, not a re-read of the shared storage slot, so
+  // this must isolate too.
+  test("two parallel create sessions sharing one DraftStorage still get different draftKeys (#1908)", async () => {
+    const { dispatcher, drafts } = makeMultiDraftDispatcher();
+    const screenDef = makeDraftWizardScreen();
+    const sharedDraftStorage = createFakeDraftStorage();
+
+    const sessionA = render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DraftStorageProvider value={sharedDraftStorage}>
+          <RenderEdit<TestValues>
+            screen={screenDef}
+            entity={orderEntity}
+            featureName="orders"
+            initial={{ title: "", count: 0 }}
+            writeCommand="order:create"
+          />
+        </DraftStorageProvider>
+      </DispatcherProvider>,
+    );
+    const sessionB = render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DraftStorageProvider value={sharedDraftStorage}>
+          <RenderEdit<TestValues>
+            screen={screenDef}
+            entity={orderEntity}
+            featureName="orders"
+            initial={{ title: "", count: 0 }}
+            writeCommand="order:create"
+          />
+        </DraftStorageProvider>
+      </DispatcherProvider>,
+    );
+
+    const titleA = within(sessionA.container)
+      .getByTestId("field-title")
+      .querySelector("input") as HTMLInputElement;
+    fireEvent.change(titleA, { target: { value: "Session A" } });
+    await act(async () => {
+      fireEvent.submit(within(sessionA.container).getByTestId("render-edit-form"));
+      await Promise.resolve();
+    });
+
+    const titleB = within(sessionB.container)
+      .getByTestId("field-title")
+      .querySelector("input") as HTMLInputElement;
+    fireEvent.change(titleB, { target: { value: "Session B" } });
+    await act(async () => {
+      fireEvent.submit(within(sessionB.container).getByTestId("render-edit-form"));
+      await Promise.resolve();
+    });
+
+    const prefix = `${screenDef.id}:new:`;
+    const createDraftKeys = [...drafts.keys()].filter((k) => k.startsWith(prefix));
+    expect(createDraftKeys).toHaveLength(2);
+    const [keyA, keyB] = createDraftKeys as [string, string];
+    expect(keyA).not.toBe(keyB);
+    const titles = createDraftKeys.map((k) => drafts.get(k)?.values["title"]).sort();
+    expect(titles).toEqual(["Session A", "Session B"]);
+  });
+
   test("cleared storage with exactly one open draft still shows the picker — no silent cross-tab adopt", async () => {
     const { dispatcher, drafts } = makeMultiDraftDispatcher();
     const screenDef = makeDraftWizardScreen();
@@ -2159,6 +2440,60 @@ describe("RenderEdit create-mode draftId (issue #1913)", () => {
 
     expect([...drafts.keys()]).toEqual([`${screenDef.id}:order-77`]);
   });
+
+  // draftKey is `${screen.id}:${entityId}` — opening a different entity on
+  // the same screen must not resume the previous entity's saved draft.
+  test("switching entityId does not load the previous entity's draft", async () => {
+    const { dispatcher, drafts } = makeMultiDraftDispatcher();
+    const screenDef = makeDraftWizardScreen();
+    drafts.set(`${screenDef.id}:order-A`, {
+      values: { title: "Draft for A", count: 1 },
+      stepIndex: 0,
+      savedAt: "2026-01-01T00:00:00Z",
+    });
+
+    const first = render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DraftStorageProvider value={createFakeDraftStorage()}>
+          <RenderEdit<TestValues>
+            screen={screenDef}
+            entity={orderEntity}
+            featureName="orders"
+            initial={{ title: "", count: 0 }}
+            entityId="order-A"
+            writeCommand="order:update"
+          />
+        </DraftStorageProvider>
+      </DispatcherProvider>,
+    );
+
+    await waitFor(() =>
+      expect(
+        (screen.getByTestId("field-title").querySelector("input") as HTMLInputElement).value,
+      ).toBe("Draft for A"),
+    );
+    first.unmount();
+
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DraftStorageProvider value={createFakeDraftStorage()}>
+          <RenderEdit<TestValues>
+            screen={screenDef}
+            entity={orderEntity}
+            featureName="orders"
+            initial={{ title: "", count: 0 }}
+            entityId="order-B"
+            writeCommand="order:update"
+          />
+        </DraftStorageProvider>
+      </DispatcherProvider>,
+    );
+
+    const titleInputB = screen
+      .getByTestId("field-title")
+      .querySelector("input") as HTMLInputElement;
+    expect(titleInputB.value).toBe("");
+  });
 });
 
 describe("RenderEdit locked state (#1896)", () => {

package/src/__tests__/test-utils.tsx

@@ -112,6 +112,26 @@ export function renderWithSidebar(
   return _render(ui, { wrapper: SidebarProviders, ...options });
 }
 
+// Nested PrimitivesProvider overrides the outer DefaultProviders one for
+// this subtree — for tests exercising a fallback when a primitive isn't
+// registered (e.g. StepBar undefined on an older PrimitivesRegistry).
+export function renderWithPrimitivesOverride(
+  ui: ReactElement,
+  primitivesOverride: Partial<typeof defaultPrimitives>,
+  options?: Omit<RenderOptions, "wrapper">,
+): RenderResult {
+  function Wrapper({ children }: { readonly children: ReactNode }): ReactNode {
+    return (
+      <DefaultProviders>
+        <PrimitivesProvider value={{ ...defaultPrimitives, ...primitivesOverride }}>
+          {children}
+        </PrimitivesProvider>
+      </DefaultProviders>
+    );
+  }
+  return _render(ui, { wrapper: Wrapper, ...options });
+}
+
 // ---------------------------------------------------------------------------
 // Mock-Dispatcher-Helper
 // ---------------------------------------------------------------------------

package/src/__tests__/wizard-form-validation.test.tsx

@@ -8,10 +8,11 @@ import type {
   EntityDefinition,
   EntityEditScreenDefinition,
 } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
 import type { FeatureSchema } from "@cosmicdrift/kumiko-renderer";
 import { DispatcherProvider, KumikoScreen } from "@cosmicdrift/kumiko-renderer";
 import userEvent from "@testing-library/user-event";
-import { createMockDispatcher, render, screen } from "./test-utils";
+import { createMockDispatcher, render, renderWithPrimitivesOverride, screen } from "./test-utils";
 
 const profileEntity = {
   fields: {
@@ -70,6 +71,84 @@ describe("entityEdit wizard — presence validation on Next (fw#1910)", () => {
     expect(screen.getByTestId("render-edit-wizard-step-label").textContent).toContain("2");
     expect(screen.queryByTestId("field-fullName-errors")).toBeNull();
   });
+
+  // handleWizardNext validates only the CURRENT step's fields
+  // (render-edit.tsx:679) — an unscoped controller.validate() regression
+  // would block Next on step 1 for a required field that only exists on
+  // step 2, permanently stuck on step 1. Submit must still enforce it.
+  test("a required field on a later step never blocks Next on an earlier step, but blocks submit", async () => {
+    const requiredEmailEntity = {
+      fields: {
+        fullName: { type: "text", required: true },
+        email: { type: "text", required: true },
+      },
+    } as unknown as EntityDefinition;
+    const requiredEmailSchema: FeatureSchema = {
+      featureName: "demo",
+      entities: { profile: requiredEmailEntity },
+      screens: [wizardScreen],
+    };
+    const { container } = render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <KumikoScreen schema={requiredEmailSchema} qn="demo:screen:profile-edit" />
+      </DispatcherProvider>,
+    );
+
+    const fullNameInput = container.querySelector("#kumiko-edit-fullName");
+    await userEvent.type(fullNameInput as Element, "Ada Lovelace");
+    await userEvent.click(screen.getByTestId("render-edit-wizard-next"));
+
+    expect(screen.getByTestId("render-edit-wizard-step-label").textContent).toContain("2");
+
+    await userEvent.click(screen.getByTestId("render-edit-submit"));
+
+    expect(screen.getByTestId("render-edit-wizard-step-label").textContent).toContain("2");
+    expect(screen.getByTestId("field-email-errors")).toBeTruthy();
+  });
+
+  // `fieldset[disabled]` also excludes its descendants' controls from a real
+  // `new FormData(form)` / native form submission — if render-edit's submit
+  // path ever read values that way instead of from controller/React state,
+  // disabling step 1's fieldset after Next would silently drop fullName on
+  // submit. Assert on the value the dispatcher actually receives, not just
+  // that step 2 shows no error.
+  test("submitting from a later step still sends an earlier step's value to the dispatcher", async () => {
+    const calls: Array<[string, unknown]> = [];
+    const write = (async (type: string, payload: unknown) => {
+      calls.push([type, payload]);
+      return { isSuccess: true, data: {} };
+    }) as unknown as Dispatcher["write"];
+    const { container } = render(
+      <DispatcherProvider dispatcher={createMockDispatcher({ write })}>
+        <KumikoScreen schema={schema} qn="demo:screen:profile-edit" />
+      </DispatcherProvider>,
+    );
+
+    const fullNameInput = container.querySelector("#kumiko-edit-fullName");
+    await userEvent.type(fullNameInput as Element, "Ada Lovelace");
+    await userEvent.click(screen.getByTestId("render-edit-wizard-next"));
+    await userEvent.click(screen.getByTestId("render-edit-submit"));
+
+    expect(calls).toHaveLength(1);
+    const [, payload] = calls[0] as [string, Record<string, unknown>];
+    expect(payload["fullName"]).toBe("Ada Lovelace");
+  });
+
+  // fw high-severity finding: `hidden` alone does not bar a field from the
+  // browser's native constraint validation, so a required field on an
+  // off-screen step blocked the whole form's `type="submit"` Next button —
+  // jsdom doesn't implement constraint validation, so this only reproduces
+  // as a DOM-shape check (fieldset[disabled] ancestor), not the actual
+  // browser-blocks-navigation symptom.
+  test("an off-screen step's fields sit inside a disabled fieldset, the current step's don't", async () => {
+    renderWizard();
+
+    const hiddenStepField = screen.getByTestId("field-email").closest("fieldset");
+    expect(hiddenStepField?.disabled).toBe(true);
+
+    const currentStepField = screen.getByTestId("field-fullName").closest("fieldset");
+    expect(currentStepField?.disabled).toBe(false);
+  });
 });
 
 // fw#1966: the wizard chrome used to only show a "Step X of Y" counter —
@@ -133,4 +212,53 @@ describe("entityEdit wizard — step bar (fw#1966)", () => {
     const steps = container.querySelectorAll('[data-testid^="render-edit-wizard-steps-step-"]');
     expect(steps.length).toBe(3);
   });
+
+  // fw#1967: a PrimitivesRegistry without StepBar (older/custom registry)
+  // must stay on the plain "Step X of Y" label RenderEdit always had —
+  // this is the changeset's stated backward-compat guarantee.
+  test("falls back to the plain step label when the registry doesn't supply StepBar", () => {
+    renderWithPrimitivesOverride(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <KumikoScreen schema={schema} qn="demo:screen:profile-edit" />
+      </DispatcherProvider>,
+      { StepBar: undefined },
+    );
+
+    expect(screen.getByTestId("render-edit-wizard-step-label").textContent).toBe(
+      "Step 1 of 2 · Step 1",
+    );
+    expect(screen.queryByTestId("render-edit-wizard-steps-step-0")).toBeNull();
+  });
+
+  // fw#1967: a titleless section used to fall back to the stringified step
+  // number, duplicating the StepBar's own numbered badge ("3 3"). The
+  // fallback is now an empty label — only the badge shows.
+  test("a titleless section shows only the step number, not a duplicated digit", () => {
+    const untitledStepScreen: EntityEditScreenDefinition = {
+      id: "profile-edit-untitled",
+      type: "entityEdit",
+      entity: "profile",
+      layout: {
+        mode: "wizard",
+        sections: [
+          { title: "Basics", fields: ["fullName"] },
+          { title: "Contact", fields: ["email"] },
+          { fields: [] },
+        ],
+      },
+    };
+    const untitledStepSchema: FeatureSchema = {
+      featureName: "demo",
+      entities: { profile: profileEntity },
+      screens: [untitledStepScreen],
+    };
+
+    render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <KumikoScreen schema={untitledStepSchema} qn="demo:screen:profile-edit-untitled" />
+      </DispatcherProvider>,
+    );
+
+    expect(screen.getByTestId("render-edit-wizard-steps-step-2").textContent).toBe("3");
+  });
 });

package/src/app/__tests__/merge-content-editors.test.ts

@@ -19,7 +19,7 @@ describe("mergeContentEditors", () => {
     expect(merged["rich"]).toBe(richEditor);
   });
 
-  test("Key-Kollision → warnt + last-wins gewinnt", () => {
+  test("key collision → warns + last-wins applies", () => {
     const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
     const first = editor();
     const second = editor();
@@ -37,7 +37,7 @@ describe("mergeContentEditors", () => {
     warnSpy.mockRestore();
   });
 
-  test("clientFeatures ohne contentEditors werden übersprungen", () => {
+  test("clientFeatures without contentEditors are skipped", () => {
     const features: ClientFeatureDefinition[] = [{ name: "a" }];
     expect(mergeContentEditors(features)).toEqual({});
   });

package/src/app/__tests__/plain-content-editor.test.tsx

@@ -32,6 +32,10 @@ describe("PlainContentEditor", () => {
     textarea.setSelectionRange(6, 6);
     fireEvent.click(screen.getByText("{{name}}"));
     expect(textarea.value).toBe("Hello {{name}} world");
+    // Caret-restore effect: focus + selection must land right after the
+    // inserted placeholder, not wherever the DOM happened to leave it.
+    expect(textarea.selectionStart).toBe(14);
+    expect(textarea.selectionEnd).toBe(14);
   });
 
   test("chip click replaces a selection instead of inserting alongside it", () => {

package/src/app/__tests__/rich-content-editor.test.tsx

@@ -15,7 +15,10 @@ describe("RichContentEditor", () => {
     );
     // The textarea id proves #1794's "never an empty panel" fallback is the
     // Suspense boundary — a null fallback would leave nothing to find here.
-    expect(document.getElementById(CONTENT_EDITOR_ELEMENT_ID)).not.toBeNull();
-    expect(await screen.findByText("hello")).toBeTruthy();
+    // TiptapEditor puts the same id on its contenteditable, so asserting
+    // presence alone wouldn't distinguish the two; assert the tag instead.
+    expect(document.getElementById(CONTENT_EDITOR_ELEMENT_ID)?.tagName).toBe("TEXTAREA");
+    const editable = await screen.findByText("hello");
+    expect(editable.closest('[contenteditable="true"]')).not.toBeNull();
   });
 });