@multiplatform.one/backoffice 7.6.3 → 7.7.0

package/src/form/dirtyTracking.spec.ts

@@ -1,91 +0,0 @@
-// R-1 false "Not Saved": engine-level dirty-tracking contract.
-// An untouched existing doc must read pristine, a real edit must read dirty,
-// create mode must read dirty from applied defaults (desk parity).
-import { describe, expect, it } from "vitest";
-import { computeDirtyFields, isSameValue } from "./dirtyTracking";
-
-describe("isSameValue (normalization-insensitive equality)", () => {
-  it("treats null / undefined / empty string / empty array as one empty state", () => {
-    expect(isSameValue(null, "")).toBe(true);
-    expect(isSameValue(undefined, "")).toBe(true);
-    expect(isSameValue(null, undefined)).toBe(true);
-    expect(isSameValue([], null)).toBe(true);
-    expect(isSameValue("  ", "")).toBe(true);
-  });
-
-  it("folds boolean and wire 0/1 representations", () => {
-    expect(isSameValue(false, 0)).toBe(true);
-    expect(isSameValue(true, 1)).toBe(true);
-    expect(isSameValue(0, false)).toBe(true);
-    expect(isSameValue(true, 0)).toBe(false);
-    expect(isSameValue(false, 1)).toBe(false);
-  });
-
-  it("does not conflate empty with falsy non-empty values", () => {
-    expect(isSameValue(0, "")).toBe(false);
-    expect(isSameValue(false, "")).toBe(false);
-    expect(isSameValue(0, null)).toBe(false);
-  });
-
-  it("stays strict for real values — no deep equality", () => {
-    expect(isSameValue("a", "a")).toBe(true);
-    expect(isSameValue("a", "b")).toBe(false);
-    // Distinct array/object identities read as different even when
-    // structurally equal (deliberate: no deep-equality time bombs).
-    expect(isSameValue([{ a: 1 }], [{ a: 1 }])).toBe(false);
-    // Representation changes of real content are edits (the field layer is
-    // responsible for not emitting them during initialization).
-    expect(isSameValue("plain", "<p>plain</p>")).toBe(false);
-  });
-});
-
-describe("computeDirtyFields", () => {
-  const baseline = {
-    doctype: "ToDo",
-    name: "abc",
-    description: "hello",
-    status: "Open",
-    color: null,
-    priority: "Medium",
-    date: "2026-08-12",
-    checked: 0,
-  };
-
-  it("existing doc mount: local === baseline snapshot reads pristine", () => {
-    expect(computeDirtyFields({ ...baseline }, baseline)).toEqual([]);
-  });
-
-  it("field re-representation during init does not dirty (null→'' and 0→false)", () => {
-    const local = { ...baseline, color: "", checked: false };
-    expect(computeDirtyFields(local, baseline)).toEqual([]);
-  });
-
-  it("a real edit reads dirty", () => {
-    const local = { ...baseline, description: "hello edited" };
-    expect(computeDirtyFields(local, baseline)).toEqual(["description"]);
-  });
-
-  it("revert to the exact baseline value reads clean again", () => {
-    // Documented behavior: value equality, not edit history — typing and
-    // deleting back to the original string is pristine. An equivalent-but-
-    // differently-represented value (e.g. tiptap-normalized HTML) would
-    // still read dirty, which matches desk.
-    const local = { ...baseline, description: "hello" };
-    expect(computeDirtyFields(local, baseline)).toEqual([]);
-  });
-
-  it("bookkeeping keys never dirty", () => {
-    const local = { ...baseline, name: "renamed", doctype: "Other" };
-    expect(computeDirtyFields(local, baseline)).toEqual([]);
-  });
-
-  it("new doc (no baseline) with applied create-defaults reads dirty — desk parity", () => {
-    const local = { doctype: "ToDo", status: "Open", priority: "Medium", description: "" };
-    expect(computeDirtyFields(local, undefined)).toEqual(["status", "priority"]);
-  });
-
-  it("new doc with only empty values reads pristine", () => {
-    const local = { doctype: "ToDo", description: "", color: null };
-    expect(computeDirtyFields(local, undefined)).toEqual([]);
-  });
-});

