@cosmicdrift/kumiko-renderer 0.290.0 → 0.292.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.290.0",
+  "version": "0.292.0",
   "description": "Platform-agnostic React renderer for Kumiko screens. Contains the shared logic — primitives-contract, hooks, KumikoScreen, navigation & SSE abstractions — that any platform-specific renderer (web, native) composes. No DOM, no EventSource, no react-dom.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -15,9 +15,9 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.290.0",
-    "@cosmicdrift/kumiko-headless": "0.290.0",
-    "@cosmicdrift/kumiko-types": "0.290.0",
+    "@cosmicdrift/kumiko-framework": "0.292.0",
+    "@cosmicdrift/kumiko-headless": "0.292.0",
+    "@cosmicdrift/kumiko-types": "0.292.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
@@ -28,7 +28,7 @@
     "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
     "react-dom": "^19.2.6",
-    "@cosmicdrift/kumiko-locale-de": "0.290.0"
+    "@cosmicdrift/kumiko-locale-de": "0.292.0"
   },
   "repository": {
     "type": "git",

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

@@ -1,6 +1,10 @@
 import { describe, expect, spyOn, test } from "bun:test";
 import type { EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
-import { mergeSearchParamsIntoInitial } from "../app/kumiko-screen";
+import {
+  buildInitialValues,
+  literalCurrencyOverrides,
+  mergeSearchParamsIntoInitial,
+} from "../app/kumiko-screen";
 import { layoutFieldNames } from "../app/layout-fields";
 
 type FieldDef = {
@@ -472,3 +476,50 @@ describe("mergeSearchParamsIntoInitial — coercion (every field URL-prefillable
     });
   });
 });
+
+// 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__/use-list-url-state.test.tsx

@@ -183,6 +183,55 @@ describe("useListUrlState", () => {
     });
   });
 
