@cosmicdrift/kumiko-renderer 0.327.0 → 0.328.1

package/src/__tests__/merge-search-params-into-initial.test.ts

@@ -1,525 +0,0 @@
-import { describe, expect, spyOn, test } from "bun:test";
-import type { EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import {
-  buildInitialValues,
-  literalCurrencyOverrides,
-  mergeSearchParamsIntoInitial,
-} from "../app/kumiko-screen";
-import { layoutFieldNames } from "../app/layout-fields";
-
-type FieldDef = {
-  type?: string;
-  default?: unknown;
-  sensitive?: boolean;
-  format?: string;
-  options?: readonly string[];
-  multiple?: boolean;
-  schema?: Record<string, { type?: string; options?: readonly string[] }>;
-  maxItems?: number;
-};
-
-function mergeWithAllFieldsUrlPrefillable(
-  fields: Record<string, FieldDef>,
-  searchParams: Record<string, string>,
-  renderableFields?: ReadonlySet<string>,
-  defaultCurrency?: string,
-): Record<string, unknown> {
-  return mergeSearchParamsIntoInitial(fields, {
-    searchParams,
-    urlPrefillFields: Object.keys(fields),
-    ...(renderableFields !== undefined && { renderableFields }),
-    ...(defaultCurrency !== undefined && { defaultCurrency }),
-  });
-}
-
-describe("mergeSearchParamsIntoInitial — urlPrefillFields allowlist", () => {
-  const fields: Record<string, FieldDef> = {
-    leaseId: { type: "text" },
-    iban: { type: "text", default: "DE00" },
-  };
-
-  test("a URL param for a declared field prefills it", () => {
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: { leaseId: "l-1" },
-      urlPrefillFields: ["leaseId"],
-    });
-    expect(result["leaseId"]).toBe("l-1");
-  });
-
-  test("a crafted link cannot prefill a field no navigate params declares", () => {
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: { leaseId: "l-1", iban: "attacker-iban" },
-      urlPrefillFields: ["leaseId"],
-    });
-    expect(result["leaseId"]).toBe("l-1");
-    expect(result["iban"]).toBe("DE00");
-  });
-
-  test("no urlPrefillFields (screen not from buildAppSchema) prefills nothing from the URL", () => {
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: { leaseId: "l-1", iban: "attacker-iban" },
-      urlPrefillFields: undefined,
-    });
-    expect(result["leaseId"]).toBe("");
-    expect(result["iban"]).toBe("DE00");
-  });
-
-  test("sensitive and password fields stay blocked even when allowlisted", () => {
-    const gated: Record<string, FieldDef> = {
-      secret: { type: "text", sensitive: true },
-      apiToken: { type: "text", format: "password", default: "unset" },
-    };
-    const result = mergeSearchParamsIntoInitial(gated, {
-      searchParams: { secret: "s", apiToken: "kpat_leak" },
-      urlPrefillFields: ["secret", "apiToken"],
-    });
-    expect(result["secret"]).toBe("");
-    expect(result["apiToken"]).toBe("unset");
-  });
-});
-
-describe("mergeSearchParamsIntoInitial — handoffValues", () => {
-  const fields: Record<string, FieldDef> = {
-    iban: { type: "text" },
-    amount: { type: "number", default: 0 },
-    secret: { type: "text", sensitive: true },
-    apiToken: { type: "text", format: "password" },
-  };
-
-  test("handed-off values prefill fields outside urlPrefillFields, strings coerced by field type", () => {
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: {},
-      urlPrefillFields: [],
-      handoffValues: { iban: "DE12", amount: "42" },
-    });
-    expect(result["iban"]).toBe("DE12");
-    expect(result["amount"]).toBe(42);
-  });
-
-  test("handed-off values never reach sensitive or password fields", () => {
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: {},
-      urlPrefillFields: [],
-      handoffValues: { secret: "s", apiToken: "kpat_leak" },
-    });
-    expect(result["secret"]).toBe("");
-    expect(result["apiToken"]).toBe("");
-  });
-
-  test("drawer overrides win over a handoff for the same field", () => {
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: {},
-      urlPrefillFields: [],
-      drawerOverrides: { iban: "from-row" },
-      handoffValues: { iban: "from-handoff" },
-    });
-    expect(result["iban"]).toBe("from-row");
-  });
-});
-
-describe("mergeSearchParamsIntoInitial — coercion (every field URL-prefillable)", () => {
-  test("raw string param merges in as-is for a text field", () => {
-    const fields: Record<string, FieldDef> = { name: { type: "text" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { name: "Alice" });
-    expect(result["name"]).toBe("Alice");
-  });
-
-  test("number-type field coerces a numeric string", () => {
-    const fields: Record<string, FieldDef> = { age: { type: "number" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { age: "42" });
-    expect(result["age"]).toBe(42);
-  });
-
-  test("invalid number string falls back to field default", () => {
-    const fields: Record<string, FieldDef> = { count: { type: "number", default: 7 } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { count: "not-a-number" });
-    expect(result["count"]).toBe(7);
-  });
-
-  test("boolean field coerces 'true' and 'false'", () => {
-    const fields: Record<string, FieldDef> = { active: { type: "boolean" } };
-    expect(mergeWithAllFieldsUrlPrefillable(fields, { active: "true" })["active"]).toBe(true);
-    expect(mergeWithAllFieldsUrlPrefillable(fields, { active: "false" })["active"]).toBe(false);
-  });
-
-  test("sensitive field is skipped even when a matching searchParam exists", () => {
-    const fields: Record<string, FieldDef> = { password: { type: "text", sensitive: true } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { password: "secret" });
-    expect(result["password"]).toBe("");
-  });
-
-  test("password-format field is skipped even when a matching searchParam exists (fw#2548)", () => {
-    const fields: Record<string, FieldDef> = {
-      apiToken: { type: "text", format: "password", default: "unset" },
-    };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { apiToken: "kpat_leak" });
-    expect(result["apiToken"]).toBe("unset");
-  });
-
-  test("field with no matching searchParam keeps its buildInitialValues default", () => {
-    const fields: Record<string, FieldDef> = { total: { type: "number", default: 100 } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, {});
-    expect(result["total"]).toBe(100);
-  });
-
-  test("money-type field without a defaultCurrency coerces a bare numeric string (legacy callers, e.g. config-edit/action-form)", () => {
-    const fields: Record<string, FieldDef> = { price: { type: "money" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { price: "19.99" });
-    expect(result["price"]).toBe(19.99);
-  });
-
-  test("money-type field WITH a defaultCurrency merges the entityEdit payload shape (#1923)", () => {
-    const fields: Record<string, FieldDef> = { price: { type: "money" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { price: "19.99" }, undefined, "USD");
-    expect(result["price"]).toEqual({ amount: 19.99, currency: "USD" });
-  });
-
-  test("money-type field WITH a defaultCurrency but no matching searchParam still defaults to the object shape", () => {
-    const fields: Record<string, FieldDef> = { price: { type: "money" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, {}, undefined, "USD");
-    expect(result["price"]).toEqual({ amount: 0, currency: "USD" });
-  });
-
-  test("renderableFields set given: searchParam for a non-rendered field is ignored (#1708)", () => {
-    const fields: Record<string, FieldDef> = {
-      status: { type: "text", default: "draft" },
-      ownerId: { type: "text" },
-    };
-    const result = mergeWithAllFieldsUrlPrefillable(
-      fields,
-      { status: "approved", ownerId: "user-123" },
-      new Set(["status"]),
-    );
-    expect(result["status"]).toBe("approved");
-    expect(result["ownerId"]).toBe("");
-  });
-
-  test("renderableFields from a groups-only layout: searchParam on a group field is kept", () => {
-    const screen: EntityEditScreenDefinition = {
-      id: "s",
-      type: "entityEdit",
-      entity: "e",
-      layout: { sections: [{ fields: [], groups: [{ title: "g", fields: ["status"] }] }] },
-    };
-    const fields: Record<string, FieldDef> = { status: { type: "text", default: "draft" } };
-    const result = mergeWithAllFieldsUrlPrefillable(
-      fields,
-      { status: "approved" },
-      layoutFieldNames(screen),
-    );
-    expect(result["status"]).toBe("approved");
-  });
-
-  test("no renderableFields set given (undefined): behaves as before, all fields eligible", () => {
-    const fields: Record<string, FieldDef> = { ownerId: { type: "text" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, { ownerId: "user-123" });
-    expect(result["ownerId"]).toBe("user-123");
-  });
-
-  test("multiSelect coerces comma-separated searchParam to string[]", () => {
-    const fields: Record<string, FieldDef> = { roles: { type: "multiSelect" } };
-    expect(mergeWithAllFieldsUrlPrefillable(fields, { roles: "TenantAdmin" })["roles"]).toEqual([
-      "TenantAdmin",
-    ]);
-    expect(mergeWithAllFieldsUrlPrefillable(fields, { roles: "Admin,User" })["roles"]).toEqual([
-      "Admin",
-      "User",
-    ]);
-  });
-
-  test("multiSelect coerces JSON-array searchParam to string[]", () => {
-    const fields: Record<string, FieldDef> = { roles: { type: "multiSelect" } };
-    expect(
-      mergeWithAllFieldsUrlPrefillable(fields, { roles: JSON.stringify(["Admin", "Editor"]) })[
-        "roles"
-      ],
-    ).toEqual(["Admin", "Editor"]);
-  });
-
-  test("multiSelect defaults to [] when unset", () => {
-    const fields: Record<string, FieldDef> = { roles: { type: "multiSelect" } };
-    expect(mergeWithAllFieldsUrlPrefillable(fields, {})["roles"]).toEqual([]);
-  });
-
-  test("multiSelect prefers JSON parse even without '[' prefix for quoted strings", () => {
-    const fields: Record<string, FieldDef> = { tags: { type: "multiSelect" } };
-    expect(
-      mergeWithAllFieldsUrlPrefillable(fields, { tags: JSON.stringify("Berlin, Germany") })["tags"],
-    ).toEqual(["Berlin, Germany"]);
-  });
-
-  test("multiSelect filters unknown option values when options are set", () => {
-    const fields: Record<string, FieldDef> = {
-      roles: { type: "multiSelect", options: ["Admin", "User"] },
-    };
-    expect(
-      mergeWithAllFieldsUrlPrefillable(fields, { roles: JSON.stringify(["Admin", "Hacker"]) })[
-        "roles"
-      ],
-    ).toEqual(["Admin"]);
-  });
-
-  test("money-type field parses a JSON {amount, currency} param without a defaultCurrency (fw#2763)", () => {
-    const fields: Record<string, FieldDef> = { price: { type: "money" } };
-    const result = mergeWithAllFieldsUrlPrefillable(fields, {
-      price: JSON.stringify({ amount: 19.99, currency: "CHF" }),
-    });
-    expect(result["price"]).toEqual({ amount: 19.99, currency: "CHF" });
-  });
-
-  test("money-type field: explicit JSON currency wins over defaultCurrency", () => {
-    const fields: Record<string, FieldDef> = { price: { type: "money" } };
-    const result = mergeWithAllFieldsUrlPrefillable(
-      fields,
-      { price: JSON.stringify({ amount: 19.99, currency: "CHF" }) },
-      undefined,
-      "USD",
-    );
-    expect(result["price"]).toEqual({ amount: 19.99, currency: "CHF" });
-  });
-
-  test("money-type field: bare number without a defaultCurrency keeps the number and warns (fw#2763)", () => {
-    const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-    try {
-      const fields: Record<string, FieldDef> = { price: { type: "money" } };
-      const result = mergeWithAllFieldsUrlPrefillable(fields, { price: "19.99" });
-      expect(result["price"]).toBe(19.99);
-      expect(warnSpy).toHaveBeenCalled();
-      expect(warnSpy.mock.calls[0]?.[0]).toContain("price");
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-
-  test("money-type field: JSON object with a broken shape falls back to the default and warns", () => {
-    const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-    try {
-      const fields: Record<string, FieldDef> = {
-        price: { type: "money", default: { amount: 0, currency: "EUR" } },
-      };
-      const result = mergeWithAllFieldsUrlPrefillable(fields, {
-        price: JSON.stringify({ amount: 5 }),
-      });
-      expect(result["price"]).toEqual({ amount: 0, currency: "EUR" });
-      expect(warnSpy).toHaveBeenCalled();
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-
-  test("money-type field: JSON object with a malformed currency code falls back to the default and warns", () => {
-    const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-    try {
-      const fields: Record<string, FieldDef> = {
-        price: { type: "money", default: { amount: 0, currency: "EUR" } },
-      };
-      const result = mergeWithAllFieldsUrlPrefillable(fields, {
-        price: JSON.stringify({ amount: 5, currency: "<script>" }),
-      });
-      expect(result["price"]).toEqual({ amount: 0, currency: "EUR" });
-      expect(warnSpy).toHaveBeenCalled();
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-
-  test("money-type field: a non-finite bare number falls back to the default (fw#2763)", () => {
-    const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-    try {
-      const fields: Record<string, FieldDef> = {
-        price: { type: "money", default: { amount: 0, currency: "EUR" } },
-      };
-      const result = mergeWithAllFieldsUrlPrefillable(fields, { price: "1e999" });
-      expect(result["price"]).toEqual({ amount: 0, currency: "EUR" });
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-
-  describe("embeddedList prefill (fw#2764)", () => {
-    const linesField = (extra: Partial<FieldDef> = {}): Record<string, FieldDef> => ({
-      lines: {
-        type: "embedded",
-        multiple: true,
-        schema: {
-          accountId: { type: "text" },
-          amount: { type: "money" },
-          qty: { type: "number" },
-          posted: { type: "boolean" },
-          kind: { type: "select", options: ["debit", "credit"] },
-        },
-        ...extra,
-      },
-    });
-
-    test("a JSON row list from params.map arrives complete in the field", () => {
-      const rows = [
-        { accountId: "bank", amount: 1299, qty: 2, posted: true, kind: "debit" },
-        { accountId: "cash", amount: -1299, qty: 1, posted: false, kind: "credit" },
-      ];
-      const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-        lines: JSON.stringify(rows),
-      });
-      expect(result["lines"]).toEqual(rows);
-    });
-
-    test("money cells stay signed minor-unit integers", () => {
-      const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-        lines: JSON.stringify([{ accountId: "bank", amount: -4200 }]),
-      });
-      expect(result["lines"]).toEqual([{ accountId: "bank", amount: -4200 }]);
-    });
-
-    test("a fractional money cell rejects the whole prefill and warns", () => {
-      const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-          lines: JSON.stringify([{ accountId: "bank", amount: 12.99 }]),
-        });
-        expect(result["lines"]).toEqual([]);
-        expect(warnSpy).toHaveBeenCalled();
-        expect(warnSpy.mock.calls[0]?.[0]).toContain("lines");
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-    test("a non-JSON param leaves the field empty and warns", () => {
-      const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const result = mergeWithAllFieldsUrlPrefillable(linesField(), { lines: "not-json-at-all" });
-        expect(result["lines"]).toEqual([]);
-        expect(warnSpy).toHaveBeenCalled();
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-    test("a JSON object instead of an array leaves the field empty and warns", () => {
-      const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-          lines: JSON.stringify({ accountId: "bank" }),
-        });
-        expect(result["lines"]).toEqual([]);
-        expect(warnSpy).toHaveBeenCalled();
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-    test("a row that is not an object leaves the field empty and warns", () => {
-      const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-          lines: JSON.stringify([1, 2]),
-        });
-        expect(result["lines"]).toEqual([]);
-        expect(warnSpy).toHaveBeenCalled();
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-    test("a select cell outside the declared options rejects the prefill and warns", () => {
-      const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-          lines: JSON.stringify([{ accountId: "bank", kind: "sudo" }]),
-        });
-        expect(result["lines"]).toEqual([]);
-        expect(warnSpy).toHaveBeenCalled();
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-    test("undeclared row keys are dropped instead of reaching the form", () => {
-      const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-        lines: JSON.stringify([{ accountId: "bank", secretFlag: "yes" }]),
-      });
-      expect(result["lines"]).toEqual([{ accountId: "bank" }]);
-    });
-
-    test("a __proto__ key in a row pollutes nothing", () => {
-      const result = mergeWithAllFieldsUrlPrefillable(linesField(), {
-        lines: '[{"accountId":"bank","__proto__":{"polluted":true}}]',
-      });
-      expect(result["lines"]).toEqual([{ accountId: "bank" }]);
-      expect(({} as Record<string, unknown>)["polluted"]).toBeUndefined();
-      expect(Object.getPrototypeOf((result["lines"] as unknown[])[0])).toBe(Object.prototype);
-    });
-
-    test("more rows than maxItems leaves the field empty and warns", () => {
-      const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const result = mergeWithAllFieldsUrlPrefillable(linesField({ maxItems: 2 }), {
-          lines: JSON.stringify([{ accountId: "a" }, { accountId: "b" }, { accountId: "c" }]),
-        });
-        expect(result["lines"]).toEqual([]);
-        expect(warnSpy).toHaveBeenCalled();
-      } finally {
-        warnSpy.mockRestore();
-      }
-    });
-
-    test("an embedded list without a matching param defaults to an empty array", () => {
-      const result = mergeWithAllFieldsUrlPrefillable(linesField(), {});
-      expect(result["lines"]).toEqual([]);
-    });
-
-    test("a sensitive embedded list ignores the param", () => {
-      const result = mergeWithAllFieldsUrlPrefillable(linesField({ sensitive: true }), {
-        lines: JSON.stringify([{ accountId: "bank" }]),
-      });
-      expect(result["lines"]).toEqual([]);
-    });
-  });
-});
-
-// fw#2839: an entity-less form screen passes no `defaultCurrency`, so before
-// this the money branch fell through to a bare `0` the handler's zod schema
-// rejected. `literalCurrencyOverrides` resolves a declared literal source with
-// no query; configEdit's plain-number contract depends on getting neither.
-describe("money currency sources on an entity-less form (fw#2839)", () => {
-  const amountField = (currency?: unknown): Record<string, FieldDef> => ({
-    amount: { type: "money", ...(currency !== undefined && { currency }) } as FieldDef,
-  });
-
-  test("a literal source seeds { amount: 0, currency } without any defaultCurrency", () => {
-    const fields = amountField({ kind: "literal", code: "CHF" });
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: {},
-      urlPrefillFields: [],
-      moneyCurrencyOverrides: literalCurrencyOverrides(fields),
-    });
-    expect(result["amount"]).toEqual({ amount: 0, currency: "CHF" });
-  });
-
-  test("a literal source also carries into a URL-prefilled amount (fw#2763 path)", () => {
-    const fields = amountField({ kind: "literal", code: "CHF" });
-    const result = mergeSearchParamsIntoInitial(fields, {
-      searchParams: { amount: "42.50" },
-      urlPrefillFields: ["amount"],
-      moneyCurrencyOverrides: literalCurrencyOverrides(fields),
-    });
-    expect(result["amount"]).toEqual({ amount: 42.5, currency: "CHF" });
-  });
-
-  test("literalCurrencyOverrides ignores tenant-declared and undeclared money fields", () => {
-    expect(literalCurrencyOverrides(amountField({ kind: "tenant" }))).toEqual({});
-    expect(literalCurrencyOverrides(amountField())).toEqual({});
-  });
-
-  test("configEdit stays on the plain-number contract: no overrides, no currency wrapper", () => {
-    const fields = amountField({ kind: "literal", code: "CHF" });
-    expect(buildInitialValues(fields)["amount"]).toBe(0);
-  });
-
-  test("entityEdit is unchanged: defaultCurrency still wins where no source is declared", () => {
-    expect(buildInitialValues(amountField(), "USD")["amount"]).toEqual({
-      amount: 0,
-      currency: "USD",
-    });
-  });
-});

package/src/__tests__/qn.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { toKebab as serverToKebab } from "@cosmicdrift/kumiko-framework/engine";
-import { lastSegment, toKebab } from "../app/qn";
-
-describe("lastSegment", () => {
-  test("strips feature-prefix from screen-QN", () => {
-    expect(lastSegment("publicstatus:screen:component-edit")).toBe("component-edit");
-  });
-
-  test("strips feature-prefix from nav-QN", () => {
-    expect(lastSegment("shop:nav:catalog")).toBe("catalog");
-  });
-
-  test("strips feature-prefix from workspace-QN", () => {
-    expect(lastSegment("admin:workspace:disposition")).toBe("disposition");
-  });
-
-  test("returns short-form input unchanged", () => {
-    // Defensive default — an Author who already passes a short id
-    // shouldn't get a misformatted result.
-    expect(lastSegment("component-edit")).toBe("component-edit");
-  });
-
-  test("strips only the LAST segment, not the first", () => {
-    // The QN convention is `<feature>:<kind>:<short-id>`. lastIndexOf
-    // ensures kebab-ids that themselves contain colons (defensive —
-    // kebab spec rejects them, but the helper shouldn't break).
-    expect(lastSegment("a:b:c:d")).toBe("d");
-  });
-
-  test("handles empty string", () => {
-    expect(lastSegment("")).toBe("");
-  });
-
-  test("handles trailing colon as empty segment", () => {
-    // E.g. when registry stamping is buggy and writes `feature:screen:`
-    // — the helper returns "" rather than throwing, the caller's
-    // navigate-then-not-found banner makes the bug visible.
-    expect(lastSegment("publicstatus:screen:")).toBe("");
-  });
-});
-
-describe("toKebab", () => {
-  test("camelCase entity ids match server qualifyEntityName", () => {
-    expect(toKebab("driverModel")).toBe("driver-model");
-    expect(toKebab("statementUpload")).toBe("statement-upload");
-  });
-
-  test("already kebab unchanged", () => {
-    expect(toKebab("driver-model")).toBe("driver-model");
-  });
-
-  test("preserves colon segments", () => {
-    expect(toKebab("driverModel:list")).toBe("driver-model:list");
-  });
-
-  test("consecutive uppercase (acronym boundary)", () => {
-    expect(toKebab("SSEBroadcast")).toBe("sse-broadcast");
-  });
-
-  test("dot separators become dashes", () => {
-    expect(toKebab("billing-period.create")).toBe("billing-period-create");
-  });
-
-  // Drift guard: this file is a byte-identical copy of the server's toKebab
-  // (packages/framework/src/engine/qualified-name.ts) kept in sync only by
-  // convention/comment, not by import (avoids pulling server deps into the
-  // browser bundle). Table-driven against the server's own doc examples so a
-  // future edit to either copy that breaks parity fails loudly here.
-  test("matches the server implementation for its documented examples", () => {
-    const cases = [
-      "task.create",
-      "ticketAssigned",
-      "billing-period.create",
-      "monthlyReport",
-      "SSEBroadcast",
-      "driverModel:list",
-    ];
-    for (const input of cases) {
-      expect(toKebab(input)).toBe(serverToKebab(input));
-    }
-  });
-});

package/src/__tests__/share-links.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { buildWhatsAppShareUrl } from "../share-links";
-
-describe("buildWhatsAppShareUrl", () => {
-  test("without a phone number the link opens the contact picker with the text prefilled", () => {
-    expect(buildWhatsAppShareUrl("Hallo Welt")).toBe("https://wa.me/?text=Hallo%20Welt");
-  });
-
-  test("encodes line breaks, umlauts and reserved characters so the text arrives unchanged", () => {
-    const text = "Škoda für 17.490 €\nProbefahrt? & mehr #1";
-    const url = new URL(buildWhatsAppShareUrl(text));
-    expect(url.searchParams.get("text")).toBe(text);
-  });
-
-  test("normalizes a formatted international number to digits only", () => {
-    expect(buildWhatsAppShareUrl("x", "+49 (171) 234-5678")).toBe(
-      "https://wa.me/491712345678?text=x",
-    );
-  });
-
-  test("treats a 00 prefix like +", () => {
-    expect(buildWhatsAppShareUrl("x", "0049 171 2345678")).toBe(
-      "https://wa.me/491712345678?text=x",
-    );
-  });
-});

package/src/__tests__/sort-by-accessor.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { sortByAccessor } from "../sort-by-accessor";
-
-type Row = { readonly name: string; readonly count: number };
-
-function makeRows(): readonly Row[] {
-  return [
-    { name: "b", count: 2 },
-    { name: "a", count: 3 },
-    { name: "c", count: 1 },
-  ];
-}
-
-const accessors = {
-  name: (r: Row) => r.name,
-  count: (r: Row) => r.count,
-};
-
-describe("sortByAccessor", () => {
-  test("sort === null returns rows unchanged (same reference)", () => {
-    const rows = makeRows();
-    expect(sortByAccessor(rows, null, accessors)).toBe(rows);
-  });
-
-  test("an unknown field returns rows unchanged (same reference)", () => {
-    const rows = makeRows();
-    expect(sortByAccessor(rows, { field: "nope", dir: "asc" }, accessors)).toBe(rows);
-  });
-
-  test("sorts ascending by the given accessor", () => {
-    const rows = makeRows();
-    const sorted = sortByAccessor(rows, { field: "name", dir: "asc" }, accessors);
-    expect(sorted.map((r) => r.name)).toEqual(["a", "b", "c"]);
-  });
-
-  test("sorts descending by the given accessor", () => {
-    const rows = makeRows();
-    const sorted = sortByAccessor(rows, { field: "count", dir: "desc" }, accessors);
-    expect(sorted.map((r) => r.count)).toEqual([3, 2, 1]);
-  });
-
-  test("does not mutate the input array", () => {
-    const rows = makeRows();
-    const original = [...rows];
-    sortByAccessor(rows, { field: "name", dir: "asc" }, accessors);
-    expect(rows).toEqual(original);
-  });
-});