package/src/form/fetchFrom.spec.ts

@@ -1,92 +0,0 @@
-/**
- * fetchFrom — fetch_from preview parity with desk script_manager.js
- * setup_add_fetch + link.js validate_link_and_fetch.
- */
-import { describe, expect, it } from "vitest";
-import type { DocFieldMeta } from "../shared/useDoctypeMeta";
-import { applyFetchedValues, buildFetchMap, isFetchLocked } from "./fetchFrom";
-
-function field(overrides: Partial<DocFieldMeta> & { fieldname: string }): DocFieldMeta {
-  return { fieldtype: "Data", ...overrides };
-}
-
-describe("buildFetchMap", () => {
-  it("registers scalar fieldtypes keyed by their link field", () => {
-    const map = buildFetchMap([
-      field({ fieldname: "customer", fieldtype: "Link", options: "Customer" }),
-      field({ fieldname: "customer_name", fetch_from: "customer.customer_name" }),
-      field({ fieldname: "territory", fieldtype: "Select", fetch_from: "customer.territory" }),
-    ]);
-    expect(map.get("customer")).toEqual([
-      { target: "customer_name", source: "customer_name", fetchIfEmpty: false },
-      { target: "territory", source: "territory", fetchIfEmpty: false },
-    ]);
-  });
-
-  it("skips fetch_from without a dot and non-registered fieldtypes", () => {
-    const map = buildFetchMap([
-      field({ fieldname: "bad", fetch_from: "customer" }),
-      field({ fieldname: "html", fieldtype: "HTML", fetch_from: "customer.blurb" }),
-    ]);
-    expect(map.size).toBe(0);
-  });
-
-  it("includes non-scalar fieldtypes when read_only (script_manager gate)", () => {
-    const map = buildFetchMap([
-      field({
-        fieldname: "blurb",
-        fieldtype: "HTML Editor",
-        fetch_from: "customer.blurb",
-        read_only: 1,
-      }),
-    ]);
-    expect(map.get("customer")).toHaveLength(1);
-  });
-
-  it("records fetch_if_empty", () => {
-    const map = buildFetchMap([
-      field({ fieldname: "note", fetch_from: "customer.note", fetch_if_empty: 1 }),
-    ]);
-    expect(map.get("customer")?.[0].fetchIfEmpty).toBe(true);
-  });
-});
-
-describe("applyFetchedValues", () => {
-  const rules = [
-    { target: "customer_name", source: "customer_name", fetchIfEmpty: false },
-    { target: "note", source: "note", fetchIfEmpty: true },
-  ];
-
-  it("writes fetched values onto targets", () => {
-    const patch = applyFetchedValues(rules, { customer_name: "Acme", note: "VIP" }, {});
-    expect(patch).toEqual({ customer_name: "Acme", note: "VIP" });
-  });
-
-  it("fetch_if_empty targets keep an existing value", () => {
-    const patch = applyFetchedValues(
-      rules,
-      { customer_name: "Acme", note: "VIP" },
-      { note: "user wrote this" },
-    );
-    expect(patch).toEqual({ customer_name: "Acme" });
-  });
-
-  it("clearing the link blanks plain targets but spares fetch_if_empty values", () => {
-    const patch = applyFetchedValues(rules, {}, { customer_name: "Acme", note: "mine" });
-    expect(patch).toEqual({ customer_name: "" });
-  });
-});
-
-describe("isFetchLocked", () => {
-  it("locks while the source link holds a value, unless fetch_if_empty", () => {
-    const target = field({ fieldname: "customer_name", fetch_from: "customer.customer_name" });
-    expect(isFetchLocked(target, { customer: "CUST-1" })).toBe(true);
-    expect(isFetchLocked(target, {})).toBe(false);
-    const softTarget = field({
-      fieldname: "note",
-      fetch_from: "customer.note",
-      fetch_if_empty: 1,
-    });
-    expect(isFetchLocked(softTarget, { customer: "CUST-1" })).toBe(false);
-  });
-});