+  // fw#3104: the date-range facet lives in the same .f. namespace so
+  // clearFilters covers it — but both bounds have to land in ONE params
+  // update, or the second call overwrites the first.
+  test("setDateRange schreibt beide Grenzen atomar + resettet page", () => {
+    const nav = makeNav({ "orders.page": "4" });
+    const { result } = renderHook(() => useListUrlState("orders"), { wrapper: wrapper(nav) });
+    act(() => {
+      result.current.setDateRange("createdAt", { from: "2020-06-10", to: "2020-06-14" });
+    });
+    expect(nav.captures).toHaveLength(1);
+    expect(nav.captures[0]).toEqual({
+      "orders.f.createdAt.from": "2020-06-10",
+      "orders.f.createdAt.to": "2020-06-14",
+      "orders.page": null,
+    });
+  });
+
+  test("setDateRange mit leerer Grenze löscht nur diesen Key", () => {
+    const nav = makeNav({
+      "orders.f.createdAt.from": "2020-06-10",
+      "orders.f.createdAt.to": "2020-06-14",
+    });
+    const { result } = renderHook(() => useListUrlState("orders"), { wrapper: wrapper(nav) });
+    act(() => {
+      result.current.setDateRange("createdAt", { from: "", to: "2020-06-14" });
+    });
+    expect(nav.captures[0]).toEqual({
+      "orders.f.createdAt.from": null,
+      "orders.f.createdAt.to": "2020-06-14",
+      "orders.page": null,
+    });
+  });
+
+  test("clearFilters löscht auch die Zeitraum-Grenzen", () => {
+    const nav = makeNav({
+      "orders.f.createdAt.from": "2020-06-10",
+      "orders.f.createdAt.to": "2020-06-14",
+    });
+    const { result } = renderHook(() => useListUrlState("orders"), { wrapper: wrapper(nav) });
+    act(() => {
+      result.current.clearFilters();
+    });
+    expect(nav.captures[0]).toEqual({
+      "orders.page": null,
+      "orders.f.createdAt.from": null,
+      "orders.f.createdAt.to": null,
+    });
+  });
+
   test("clearFilters löscht alle aktiven .f.<field>-Keys", () => {
     const nav = makeNav({
       "orders.f.status": "draft",

package/src/app/__tests__/list-daterange-facet.test.ts

@@ -0,0 +1,165 @@
+// fw#3104: a dateRange facet turns two calendar dates into the two query
+// params it declares. The conversion is the whole risk surface — a calendar
+// date has no time, `createdAt` is an instant, and "to the 14th" has to mean
+// "through the end of the 14th" in the viewer's zone, not "at 00:00".
+
+import { describe, expect, test } from "bun:test";
+import type { ListFacetSpec } from "@cosmicdrift/kumiko-framework/ui-types";
+import { Temporal } from "temporal-polyfill";
+import {
+  buildDateRangePayload,
+  clampDateRange,
+  readDateRange,
+  resolveDateRangeFacets,
+  resolveProjectionFacetSpecs,
+} from "../list-facets";
+
+const VIENNA = "Europe/Vienna";
+
+const auditFacets: readonly ListFacetSpec[] = [
+  {
+    type: "dateRange",
+    field: "createdAt",
+    label: "audit.log.col.when",
+    params: { from: "from", to: "to" },
+  },
+];
+
+const specs = resolveDateRangeFacets(auditFacets, (key) => key);
+
+function payload(
+  filters: Record<string, readonly string[]>,
+  timeZone = VIENNA,
+): Record<string, string> {
+  return buildDateRangePayload(specs, filters, timeZone);
+}
+
+describe("dateRange facet resolution", () => {
+  test("resolves the declared param names, not a from/to convention", () => {
+    const resolved = resolveDateRangeFacets(
+      [
+        {
+          type: "dateRange",
+          field: "occurredAt",
+          label: "when",
+          params: { from: "since", to: "until" },
+        },
+      ],
+      (key) => key,
+    );
+    expect(resolved).toEqual([
+      { field: "occurredAt", label: "when", fromParam: "since", toParam: "until" },
+    ]);
+  });
+
+  test("stays out of the option-dropdown facets (no `filters` entry)", () => {
+    expect(resolveProjectionFacetSpecs(auditFacets, (key) => key, "audit")).toEqual([]);
+  });
+
+  test("reads both bounds out of the shared f.<field> URL namespace", () => {
+    expect(
+      readDateRange(
+        { "createdAt.from": ["2020-06-10"], "createdAt.to": ["2020-06-14"] },
+        "createdAt",
+      ),
+    ).toEqual({ from: "2020-06-10", to: "2020-06-14" });
+    expect(readDateRange({}, "createdAt")).toEqual({ from: "", to: "" });
+  });
+});
+
+describe("dateRange facet → query params", () => {
+  test("both bounds travel under the declared param names", () => {
+    expect(payload({ "createdAt.from": ["2020-06-10"], "createdAt.to": ["2020-06-14"] })).toEqual({
+      from: "2020-06-09T22:00:00Z",
+      to: "2020-06-14T21:59:59.999999999Z",
+    });
+  });
+
+  test("open interval: only `from` set sends only that param", () => {
+    expect(payload({ "createdAt.from": ["2020-06-10"] })).toEqual({ from: "2020-06-09T22:00:00Z" });
+  });
+
+  test("open interval: only `to` set sends only that param", () => {
+    expect(payload({ "createdAt.to": ["2020-06-14"] })).toEqual({
+      to: "2020-06-14T21:59:59.999999999Z",
+    });
+  });
+
+  test("no bounds set sends nothing", () => {
+    expect(payload({})).toEqual({});
+  });
+
+  test("a half-typed or hand-crafted URL value is dropped, not sent", () => {
+    expect(payload({ "createdAt.from": ["2020-06"], "createdAt.to": ["nonsense"] })).toEqual({});
+  });
+
+  test("bounds follow the viewer's zone", () => {
+    expect(payload({ "createdAt.from": ["2020-06-10"] }, "UTC")).toEqual({
+      from: "2020-06-10T00:00:00Z",
+    });
+  });
+
+  test("DST: the day the clock jumps forward is still bounded by its own edges", () => {
+    // 2020-03-29 is 23h long in Vienna — a naive +24h end-of-day would spill
+    // an hour into the 30th.
+    expect(payload({ "createdAt.from": ["2020-03-29"], "createdAt.to": ["2020-03-29"] })).toEqual({
+      from: "2020-03-28T23:00:00Z",
+      to: "2020-03-29T21:59:59.999999999Z",
+    });
+  });
+});
+
+describe("dateRange facet timezone edge (issue #3104)", () => {
+  test("an event at 23:59 of the `to` day falls inside the range", () => {
+    const { from, to } = payload({
+      "createdAt.from": ["2020-06-14"],
+      "createdAt.to": ["2020-06-14"],
+    });
+    if (from === undefined || to === undefined) throw new Error("expected both bounds");
+    const lateEvent = Temporal.ZonedDateTime.from(`2020-06-14T23:59:00[${VIENNA}]`).toInstant();
+    expect(Temporal.Instant.compare(lateEvent, Temporal.Instant.from(from))).toBeGreaterThan(0);
+    // The handler filters with `lte`, so the last instant of the day counts.
+    expect(Temporal.Instant.compare(lateEvent, Temporal.Instant.from(to))).toBeLessThanOrEqual(0);
+  });
+
+  test("the next day's first moment falls outside", () => {
+    const { to } = payload({ "createdAt.to": ["2020-06-14"] });
+    if (to === undefined) throw new Error("expected a `to` bound");
+    const nextDay = Temporal.ZonedDateTime.from(`2020-06-15T00:00:00[${VIENNA}]`).toInstant();
+    expect(Temporal.Instant.compare(nextDay, Temporal.Instant.from(to))).toBeGreaterThan(0);
+  });
+});
+
+describe("clampDateRange keeps from <= to", () => {
+  test("a `from` past the current `to` pushes `to` along", () => {
+    expect(clampDateRange({ from: "2020-06-01", to: "2020-06-10" }, "from", "2020-06-20")).toEqual({
+      from: "2020-06-20",
+      to: "2020-06-20",
+    });
+  });
+
+  test("a `to` before the current `from` pulls `from` along", () => {
+    expect(clampDateRange({ from: "2020-06-10", to: "2020-06-20" }, "to", "2020-06-01")).toEqual({
+      from: "2020-06-01",
+      to: "2020-06-01",
+    });
+  });
+
+  test("a valid bound leaves the other alone", () => {
+    expect(clampDateRange({ from: "2020-06-01", to: "2020-06-20" }, "from", "2020-06-05")).toEqual({
+      from: "2020-06-05",
+      to: "2020-06-20",
+    });
+  });
+
+  test("clearing a bound never drags the other one with it", () => {
+    expect(clampDateRange({ from: "2020-06-10", to: "2020-06-20" }, "from", "")).toEqual({
+      from: "",
+      to: "2020-06-20",
+    });
+    expect(clampDateRange({ from: "2020-06-10", to: "2020-06-20" }, "to", "")).toEqual({
+      from: "2020-06-10",
+      to: "",
+    });
+  });
+});

package/src/app/__tests__/list-filter-facets.test.tsx

@@ -106,10 +106,11 @@ function renderScreen(
   schema: FeatureSchema,
   qn: string,
   dispatcher: Dispatcher = stubDispatcher(),
+  timeZone = "UTC",
 ): void {
   render(
     <LocaleProvider
-      resolver={createStaticLocaleResolver({ locale: "de-DE" })}
+      resolver={createStaticLocaleResolver({ locale: "de-DE", timeZone })}
       fallbackBundles={[kumikoDefaultTranslations]}
     >
       <DispatcherProvider dispatcher={dispatcher}>
@@ -426,3 +427,92 @@ describe("projectionList filter + facets (fw#2224)", () => {
     });
   });
 });
+
+// fw#3104: a dateRange facet is the first facet that does NOT travel in
+// payload.filters — its two bounds go out as the top-level params the screen
+// declares. A screen may declare it as its only facet, so the wiring must not
+// hang off the option-facet path.
+describe("projectionList dateRange facet (fw#3104)", () => {
+  const dateRangeScreen: ProjectionListScreenDefinition = {
+    id: "event-list",
+    type: "projectionList",
+    query: "ledger:query:event:list",
+    columns: ["createdAt"],
+    facets: [
+      {
+        field: "createdAt",
+        type: "dateRange",
+        label: "When",
+        params: { from: "from", to: "to" },
+      },
+    ],
+  };
+  const schema: FeatureSchema = {
+    featureName: "ledger",
+    entities: {},
+    screens: [dateRangeScreen],
+  } as FeatureSchema;
+
+  test("reaches the DataTable as a dateRange facet, not as a filter dropdown", async () => {
+    queryCalls = [];
+    capturedProps = undefined;
+    renderScreen(schema, "ledger:screen:event-list");
+
+    await waitFor(() => expect(capturedProps).toBeDefined());
+    const props = getCapturedProps();
+    if (props === undefined) throw new Error("DataTable was not rendered");
+    expect(props.dateRangeFacets).toEqual([
+      { field: "createdAt", label: "When", from: "", to: "" },
+    ]);
+    expect(props.filterFacets).toBeUndefined();
+    // Reset still has to be reachable on a dateRange-only screen.
+    expect(props.onFilterReset).toBeDefined();
+    expect(queryCalls[0]?.payload).not.toHaveProperty("from");
+  });
+
+  test("picking a bound sends it as the declared query param, in the viewer's zone", async () => {
+    queryCalls = [];
+    capturedProps = undefined;
+    renderScreen(schema, "ledger:screen:event-list", stubDispatcher(), "Europe/Vienna");
+
+    await waitFor(() => expect(capturedProps).toBeDefined());
+    const before = queryCalls.length;
+    await act(async () => {
+      getCapturedProps()?.onDateRangeChange?.("createdAt", "to", "2020-06-14");
+    });
+    await waitFor(() => expect(queryCalls.length).toBeGreaterThan(before));
+    const payload = queryCalls[queryCalls.length - 1]?.payload;
+    // Open interval: only the bound the user picked travels.
+    expect(payload).toMatchObject({ to: "2020-06-14T21:59:59.999999999Z" });
+    expect(payload).not.toHaveProperty("from");
+    expect(payload).not.toHaveProperty("filters");
+    expect(getCapturedProps()?.dateRangeFacets).toEqual([
+      { field: "createdAt", label: "When", from: "", to: "2020-06-14" },
+    ]);
+  });
+
+  test("a `from` past the current `to` is clamped before it can reach the handler's refine", async () => {
+    queryCalls = [];
+    capturedProps = undefined;
+    renderScreen(schema, "ledger:screen:event-list", stubDispatcher(), "Europe/Vienna");
+
+    await waitFor(() => expect(capturedProps).toBeDefined());
+    await act(async () => {
+      getCapturedProps()?.onDateRangeChange?.("createdAt", "to", "2020-06-14");
+    });
+    await act(async () => {
+      getCapturedProps()?.onDateRangeChange?.("createdAt", "from", "2020-06-20");
+    });
+    await waitFor(() =>
+      expect(getCapturedProps()?.dateRangeFacets).toEqual([
+        { field: "createdAt", label: "When", from: "2020-06-20", to: "2020-06-20" },
+      ]),
+    );
+    const payload = queryCalls[queryCalls.length - 1]?.payload as Record<string, string>;
+    const from = payload["from"];
+    const to = payload["to"];
+    expect(from).toBeString();
+    expect(to).toBeString();
+    expect((from ?? "") <= (to ?? "")).toBe(true);
+  });
+});

package/src/app/__tests__/projection-detail-reference-field.test.tsx

@@ -18,6 +18,8 @@ import { KumikoScreen } from "../kumiko-screen";
 import type { NavApi } from "../nav";
 import { NavProvider } from "../nav";
 
+const SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
+
 const noop = (): ReactNode => null;
 const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
 // passChildren would drop testId — ReadOnlyReferenceValue/readOnlyDisplayText
@@ -55,7 +57,7 @@ function stubDispatcher(): Dispatcher {
       if (type === "sessions:query:session:detail") {
         return {
           isSuccess: true,
-          data: { id: "sess-1", userId: "u-1", ip: "10.0.0.1" },
+          data: { id: "sess-1", userId: "u-1", actedBy: SYSTEM_USER_ID, ip: "10.0.0.1" },
         };
       }
       if (type === "user:query:user:list") {
@@ -84,7 +86,13 @@ const detailScreen: ProjectionDetailScreenDefinition = {
   layout: {
     sections: [
       {
-        fields: [{ field: "userId", refEntity: "user:user", refLabelField: "displayName" }, "ip"],
+        fields: [
+          { field: "userId", refEntity: "user:user", refLabelField: "displayName" },
+          // Mirrors the audit-log detail actor field (fw#3103) — a system
+          // write has no read_users row for the bulk lookup to find.
+          { field: "actedBy", refEntity: "user:user", refLabelField: "displayName" },
+          "ip",
+        ],
       },
     ],
   },
@@ -137,6 +145,14 @@ describe("projectionDetail reference field resolves labels (fw#2662)", () => {
     });
   });
 
+  test("SYSTEM_USER_ID resolves to the system label instead of the raw id (fw#3103)", async () => {
+    const { getByTestId } = renderDetailScreen();
+
+    await waitFor(() => {
+      expect(getByTestId("field-value-actedBy").textContent).toBe("System");
+    });
+  });
+
   test("non-regression: a field without refEntity metadata renders its raw value unchanged", async () => {
     const { getByTestId } = renderDetailScreen();
 

package/src/app/__tests__/projection-list-reference-column.test.tsx

@@ -6,7 +6,10 @@
 // text back off the reference column's injected runtime renderer.
 
 import { describe, expect, test } from "bun:test";
-import type { ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type {
+  ListColumnSpec,
+  ProjectionListScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Dispatcher, RuntimeRenderer } from "@cosmicdrift/kumiko-headless";
 import { render, waitFor } from "@testing-library/react";
 import type { ComponentType, ReactNode } from "react";
@@ -21,6 +24,9 @@ import { NavProvider } from "../nav";
 
 const SYSTEM_TENANT_ID = "00000000-0000-4000-8000-000000000000";
 const REAL_TENANT_ID = "11111111-1111-4111-8111-111111111111";
+const SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
+const REAL_USER_ID = "22222222-2222-4222-8222-222222222222";
+const DELETED_USER_ID = "33333333-3333-4333-8333-333333333333";
 
 let capturedProps: DataTableProps | undefined;
 const captureDataTable: ComponentType<DataTableProps> = (props) => {
@@ -61,8 +67,9 @@ function stubDispatcher(): Dispatcher {
           isSuccess: true,
           data: {
             rows: [
-              { id: "row-1", tenantId: REAL_TENANT_ID },
-              { id: "row-2", tenantId: SYSTEM_TENANT_ID },
+              { id: "row-1", tenantId: REAL_TENANT_ID, createdBy: REAL_USER_ID },
+              { id: "row-2", tenantId: SYSTEM_TENANT_ID, createdBy: SYSTEM_USER_ID },
+              { id: "row-3", tenantId: REAL_TENANT_ID, createdBy: DELETED_USER_ID },
             ],
             nextCursor: null,
           },
@@ -74,6 +81,12 @@ function stubDispatcher(): Dispatcher {
           data: { rows: [{ id: REAL_TENANT_ID, name: "Acme Inc" }], nextCursor: null },
         };
       }
+      if (type === "user:query:user:list") {
+        return {
+          isSuccess: true,
+          data: { rows: [{ id: REAL_USER_ID, displayName: "Ada Lovelace" }], nextCursor: null },
+        };
+      }
       return { isSuccess: true, data: { rows: [], nextCursor: null } };
     }) as unknown as Dispatcher["query"],
     batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
@@ -95,6 +108,21 @@ function buildSchema(screen: ProjectionListScreenDefinition): FeatureSchema {
   } as FeatureSchema;
 }
 
+const TENANT_COLUMN: ListColumnSpec = {
+  field: "tenantId",
+  label: "delivery.log.col.tenantId",
+  refEntity: "tenant:tenant",
+  refLabelField: "name",
+};
+
+// Mirrors the audit-log actor column (fw#3103).
+const ACTOR_COLUMN: ListColumnSpec = {
+  field: "createdBy",
+  label: "audit.log.col.actor",
+  refEntity: "user:user",
+  refLabelField: "displayName",
+};
+
 const staticNav: NavApi = {
   route: { screenId: "delivery:screen:log" },
   navigate: () => {},
@@ -104,19 +132,12 @@ const staticNav: NavApi = {
   setSearchParams: () => {},
 };
 
-function renderLogScreen(): void {
+function renderLogScreen(column: ListColumnSpec = TENANT_COLUMN): void {
   const screen: ProjectionListScreenDefinition = {
     id: "log",
     type: "projectionList",
     query: "delivery:query:log:list",
-    columns: [
-      {
-        field: "tenantId",
-        label: "delivery.log.col.tenantId",
-        refEntity: "tenant:tenant",
-        refLabelField: "name",
-      },
-    ],
+    columns: [column],
   };
   render(
     <LocaleProvider
@@ -134,8 +155,8 @@ function renderLogScreen(): void {
   );
 }
 
-function referenceRenderer(): RuntimeRenderer {
-  const col = getCapturedProps()?.columns.find((c) => c.field === "tenantId");
+function referenceRenderer(field = "tenantId"): RuntimeRenderer {
+  const col = getCapturedProps()?.columns.find((c) => c.field === field);
   if (typeof col?.renderer !== "function") throw new Error("reference column has no renderer yet");
   return col.renderer as RuntimeRenderer;
 }
@@ -159,3 +180,35 @@ describe("projectionList reference column resolves labels (fw#2662)", () => {
     });
   });
 });
+
+describe("actor column resolves display names (fw#3103)", () => {
+  const actorCell = (id: string): unknown => referenceRenderer("createdBy")(id, { createdBy: id });
+
+  test("a real user id resolves to the display name", async () => {
+    capturedProps = undefined;
+    renderLogScreen(ACTOR_COLUMN);
+
+    await waitFor(() => {
+      expect(actorCell(REAL_USER_ID)).toBe("Ada Lovelace");
+    });
+  });
+
+  test("SYSTEM_USER_ID resolves to the system label", async () => {
+    capturedProps = undefined;
+    renderLogScreen(ACTOR_COLUMN);
+
+    await waitFor(() => {
+      expect(actorCell(SYSTEM_USER_ID)).toBe("System");
+    });
+  });
+
+  test("an unresolvable actor (deleted user) falls back to the raw id without throwing", async () => {
+    capturedProps = undefined;
+    renderLogScreen(ACTOR_COLUMN);
+
+    await waitFor(() => {
+      expect(actorCell(REAL_USER_ID)).toBe("Ada Lovelace");
+    });
+    expect(actorCell(DELETED_USER_ID)).toBe(DELETED_USER_ID);
+  });
+});