@multiplatform.one/frappe-ui 7.6.3 → 7.7.1

package/src/formEngine/formActions.ts

@@ -0,0 +1,285 @@
+/**
+ * Desk form RPC helpers — thin wrappers over the whitelisted methods the
+ * stock desk form view calls. Every payload here was probed against a live
+ * bench (frappe v15) before implementation:
+ *
+ *   frappe.desk.form.assign_to.add        {doctype, name, assign_to: [..], description?}
+ *   frappe.desk.form.assign_to.remove     {doctype, name, assign_to: "user"}
+ *   frappe.desk.form.utils.add_comment    {reference_doctype, reference_name, content,
+ *                                          comment_email, comment_by}
+ *   frappe.desk.doctype.tag.tag.add_tag   {tag, dt, dn}
+ *   frappe.desk.doctype.tag.tag.remove_tag{tag, dt, dn}
+ *   frappe.desk.like.toggle_like          {doctype, name, add: "Yes"|"No"}
+ *   frappe.desk.form.document_follow.follow_document / unfollow_document
+ *                                         {doctype, doc_name, user}
+ *   frappe.model.rename_doc.update_document_title
+ *                                         {doctype, docname, name, merge: 0} → new name
+ *                                         (what desk calls — syncs the title field too)
+ *   frappe.client.submit                  {doc} (full doc incl. modified — OCC enforced)
+ *   frappe.client.cancel                  {doctype, name}
+ *   frappe.client.get_count               {doctype, filters}
+ *   frappe.client.validate_link           {doctype, docname, fields: [..]} →
+ *                                         {name, <field>: value} (fetch_from preview)
+ *   frappe.core.doctype.communication.email.make
+ *                                         {doctype, name, recipients, subject, content,
+ *                                          send_email: 1}
+ *   frappe.desk.form.utils.remove_attach  {fid, dt, dn}
+ */
+
+import { HttpClient, FileModule, type AuthConfig } from "@multiplatform.one/frappe";
+import type { FixtureProvider } from "@multiplatform.one/frappe";
+
+/**
+ * Connection shape shared by every form loader/action — structurally
+ * compatible with frappe-ui's FrappeConfig and the frappe package's
+ * UseFrappeCollectionConfig (function tokens included).
+ */
+export interface FrappeConnection {
+  baseURL: string;
+  socketPort?: number;
+  /** Same-origin socket override (see FrappeConfig.socketBaseURL). */
+  socketBaseURL?: string;
+  /** Frappe site name — the realtime Socket.IO namespace. */
+  siteName?: string;
+  auth?: {
+    useToken?: boolean;
+    token?: string | (() => string | Promise<string>);
+    type?: string;
+  };
+  // biome-ignore lint: matches FrappeConfig.syncOptions
+  syncOptions?: any;
+  fixtures?: FixtureProvider;
+}
+
+export function createHttpClient(connection: FrappeConnection): HttpClient {
+  const auth: AuthConfig | undefined = connection.auth
+    ? {
+        useToken: connection.auth.useToken,
+        token: connection.auth.token,
+        type: connection.auth.type as AuthConfig["type"],
+      }
+    : undefined;
+  return new HttpClient(connection.baseURL, auth);
+}
+
+async function post<T = unknown>(
+  http: HttpClient,
+  method: string,
+  body: Record<string, unknown>,
+): Promise<T | undefined> {
+  const response = await http.post<{ message?: T }>(`/api/method/${method}`, body);
+  return response.payload?.message;
+}
+
+// ---------------------------------------------------------------------------
+// Assignments
+// ---------------------------------------------------------------------------
+
+export function addAssignment(
+  http: HttpClient,
+  doctype: string,
+  name: string,
+  users: string[],
+  description?: string,
+) {
+  return post(http, "frappe.desk.form.assign_to.add", {
+    doctype,
+    name,
+    assign_to: users,
+    description: description || undefined,
+  });
+}
+
+export function removeAssignment(http: HttpClient, doctype: string, name: string, user: string) {
+  return post(http, "frappe.desk.form.assign_to.remove", { doctype, name, assign_to: user });
+}
+
+// ---------------------------------------------------------------------------
+// Comments
+// ---------------------------------------------------------------------------
+
+export function addComment(
+  http: HttpClient,
+  args: {
+    doctype: string;
+    name: string;
+    content: string;
+    commentEmail: string;
+    commentBy?: string;
+  },
+) {
+  return post(http, "frappe.desk.form.utils.add_comment", {
+    reference_doctype: args.doctype,
+    reference_name: args.name,
+    content: args.content,
+    comment_email: args.commentEmail,
+    comment_by: args.commentBy ?? args.commentEmail,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Tags
+// ---------------------------------------------------------------------------
+
+export function addTag(http: HttpClient, doctype: string, name: string, tag: string) {
+  return post(http, "frappe.desk.doctype.tag.tag.add_tag", { tag, dt: doctype, dn: name });
+}
+
+export function removeTag(http: HttpClient, doctype: string, name: string, tag: string) {
+  return post(http, "frappe.desk.doctype.tag.tag.remove_tag", { tag, dt: doctype, dn: name });
+}
+
+// ---------------------------------------------------------------------------
+// Like / Follow
+// ---------------------------------------------------------------------------
+
+export function toggleLike(http: HttpClient, doctype: string, name: string, add: boolean) {
+  return post(http, "frappe.desk.like.toggle_like", {
+    doctype,
+    name,
+    add: add ? "Yes" : "No",
+  });
+}
+
+export function followDocument(http: HttpClient, doctype: string, name: string, user: string) {
+  return post(http, "frappe.desk.form.document_follow.follow_document", {
+    doctype,
+    doc_name: name,
+    user,
+  });
+}
+
+export function unfollowDocument(http: HttpClient, doctype: string, name: string, user: string) {
+  return post(http, "frappe.desk.form.document_follow.unfollow_document", {
+    doctype,
+    doc_name: name,
+    user,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Document lifecycle
+// ---------------------------------------------------------------------------
+
+/**
+ * Rename a document; resolves with the new name. Uses desk's own
+ * `update_document_title` (handles title-field sync; the bare
+ * `frappe.rename_doc` does not). Pass a `title` argument instead of `name`
+ * to retitle without renaming — not needed here yet.
+ */
+export async function renameDoc(
+  http: HttpClient,
+  doctype: string,
+  oldName: string,
+  newName: string,
+): Promise<string> {
+  const result = await post<string>(http, "frappe.model.rename_doc.update_document_title", {
+    doctype,
+    docname: oldName,
+    name: newName,
+    merge: 0,
+  });
+  return result ?? newName;
+}
+
+/** Submit a saved draft (docstatus 0 → 1). Requires the current full doc for OCC. */
+export function submitDoc(http: HttpClient, doc: Record<string, unknown>) {
+  return post<Record<string, unknown>>(http, "frappe.client.submit", { doc });
+}
+
+/** Cancel a submitted doc (docstatus 1 → 2). */
+export function cancelDoc(http: HttpClient, doctype: string, name: string) {
+  return post<Record<string, unknown>>(http, "frappe.client.cancel", { doctype, name });
+}
+
+/** Direct REST insert — returns the created doc (with its server-issued name). */
+export async function insertDoc(
+  http: HttpClient,
+  doctype: string,
+  values: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  const response = await http.post<{ data?: Record<string, unknown> }>(
+    `/api/resource/${encodeURIComponent(doctype)}`,
+    values,
+  );
+  const data = response.payload?.data;
+  if (!data) throw new Error(`Insert into ${doctype} returned no document`);
+  return data;
+}
+
+/**
+ * Validate a link value and fetch columns off the linked doc in one call —
+ * what desk's Link control uses to drive fetch_from previews. Resolves with
+ * `{name, <field>: value, ...}`; rejects when the target doc is missing.
+ */
+export async function validateLink(
+  http: HttpClient,
+  doctype: string,
+  docname: string,
+  fields: string[],
+): Promise<Record<string, unknown>> {
+  const result = await post<Record<string, unknown>>(http, "frappe.client.validate_link", {
+    doctype,
+    docname,
+    fields,
+  });
+  return result ?? {};
+}
+
+// ---------------------------------------------------------------------------
+// Misc
+// ---------------------------------------------------------------------------
+
+export async function getCount(
+  http: HttpClient,
+  doctype: string,
+  filters: Record<string, unknown>,
+): Promise<number> {
+  const response = await http.get<{ message?: number }>("/api/method/frappe.client.get_count", {
+    doctype,
+    filters: JSON.stringify(filters),
+  });
+  return response.payload?.message ?? 0;
+}
+
+let cachedUser: string | undefined;
+export async function getLoggedUser(http: HttpClient): Promise<string> {
+  if (cachedUser) return cachedUser;
+  const response = await http.get<{ message?: string }>("/api/method/frappe.auth.get_logged_user");
+  cachedUser = response.payload?.message ?? "Guest";
+  return cachedUser;
+}
+
+export function removeAttachment(http: HttpClient, fileId: string, doctype: string, name: string) {
+  return post(http, "frappe.desk.form.utils.remove_attach", { fid: fileId, dt: doctype, dn: name });
+}
+
+export function uploadAttachment(
+  http: HttpClient,
+  file: File | Blob,
+  doctype: string,
+  name: string,
+): Promise<unknown> {
+  const files = new FileModule(http);
+  return files.uploadFile(file, { doctype, docname: name });
+}
+
+export function sendEmail(
+  http: HttpClient,
+  args: {
+    doctype: string;
+    name: string;
+    recipients: string;
+    subject: string;
+    content: string;
+  },
+) {
+  return post(http, "frappe.core.doctype.communication.email.make", {
+    doctype: args.doctype,
+    name: args.name,
+    recipients: args.recipients,
+    subject: args.subject,
+    content: args.content,
+    send_email: 1,
+  });
+}

package/src/formEngine/formLayout.spec.ts

@@ -0,0 +1,373 @@
+/**
+ * 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 "./doctypeMeta";
+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();
+  });
+});