package/src/form/fieldPermissions.spec.ts

@@ -1,61 +0,0 @@
-/**
- * fieldPermissions — permlevel matrix parity with desk perm.js
- * get_role_permissions / get_field_display_status.
- */
-import { describe, expect, it } from "vitest";
-import { buildPermLevelMatrix, canReadLevel, canWriteLevel } from "./fieldPermissions";
-
-const userDoctypePerms = [
-  { role: "System Manager", permlevel: 0, read: 1 as const, write: 1 as const },
-  { role: "System Manager", permlevel: 1, read: 1 as const, write: 1 as const },
-  { role: "Desk User", permlevel: 0, read: 0 as const, write: 0 as const },
-];
-
-describe("buildPermLevelMatrix", () => {
-  it("unions rights across the user's matching roles", () => {
-    const matrix = buildPermLevelMatrix(
-      [
-        { role: "Blogger", permlevel: 1, read: 1 as const, write: 0 as const },
-        { role: "Website Manager", permlevel: 1, read: 1 as const, write: 1 as const },
-      ],
-      ["Blogger", "Website Manager"],
-    );
-    expect(matrix?.[1]).toEqual({ read: true, write: true });
-  });
-
-  it("ignores rows for roles the user does not hold (User doctype shape)", () => {
-    const matrix = buildPermLevelMatrix(userDoctypePerms, ["Desk User"]);
-    expect(matrix?.[1]).toBeUndefined();
-    expect(canReadLevel(matrix, 1)).toBe(false);
-    expect(canWriteLevel(matrix, 1)).toBe(false);
-  });
-
-  it("returns undefined without roles or permission rows (fallback signal)", () => {
-    expect(buildPermLevelMatrix(userDoctypePerms, undefined)).toBeUndefined();
-    expect(buildPermLevelMatrix([], ["System Manager"])).toBeUndefined();
-    expect(buildPermLevelMatrix(undefined, ["System Manager"])).toBeUndefined();
-  });
-});
-
-describe("canReadLevel / canWriteLevel", () => {
-  const matrix = buildPermLevelMatrix(userDoctypePerms, ["System Manager"]);
-
-  it("level 0 defers to doc-level perms (always true here)", () => {
-    expect(canReadLevel(matrix, 0)).toBe(true);
-    expect(canWriteLevel(matrix, 0)).toBe(true);
-    expect(canReadLevel(undefined, 0)).toBe(true);
-    expect(canWriteLevel(undefined, 0)).toBe(true);
-  });
-
-  it("higher levels resolve from the matrix", () => {
-    expect(canReadLevel(matrix, 1)).toBe(true);
-    expect(canWriteLevel(matrix, 1)).toBe(true);
-    // Level with no rows at all → hidden (desk fills gaps with {}).
-    expect(canReadLevel(matrix, 2)).toBe(false);
-  });
-
-  it("without a matrix: visible but read-only above level 0 (coarse fallback)", () => {
-    expect(canReadLevel(undefined, 1)).toBe(true);
-    expect(canWriteLevel(undefined, 1)).toBe(false);
-  });
-});

package/src/form/formLayout.spec.ts

