@cosmicdrift/kumiko-headless 0.328.0 → 0.329.0

package/src/view-model/__tests__/edit.test.ts

@@ -1,1072 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  EntityDefinition,
-  EntityEditScreenDefinition,
-  RowAction,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import { computeEditViewModel } from "../edit";
-import type {
-  EditFieldsSectionViewModel,
-  EditRelatedListSectionViewModel,
-  EditSectionViewModel,
-  EditWriteFormSectionViewModel,
-} from "../types";
-
-function asFields(s: EditSectionViewModel | undefined): EditFieldsSectionViewModel {
-  if (s === undefined || s.kind !== "fields") {
-    throw new Error(`expected fields-section, got ${s?.kind ?? "undefined"}`);
-  }
-  return s;
-}
-
-const orderEntity = {
-  fields: {
-    customerName: { type: "text", required: true },
-    notes: { type: "text" },
-    vatExempt: { type: "boolean" },
-    vatReason: { type: "text" },
-    kind: { type: "text" },
-  },
-} as unknown as EntityDefinition;
-
-function editScreen(
-  layout: EntityEditScreenDefinition["layout"],
-  overrides?: Partial<EntityEditScreenDefinition>,
-): EntityEditScreenDefinition {
-  return {
-    id: "orders:screen:order-edit",
-    type: "entityEdit",
-    entity: "order",
-    layout,
-    ...overrides,
-  };
-}
-
-const translate = (key: string) => key;
-
-describe("computeEditViewModel", () => {
-  test("flat screen: single section, string-form fields → resolved field view models", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [{ title: "Hauptdaten", fields: ["customerName", "notes"] }],
-      }),
-      entity: orderEntity,
-      values: { customerName: "Acme", notes: "VIP" },
-      translate,
-      featureName: "orders",
-    });
-
-    expect(vm.sections).toHaveLength(1);
-    const section = vm.sections[0];
-    expect(section?.title).toBe("Hauptdaten");
-    expect(asFields(section).columns).toBe(1); // default
-    expect(asFields(section).fields).toEqual([
-      {
-        field: "customerName",
-        label: "orders:entity:order:field:customerName",
-        type: "text",
-        value: "Acme",
-        visible: true,
-        readOnly: false,
-        required: true, // from entity
-      },
-      {
-        field: "notes",
-        label: "orders:entity:order:field:notes",
-        type: "text",
-        value: "VIP",
-        visible: true,
-        readOnly: false,
-        required: false,
-      },
-    ]);
-  });
-
-  test("fieldLabels override the convention key per field; absent fields fall back", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen(
-        { sections: [{ title: "Main", fields: ["customerName", "notes"] }] },
-        { fieldLabels: { customerName: "config:mask:customer-name" } },
-      ),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const fields = asFields(vm.sections[0]).fields;
-    // overridden field uses the injected i18n key (the Settings-Hub puts mask.title here)
-    expect(fields[0]?.label).toBe("config:mask:customer-name");
-    // un-overridden field stays on the `<feature>:entity:<entity>:field:<name>` convention
-    expect(fields[1]?.label).toBe("orders:entity:order:field:notes");
-  });
-
-  test("section.columns override is respected; defaults to 1 when absent", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          { title: "Main", columns: 2, fields: ["customerName"] },
-          { title: "Notes", fields: ["notes"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asFields(vm.sections[0]).columns).toBe(2);
-    expect(asFields(vm.sections[1]).columns).toBe(1);
-  });
-
-  // The two-column default came in with projectionDetail tabs and now also
-  // covers entityEdit tabs (fw#3134) — a tab is its own panel, where a stacked
-  // form's single column wastes the width.
-  test("a tabs layout defaults sections to 2 columns, not 1", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        mode: "tabs",
-        sections: [
-          { id: "main", title: "Main", fields: ["customerName"] },
-          { id: "notes", title: "Notes", columns: 1, fields: ["notes"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asFields(vm.sections[0]).columns).toBe(2);
-    expect(asFields(vm.sections[1]).columns).toBe(1);
-  });
-
-  test("tabs sections carry their declared id into the view model", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        mode: "tabs",
-        sections: [
-          { id: "main", title: "Main", fields: ["customerName"] },
-          { id: "notes", title: "Notes", fields: ["notes"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asFields(vm.sections[0]).id).toBe("main");
-    expect(asFields(vm.sections[1]).id).toBe("notes");
-  });
-
-  test("visible predicate evaluated against current values (live-reactive)", () => {
-    const screen = editScreen({
-      sections: [
-        {
-          title: "VAT",
-          fields: [
-            "vatExempt",
-            {
-              field: "vatReason",
-              visible: { field: "vatExempt", eq: true },
-              required: { field: "vatExempt", eq: true },
-            },
-          ],
-        },
-      ],
-    });
-
-    const hidden = computeEditViewModel({
-      screen,
-      entity: orderEntity,
-      values: { vatExempt: false },
-      translate,
-      featureName: "orders",
-    });
-    const reasonHidden = asFields(hidden.sections[0]).fields[1];
-    expect(reasonHidden?.visible).toBe(false);
-    expect(reasonHidden?.required).toBe(false);
-
-    const shown = computeEditViewModel({
-      screen,
-      entity: orderEntity,
-      values: { vatExempt: true },
-      translate,
-      featureName: "orders",
-    });
-    const reasonShown = asFields(shown.sections[0]).fields[1];
-    expect(reasonShown?.visible).toBe(true);
-    expect(reasonShown?.required).toBe(true);
-  });
-
-  test("section with all fields hidden by visible condition → section.visible is false but section stays in the array (key stability)", () => {
-    const screen = editScreen({
-      sections: [
-        {
-          title: "Person",
-          fields: [{ field: "customerName", visible: { field: "kind", eq: "person" } }],
-        },
-        {
-          title: "Firma",
-          fields: [{ field: "notes", visible: { field: "kind", eq: "company" } }],
-        },
-      ],
-    });
-
-    const vm = computeEditViewModel({
-      screen,
-      entity: orderEntity,
-      values: { kind: "person", customerName: "Acme" },
-      translate,
-      featureName: "orders",
-    });
-
-    expect(vm.sections).toHaveLength(2);
-    expect(asFields(vm.sections[0]).visible).toBe(true);
-    expect(asFields(vm.sections[1]).visible).toBe(false);
-    expect(vm.sections[1]?.title).toBe("Firma");
-  });
-
-  test("readonly condition { field, ne } evaluates against form values", () => {
-    const screen = editScreen({
-      sections: [
-        {
-          title: "x",
-          fields: [{ field: "customerName", readOnly: { field: "isEditable", ne: true } }],
-        },
-      ],
-    });
-
-    const locked = computeEditViewModel({
-      screen,
-      entity: orderEntity,
-      values: { customerName: "A", isEditable: false },
-      translate,
-      featureName: "orders",
-    });
-    expect(asFields(locked.sections[0]).fields[0]?.readOnly).toBe(true);
-
-    const editable = computeEditViewModel({
-      screen,
-      entity: orderEntity,
-      values: { customerName: "A", isEditable: true },
-      translate,
-      featureName: "orders",
-    });
-    expect(asFields(editable.sections[0]).fields[0]?.readOnly).toBe(false);
-  });
-
-  test("screen-level required override wins over entity-level required", () => {
-    // customerName is required:true on the entity. Screen marks it
-    // required:false — a short-form wizard might collect less up-front.
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            title: "x",
-            fields: [{ field: "customerName", required: false }],
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asFields(vm.sections[0]).fields[0]?.required).toBe(false);
-  });
-
-  test("id is extracted from values or null on create (no existing row)", () => {
-    const create = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["customerName"] }] }),
-      entity: orderEntity,
-      values: { customerName: "new" },
-      translate,
-      featureName: "orders",
-    });
-    expect(create.id).toBeNull();
-
-    const edit = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["customerName"] }] }),
-      entity: orderEntity,
-      values: { id: "o-1", customerName: "existing" },
-      translate,
-      featureName: "orders",
-    });
-    expect(edit.id).toBe("o-1");
-  });
-
-  test("unknown field in a section throws — no silent-ignore of a typo", () => {
-    expect(() =>
-      computeEditViewModel({
-        screen: editScreen({ sections: [{ title: "x", fields: ["ghost"] }] }),
-        entity: orderEntity,
-        values: {},
-        translate,
-        featureName: "orders",
-      }),
-    ).toThrow(/unknown field "ghost"/);
-  });
-
-  test("slots pass through for the renderer to mount", () => {
-    const slots = { header: { react: "H" } };
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["customerName"] }] }, { slots }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-    expect(vm.slots).toBe(slots);
-  });
-
-  test("span on field-spec propagates to the view model", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [{ title: "x", columns: 3, fields: [{ field: "customerName", span: 2 }] }],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-    expect(asFields(vm.sections[0]).fields[0]?.span).toBe(2);
-  });
-
-  test("section.description is translated and passed through; absent stays undefined", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            title: "Basics",
-            description: "orders:screen:order-edit.basics.help",
-            fields: ["notes"],
-          },
-          { title: "Extra", fields: ["kind"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-    expect(asFields(vm.sections[0]).description).toBe("orders:screen:order-edit.basics.help");
-    expect(asFields(vm.sections[1]).description).toBeUndefined();
-  });
-
-  test("field.icon propagates to the view model; absent stays undefined", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [{ title: "x", fields: [{ field: "customerName", icon: "user" }, "notes"] }],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-    const fields = asFields(vm.sections[0]).fields;
-    expect(fields[0]?.icon).toBe("user");
-    expect(fields[1]?.icon).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — date/timestamp min/max/locale (#369)", () => {
-  test("date-Field reicht min/max/locale ins ViewModel", () => {
-    const entity = {
-      fields: {
-        born: { type: "date", min: "1900-01-01", max: "2026-06-15", locale: "en-US" },
-      },
-    } as unknown as EntityDefinition;
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "X", fields: ["born"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.min).toBe("1900-01-01");
-    expect(field?.max).toBe("2026-06-15");
-    expect(field?.dateLocale).toBe("en-US");
-  });
-
-  test("date-Field ohne bounds: min/max/dateLocale bleiben weg", () => {
-    const entity = {
-      fields: { born: { type: "date" } },
-    } as unknown as EntityDefinition;
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "X", fields: ["born"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.min).toBeUndefined();
-    expect(field?.max).toBeUndefined();
-    expect(field?.dateLocale).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — embedded-list cells (#1835)", () => {
-  const lineFieldSchema = {
-    description: { type: "text", required: true },
-    quantity: { type: "number", required: true },
-    unit: { type: "select", options: ["hour", "day"] },
-    product: { type: "reference", entity: "product", labelField: "name" },
-  };
-
-  function embeddedListEntity(overrides?: Record<string, unknown>): EntityDefinition {
-    return {
-      fields: {
-        lines: {
-          type: "embedded",
-          multiple: true,
-          schema: lineFieldSchema,
-          ...overrides,
-        },
-      },
-    } as unknown as EntityDefinition;
-  }
-
-  test("multiple: true embedded field → embeddedListCells has one entry per schema key with correct type/required/options/optionLabels/refEntity", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity: embeddedListEntity(),
-      values: { lines: [] },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.type).toBe("embedded");
-    const cells = field?.embeddedListCells;
-    expect(cells).toHaveLength(4);
-
-    const byField = Object.fromEntries((cells ?? []).map((cell) => [cell.field, cell]));
-    expect(byField["description"]).toMatchObject({
-      type: "text",
-      required: true,
-      label: "orders:entity:order:field:lines:cell:description",
-    });
-    expect(byField["quantity"]).toMatchObject({ type: "number", required: true });
-    expect(byField["unit"]).toMatchObject({
-      type: "select",
-      required: false,
-      options: ["hour", "day"],
-      optionLabels: { hour: "hour", day: "day" },
-    });
-    expect(byField["product"]).toMatchObject({
-      type: "reference",
-      required: false,
-      refEntity: "product",
-      refFeature: "orders",
-      refLabelField: "name",
-    });
-    expect(byField["product"]?.refOptionsQuery).toBeUndefined();
-  });
-
-  test("a reference sub-field's optionsQuery reaches the cell view-model (fw#2780)", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity: embeddedListEntity({
-        schema: {
-          ...lineFieldSchema,
-          product: {
-            type: "reference",
-            entity: "product",
-            labelField: "name",
-            optionsQuery: "orders:query:product:options",
-          },
-        },
-      }),
-      values: { lines: [] },
-      translate,
-      featureName: "orders",
-    });
-
-    const cells = asFields(vm.sections[0]).fields[0]?.embeddedListCells;
-    const product = (cells ?? []).find((cell) => cell.field === "product");
-    expect(product?.refOptionsQuery).toBe("orders:query:product:options");
-  });
-
-  test("minItems/maxItems/derived/totals pass through onto the field view-model when set", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity: embeddedListEntity({
-        minItems: 1,
-        maxItems: 20,
-        derived: { total: { op: "multiply", from: ["quantity", "unitPrice"] } },
-        totals: ["quantity", "total"],
-      }),
-      values: { lines: [] },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.embeddedListMinItems).toBe(1);
-    expect(field?.embeddedListMaxItems).toBe(20);
-    expect(field?.embeddedListDerived).toEqual({
-      total: { op: "multiply", from: ["quantity", "unitPrice"] },
-    });
-    expect(field?.embeddedListTotals).toEqual(["quantity", "total"]);
-  });
-
-  test("minItems/maxItems/derived/totals stay undefined when not declared", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity: embeddedListEntity(),
-      values: { lines: [] },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.embeddedListMinItems).toBeUndefined();
-    expect(field?.embeddedListMaxItems).toBeUndefined();
-    expect(field?.embeddedListDerived).toBeUndefined();
-    expect(field?.embeddedListTotals).toBeUndefined();
-  });
-
-  test("a plain (non-list) embedded field never gets embeddedListCells — that's how the renderer tells it apart from an embedded list", () => {
-    const entity = {
-      fields: {
-        meta: { type: "embedded", schema: { note: { type: "text" } } },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["meta"] }] }),
-      entity,
-      values: { meta: {} },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.type).toBe("embedded");
-    expect(field?.embeddedListCells).toBeUndefined();
-    expect(field?.embeddedListMinItems).toBeUndefined();
-  });
-
-  test("select-cell options are translated when registered, fall back to the raw value otherwise", () => {
-    const translateUnit = (key: string) =>
-      key === "orders:entity:order:field:lines:cell:unit:option:hour" ? "Stunde" : key;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity: embeddedListEntity(),
-      values: { lines: [] },
-      translate: translateUnit,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    const unitCell = field?.embeddedListCells?.find((cell) => cell.field === "unit");
-    expect(unitCell?.optionLabels).toEqual({ hour: "Stunde", day: "day" });
-  });
-
-  test("embeddedListCurrency mirrors entity.defaultCurrency (#1839)", () => {
-    const entity = {
-      defaultCurrency: "USD",
-      fields: {
-        lines: { type: "embedded", multiple: true, schema: lineFieldSchema },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity,
-      values: { lines: [] },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.embeddedListCurrency).toBe("USD");
-  });
-
-  test("embeddedListCurrency falls back to EUR when the entity has no defaultCurrency (#1839)", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["lines"] }] }),
-      entity: embeddedListEntity(),
-      values: { lines: [] },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.embeddedListCurrency).toBe("EUR");
-  });
-
-  test("embeddedListCurrency is undefined for a plain (non-list) embedded field", () => {
-    const entity = {
-      defaultCurrency: "USD",
-      fields: {
-        meta: { type: "embedded", schema: { note: { type: "text" } } },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["meta"] }] }),
-      entity,
-      values: { meta: {} },
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.embeddedListCurrency).toBeUndefined();
-  });
-
-  test("imageVariant is the FIRST variant declared on the field def", () => {
-    const entity = {
-      fields: {
-        avatar: {
-          type: "image",
-          variants: {
-            profile: { fit: "cover", size: { width: 512, height: 512 }, format: "webp" },
-            big: { fit: "cover", size: { width: 1024, height: 1024 }, format: "webp" },
-          },
-        },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["avatar"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.imageVariant).toBe("profile");
-  });
-
-  test("imageVariant is undefined for an image field without variants", () => {
-    const entity = {
-      fields: {
-        avatar: { type: "image" },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["avatar"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.imageVariant).toBeUndefined();
-  });
-
-  test("capture is forwarded for an image field that declares it", () => {
-    const entity = {
-      fields: {
-        avatar: { type: "image", capture: "environment" },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["avatar"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.capture).toBe("environment");
-  });
-
-  test("capture is undefined for an image field without it", () => {
-    const entity = {
-      fields: {
-        avatar: { type: "image" },
-      },
-    } as unknown as EntityDefinition;
-
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["avatar"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.capture).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — multiSelect display/columns/maxRows passthrough", () => {
-  function multiSelectEntity(overrides?: Record<string, unknown>): EntityDefinition {
-    return {
-      fields: {
-        languages: {
-          type: "multiSelect",
-          options: ["en", "de", "es"],
-          ...overrides,
-        },
-      },
-    } as unknown as EntityDefinition;
-  }
-
-  test("display/columns/maxRows carry through when set on the field def", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["languages"] }] }),
-      entity: multiSelectEntity({ display: "checkboxes", columns: 2, maxRows: 3 }),
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.display).toBe("checkboxes");
-    expect(field?.columns).toBe(2);
-    expect(field?.maxRows).toBe(3);
-  });
-
-  test("display/columns/maxRows are absent when not set on the field def (back-compat)", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ title: "x", fields: ["languages"] }] }),
-      entity: multiSelectEntity(),
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.display).toBeUndefined();
-    expect(field?.columns).toBeUndefined();
-    expect(field?.maxRows).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — declared reference metadata (fw#2662)", () => {
-  // projectionDetail fields have no real EntityDefinition — the shim that
-  // adapts them synthesizes a pseudo-entity where every field is hardcoded
-  // to "text" (see projection-detail-shim.ts). EditFieldSpec.refEntity must
-  // be evaluated BEFORE the entity.fields lookup, or it never fires against
-  // that shape.
-  const projectionPseudoEntity = {
-    fields: {
-      userId: { type: "text" },
-      ip: { type: "text" },
-    },
-  } as unknown as EntityDefinition;
-
-  test("EditFieldSpec.refEntity marks the field as a reference, even against a pseudo-entity whose fields are all 'text' (fw#2662)", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          { fields: [{ field: "userId", refEntity: "user:user", refLabelField: "displayName" }] },
-        ],
-      }),
-      entity: projectionPseudoEntity,
-      values: { userId: "u-1" },
-      translate,
-      featureName: "sessions",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field).toMatchObject({
-      field: "userId",
-      type: "reference",
-      refEntity: "user",
-      refFeature: "user",
-      refLabelField: "displayName",
-    });
-    expect(field?.refMultiple).toBeUndefined();
-  });
-
-  test("a reference field's optionsQuery reaches the field view-model, labelField untouched (fw#2780)", () => {
-    const entity = {
-      fields: {
-        leaseId: {
-          type: "reference",
-          entity: "lease",
-          labelField: "startDate",
-          optionsQuery: "deposits:query:lease:options",
-        },
-      },
-    } as unknown as EntityDefinition;
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ fields: ["leaseId"] }] }),
-      entity,
-      values: {},
-      translate,
-      featureName: "deposits",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field).toMatchObject({
-      type: "reference",
-      refEntity: "lease",
-      refLabelField: "startDate",
-      refOptionsQuery: "deposits:query:lease:options",
-    });
-  });
-
-  test("non-regression: a projectionDetail field without refEntity metadata stays 'text', unchanged (fw#2662)", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({ sections: [{ fields: ["ip"] }] }),
-      entity: projectionPseudoEntity,
-      values: { ip: "10.0.0.1" },
-      translate,
-      featureName: "sessions",
-    });
-
-    const field = asFields(vm.sections[0]).fields[0];
-    expect(field?.type).toBe("text");
-    expect(field?.refEntity).toBeUndefined();
-    expect(field?.refFeature).toBeUndefined();
-    expect(field?.refLabelField).toBeUndefined();
-  });
-});
-
-function asRelatedList(s: EditSectionViewModel | undefined): EditRelatedListSectionViewModel {
-  if (s === undefined || s.kind !== "relatedList") {
-    throw new Error(`expected relatedList-section, got ${s?.kind ?? "undefined"}`);
-  }
-  return s;
-}
-
-function asWriteForm(s: EditSectionViewModel | undefined): EditWriteFormSectionViewModel {
-  if (s === undefined || s.kind !== "writeForm") {
-    throw new Error(`expected writeForm-section, got ${s?.kind ?? "undefined"}`);
-  }
-  return s;
-}
-
-describe("computeEditViewModel — relatedList rowActions passthrough (fw editable-detail-screens)", () => {
-  test("rowActions pass through onto the relatedList section view-model verbatim", () => {
-    const rowActions: readonly RowAction[] = [
-      { id: "sync", label: "actions.sync", handler: "app:write:sync", payload: { pick: ["id"] } },
-    ];
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            kind: "relatedList",
-            title: "History",
-            query: "app:query:history",
-            columns: ["name"],
-            rowActions,
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asRelatedList(vm.sections[0]).rowActions).toEqual(rowActions);
-  });
-
-  test("rowActions is absent from the view-model when the section spec has none", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          { kind: "relatedList", title: "History", query: "app:query:history", columns: ["name"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asRelatedList(vm.sections[0]).rowActions).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — relatedList searchable/facets passthrough (fw#2740)", () => {
-  test("searchable and facets pass through onto the relatedList section view-model untranslated", () => {
-    const facets = [
-      {
-        field: "status",
-        type: "select" as const,
-        label: "app:facet.status.label",
-        options: [{ value: "active", label: "app:facet.status.active" }],
-      },
-    ];
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            kind: "relatedList",
-            title: "History",
-            query: "app:query:history",
-            columns: ["name", "status"],
-            searchable: true,
-            facets,
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const section = asRelatedList(vm.sections[0]);
-    expect(section.searchable).toBe(true);
-    expect(section.facets).toEqual(facets);
-  });
-
-  test("searchable and facets are absent from the view-model when the section spec has none", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          { kind: "relatedList", title: "History", query: "app:query:history", columns: ["name"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const section = asRelatedList(vm.sections[0]);
-    expect(section.searchable).toBeUndefined();
-    expect(section.facets).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — relatedList parentFilter passthrough", () => {
-  test("parentFilter passes through onto the relatedList section view-model verbatim", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            kind: "relatedList",
-            title: "History",
-            query: "app:query:history",
-            columns: ["name"],
-            parentFilter: { field: "orderId" },
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asRelatedList(vm.sections[0]).parentFilter).toEqual({ field: "orderId" });
-  });
-
-  test("parentFilter is absent from the view-model when the section spec has none", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          { kind: "relatedList", title: "History", query: "app:query:history", columns: ["name"] },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asRelatedList(vm.sections[0]).parentFilter).toBeUndefined();
-  });
-});
-
-describe("computeEditViewModel — writeForm sections (fw editable-detail-screens)", () => {
-  test("resolves the section's own fieldDefs/fields through the same per-field pipeline as a fields section", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            kind: "writeForm",
-            title: "Add note",
-            fieldDefs: { note: { type: "text", required: true } },
-            fields: ["note"],
-            handler: "orders:write:add-note",
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const section = asWriteForm(vm.sections[0]);
-    expect(section.handler).toBe("orders:write:add-note");
-    expect(section.fields).toEqual([
-      {
-        field: "note",
-        label: "orders:entity:__write-form-section__:field:note",
-        type: "text",
-        value: undefined,
-        visible: true,
-        readOnly: false,
-        required: true,
-      },
-    ]);
-  });
-
-  test("readOnly/required on a writeForm field come from the section's own fieldDefs, independent of the host entity", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            kind: "writeForm",
-            title: "Add note",
-            // "notes" is optional on orderEntity — the writeForm section's own
-            // fieldDefs declares its own "notes" field as required, and that
-            // (not the host entity's) must win.
-            fieldDefs: { notes: { type: "text", required: true } },
-            fields: ["notes"],
-            handler: "orders:write:add-note",
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    expect(asWriteForm(vm.sections[0]).fields[0]?.required).toBe(true);
-  });
-
-  test("columns defaults to 1; icon/description/submitLabel are translated and passed through when set", () => {
-    const vm = computeEditViewModel({
-      screen: editScreen({
-        sections: [
-          {
-            kind: "writeForm",
-            title: "Add note",
-            description: "orders:write-form.description",
-            icon: "plus",
-            fieldDefs: { note: { type: "text" } },
-            fields: ["note"],
-            handler: "orders:write:add-note",
-            submitLabel: "orders:write-form.submit",
-          },
-        ],
-      }),
-      entity: orderEntity,
-      values: {},
-      translate,
-      featureName: "orders",
-    });
-
-    const section = asWriteForm(vm.sections[0]);
-    expect(section.columns).toBe(1);
-    expect(section.icon).toBe("plus");
-    expect(section.description).toBe("orders:write-form.description");
-    expect(section.submitLabel).toBe("orders:write-form.submit");
-  });
-});