@@ -1,373 +0,0 @@
-/**
- * formLayout — desk layout-engine parity specs. Ground truth:
- * frappe/public/js/frappe/form/layout.js (+ section.js, tab.js) and
- * frappe/public/js/frappe/model/perm.js get_field_display_status.
- */
-import { describe, expect, it } from "vitest";
-import type { DocFieldMeta } from "../shared/useDoctypeMeta";
-import { buildPermLevelMatrix } from "./fieldPermissions";
-import { buildCreateDefaults, buildFormTabs, type BuildTabsOptions } from "./formLayout";
-
-function field(overrides: Partial<DocFieldMeta> & { fieldname: string }): DocFieldMeta {
-  return { fieldtype: "Data", label: overrides.fieldname, ...overrides };
-}
-
-function build(
-  fields: DocFieldMeta[],
-  overrides: Partial<BuildTabsOptions> = {},
-): ReturnType<typeof buildFormTabs> {
-  return buildFormTabs({
-    fields,
-    doc: {},
-    docstatus: 0,
-    formReadOnly: false,
-    isCreate: false,
-    detailsLabel: "Details",
-    ...overrides,
-  });
-}
-
-function flatFieldNames(tabs: ReturnType<typeof buildFormTabs>): string[] {
-  return tabs.flatMap((tab) => tab.schema.fields.map((f) => f.name));
-}
-
-function findField(tabs: ReturnType<typeof buildFormTabs>, name: string) {
-  for (const tab of tabs) {
-    const hit = tab.schema.fields.find((f) => f.name === name);
-    if (hit) return hit;
-  }
-  return undefined;
-}
-
-describe("tab / section / column grouping", () => {
-  it("groups fields under Tab Breaks with an implicit Details tab", () => {
-    const tabs = build([
-      field({ fieldname: "a" }),
-      field({ fieldname: "tab1", fieldtype: "Tab Break", label: "More" }),
-      field({ fieldname: "b" }),
-    ]);
-    expect(tabs.map((t) => t.key)).toEqual(["__details", "tab1"]);
-    expect(tabs[0].label).toBe("Details");
-    expect(tabs[0].schema.fields.map((f) => f.name)).toEqual(["a"]);
-    expect(tabs[1].schema.fields.map((f) => f.name)).toEqual(["b"]);
-  });
-
-  it("drops the implicit Details tab when the doctype starts with a Tab Break (User)", () => {
-    const tabs = build([
-      field({ fieldname: "details_tab", fieldtype: "Tab Break", label: "User Details" }),
-      field({ fieldname: "email" }),
-    ]);
-    expect(tabs.map((t) => t.key)).toEqual(["details_tab"]);
-  });
-
-  it("splits Section Breaks into sections and Column Breaks into columns", () => {
-    const tabs = build([
-      field({ fieldname: "a" }),
-      field({ fieldname: "sec1", fieldtype: "Section Break", label: "Second" }),
-      field({ fieldname: "b" }),
-      field({ fieldname: "col1", fieldtype: "Column Break" }),
-      field({ fieldname: "c" }),
-    ]);
-    const sections = tabs[0].schema.sections;
-    expect(sections).toHaveLength(2);
-    expect(sections[1].label).toBe("Second");
-    expect(sections[1].columns).toHaveLength(2);
-    expect(sections[1].columns[0].fields[0].name).toBe("b");
-    expect(sections[1].columns[1].fields[0].name).toBe("c");
-  });
-});
-
-describe("hidden + depends_on visibility", () => {
-  it("drops hidden fields", () => {
-    const tabs = build([field({ fieldname: "a" }), field({ fieldname: "b", hidden: 1 })]);
-    expect(flatFieldNames(tabs)).toEqual(["a"]);
-  });
-
-  it("auto-hides a section when all its fields hide (desk empty-section)", () => {
-    const tabs = build([
-      field({ fieldname: "a" }),
-      field({ fieldname: "sec1", fieldtype: "Section Break", label: "Hidden Section" }),
-      field({ fieldname: "b", hidden: 1 }),
-      field({ fieldname: "c", depends_on: "eval:doc.missing" }),
-    ]);
-    expect(tabs[0].schema.sections).toHaveLength(1);
-  });
-
-  it("auto-hides a tab when all its sections hide", () => {
-    const tabs = build([
-      field({ fieldname: "a" }),
-      field({ fieldname: "tab1", fieldtype: "Tab Break", label: "Empty" }),
-      field({ fieldname: "b", hidden: 1 }),
-    ]);
-    expect(tabs.map((t) => t.key)).toEqual(["__details"]);
-  });
-
-  it("hides a whole section when its Section Break depends_on is false", () => {
-    const tabs = build(
-      [
-        field({ fieldname: "a" }),
-        field({
-          fieldname: "sec1",
-          fieldtype: "Section Break",
-          depends_on: "eval:doc.show_more",
-        }),
-        field({ fieldname: "b" }),
-      ],
-      { doc: { show_more: 0 } },
-    );
-    expect(flatFieldNames(tabs)).toEqual(["a"]);
-  });
-
-  it("re-resolves depends_on against the live doc", () => {
-    const fields = [
-      field({ fieldname: "channel", fieldtype: "Select", options: "Email\nSlack" }),
-      field({
-        fieldname: "slack_webhook_url",
-        depends_on: "eval:doc.channel=='Slack'",
-        mandatory_depends_on: "eval:doc.channel=='Slack'",
-      }),
-    ];
-    expect(flatFieldNames(build(fields, { doc: { channel: "Email" } }))).toEqual(["channel"]);
-    const slackTabs = build(fields, { doc: { channel: "Slack" } });
-    expect(flatFieldNames(slackTabs)).toEqual(["channel", "slack_webhook_url"]);
-    expect(findField(slackTabs, "slack_webhook_url")?.required).toBe(true);
-  });
-});
-
-describe("read_only / read_only_depends_on / set_only_once", () => {
-  it("marks read_only fields readOnly", () => {
-    const tabs = build([field({ fieldname: "a", read_only: 1 })]);
-    expect(findField(tabs, "a")?.readOnly).toBe(true);
-  });
-
-  it("resolves read_only_depends_on per doc state", () => {
-    const fields = [field({ fieldname: "a", read_only_depends_on: "eval:doc.locked" })];
-    expect(findField(build(fields, { doc: { locked: 1 } }), "a")?.readOnly).toBe(true);
-    expect(findField(build(fields, { doc: { locked: 0 } }), "a")?.readOnly).toBe(false);
-  });
-
-  it("set_only_once: editable on new docs, read-only on saved docs (perm.js:261)", () => {
-    const fields = [field({ fieldname: "a", set_only_once: 1 })];
-    expect(findField(build(fields, { isCreate: true }), "a")?.readOnly).toBe(false);
-    expect(findField(build(fields, { isCreate: false }), "a")?.readOnly).toBe(true);
-  });
-});
-
-describe("docstatus lifecycle locking", () => {
-  const fields = [
-    field({ fieldname: "locked_field" }),
-    field({ fieldname: "open_field", allow_on_submit: 1 }),
-  ];
-
-  it("docstatus 1 locks everything except allow_on_submit", () => {
-    const tabs = build(fields, { docstatus: 1 });
-    expect(findField(tabs, "locked_field")?.readOnly).toBe(true);
-    expect(findField(tabs, "open_field")?.readOnly).toBe(false);
-  });
-
-  it("docstatus 2 locks allow_on_submit fields too", () => {
-    const tabs = build(fields, { docstatus: 2 });
-    expect(findField(tabs, "open_field")?.readOnly).toBe(true);
-  });
-});
-
-describe("permlevel gating (perm.js get_field_display_status)", () => {
-  const permissions = [
-    { role: "System Manager", permlevel: 0, read: 1 as const, write: 1 as const },
-    { role: "System Manager", permlevel: 1, read: 1 as const, write: 1 as const },
-    { role: "Auditor", permlevel: 1, read: 1 as const, write: 0 as const },
-    { role: "Desk User", permlevel: 0, read: 1 as const, write: 1 as const },
-  ];
-  const fields = [field({ fieldname: "plain" }), field({ fieldname: "restricted", permlevel: 1 })];
-
-  it("write at the level → editable (fixes the coarse always-read-only rule)", () => {
-    const matrix = buildPermLevelMatrix(permissions, ["System Manager"]);
-    const tabs = build(fields, { permLevels: matrix });
-    expect(findField(tabs, "restricted")?.readOnly).toBe(false);
-  });
-
-  it("read without write at the level → read-only", () => {
-    const matrix = buildPermLevelMatrix(permissions, ["Auditor"]);
-    const tabs = build(fields, { permLevels: matrix });
-    expect(findField(tabs, "restricted")?.readOnly).toBe(true);
-  });
-
-  it("no read at the level → field hidden (desk status None)", () => {
-    const matrix = buildPermLevelMatrix(permissions, ["Desk User"]);
-    const tabs = build(fields, { permLevels: matrix });
-    expect(findField(tabs, "restricted")).toBeUndefined();
-    expect(findField(tabs, "plain")).toBeDefined();
-  });
-
-  it("without a matrix falls back to coarse permlevel>0 read-only, never hidden", () => {
-    const tabs = build(fields);
-    expect(findField(tabs, "restricted")?.readOnly).toBe(true);
-  });
-
-  it("hides a Tab Break the user cannot read (tab.js:41)", () => {
-    const matrix = buildPermLevelMatrix(permissions, ["Desk User"]);
-    const tabs = build(
-      [
-        field({ fieldname: "a" }),
-        field({ fieldname: "sec_tab", fieldtype: "Tab Break", label: "Secret", permlevel: 1 }),
-        field({ fieldname: "b" }),
-      ],
-      { permLevels: matrix },
-    );
-    expect(tabs.map((t) => t.key)).toEqual(["__details"]);
-  });
-});
-
-describe("section collapse state (layout.js refresh_section_collapse)", () => {
-  it("collapsible sections start collapsed", () => {
-    const tabs = build([
-      field({ fieldname: "sec1", fieldtype: "Section Break", label: "S", collapsible: 1 }),
-      field({ fieldname: "a" }),
-    ]);
-    expect(tabs[0].schema.sections[0].collapsed).toBe(true);
-  });
-
-  it("collapsible_depends_on truthy → expanded (Notification print settings)", () => {
-    const fields = [
-      field({
-        fieldname: "sec1",
-        fieldtype: "Section Break",
-        label: "S",
-        collapsible: 1,
-        collapsible_depends_on: "attach_print",
-      }),
-      field({ fieldname: "a" }),
-    ];
-    expect(build(fields, { doc: { attach_print: 1 } })[0].schema.sections[0].collapsed).toBe(false);
-    expect(build(fields, { doc: { attach_print: 0 } })[0].schema.sections[0].collapsed).toBe(true);
-  });
-
-  it("a missing mandatory value forces the section open (section.js has_missing_mandatory)", () => {
-    const fields = [
-      field({ fieldname: "sec1", fieldtype: "Section Break", label: "S", collapsible: 1 }),
-      field({ fieldname: "a", reqd: 1 }),
-    ];
-    expect(build(fields, { doc: {} })[0].schema.sections[0].collapsed).toBe(false);
-    // Desk checks `value == null` — an empty string counts as present.
-    expect(build(fields, { doc: { a: "" } })[0].schema.sections[0].collapsed).toBe(true);
-  });
-
-  it("non-collapsible sections have no collapse state", () => {
-    const tabs = build([
-      field({ fieldname: "sec1", fieldtype: "Section Break", label: "S" }),
-      field({ fieldname: "a" }),
-    ]);
-    expect(tabs[0].schema.sections[0].collapsed).toBeUndefined();
-    expect(tabs[0].schema.sections[0].collapsible).toBe(false);
-  });
-
-  it("forwards hide_border and description", () => {
-    const tabs = build([
-      field({
-        fieldname: "sec1",
-        fieldtype: "Section Break",
-        label: "S",
-        hide_border: 1,
-        description: "About this group",
-      }),
-      field({ fieldname: "a" }),
-    ]);
-    expect(tabs[0].schema.sections[0].hideBorder).toBe(true);
-    expect(tabs[0].schema.sections[0].description).toBe("About this group");
-  });
-});
-
-describe("fetch_from read-only lock", () => {
-  const fields = [
-    field({ fieldname: "customer", fieldtype: "Link", options: "Customer" }),
-    field({ fieldname: "customer_name", fetch_from: "customer.customer_name" }),
-    field({
-      fieldname: "note",
-      fetch_from: "customer.note",
-      fetch_if_empty: 1,
-    }),
-  ];
-
-  it("locks a fetch target while its source link is set (base_input.js:56)", () => {
-    const tabs = build(fields, { doc: { customer: "CUST-1" } });
-    expect(findField(tabs, "customer_name")?.readOnly).toBe(true);
-  });
-
-  it("keeps the target editable when the source is empty or fetch_if_empty is set", () => {
-    const emptyTabs = build(fields, { doc: {} });
-    expect(findField(emptyTabs, "customer_name")?.readOnly).toBe(false);
-    const setTabs = build(fields, { doc: { customer: "CUST-1" } });
-    expect(findField(setTabs, "note")?.readOnly).toBe(false);
-  });
-});
-
-describe("field property pass-through", () => {
-  it("forwards description, precision, and length", () => {
-    const tabs = build([
-      field({ fieldname: "a", description: "help", precision: "3", length: 20 }),
-    ]);
-    const schema = findField(tabs, "a");
-    expect(schema?.description).toBe("help");
-    expect(schema?.precision).toBe(3);
-    expect(schema?.maxLength).toBe(20);
-  });
-});
-
-describe("buildCreateDefaults (create_new.js get_default_value)", () => {
-  it("seeds static, Today, and __user defaults", () => {
-    const doc = buildCreateDefaults(
-      [
-        field({
-          fieldname: "status",
-          fieldtype: "Select",
-          options: "Open\nClosed",
-          default: "Open",
-        }),
-        field({ fieldname: "date", fieldtype: "Date", default: "Today" }),
-        field({ fieldname: "owner_field", fieldtype: "Link", options: "User", default: "__user" }),
-        field({ fieldname: "count", fieldtype: "Int", default: "5" }),
-      ],
-      "admin@example.com",
-    );
-    expect(doc.status).toBe("Open");
-    expect(doc.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    expect(doc.owner_field).toBe("admin@example.com");
-    expect(doc.count).toBe(5);
-  });
-
-  it("seeds `user` alias on Link/Data only and `now` per fieldtype", () => {
-    const doc = buildCreateDefaults(
-      [
-        field({ fieldname: "who", fieldtype: "Link", options: "User", default: "user" }),
-        field({ fieldname: "sel", fieldtype: "Select", options: "user\nrole", default: "user" }),
-        field({ fieldname: "at_time", fieldtype: "Time", default: "now" }),
-        field({ fieldname: "at_dt", fieldtype: "Datetime", default: "now" }),
-      ],
-      "admin@example.com",
-    );
-    expect(doc.who).toBe("admin@example.com");
-    expect(doc.sel).toBe("user"); // Select keeps its literal option
-    expect(doc.at_time).toMatch(/^\d{2}:\d{2}:\d{2}$/);
-    expect(doc.at_dt).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
-  });
-
-  it("seeds the first Select option when no default exists (create_new.js:107)", () => {
-    const doc = buildCreateDefaults([
-      field({ fieldname: "kind", fieldtype: "Select", options: "Small\nLarge" }),
-      field({ fieldname: "empty_first", fieldtype: "Select", options: "\nA\nB" }),
-      field({ fieldname: "placeholder", fieldtype: "Select", options: "[Select]" }),
-    ]);
-    expect(doc.kind).toBe("Small");
-    expect(doc.empty_first).toBe("");
-    expect(doc.placeholder).toBeUndefined();
-  });
-
-  it("leaves server-resolved tokens unset", () => {
-    const doc = buildCreateDefaults([
-      field({ fieldname: "company", fieldtype: "Link", options: "Company", default: ":Company" }),
-      field({ fieldname: "fullname", fieldtype: "Data", default: "user_fullname" }),
-    ]);
-    expect(doc.company).toBeUndefined();
-    expect(doc.fullname).toBeUndefined();
-  });
-});