@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

package/src/ui-types/app-schema.ts

@@ -7,6 +7,7 @@
 // web), Runtime-Helpers (toAppSchema, isAppSchema) bleiben renderer-side
 // weil das die Layer ist die mit den AppSchemas zur Laufzeit arbeitet.
 
+import type { TranslationKeys } from "../engine/types/config";
 import type { EntityDefinition } from "../engine/types/fields";
 import type { NavDefinition } from "../engine/types/nav";
 import type { ScreenDefinition } from "../engine/types/screen";
@@ -19,6 +20,17 @@ export type FeatureSchema = {
   // Flat list; resolveNavigation builds the tree at render-time from
   // the registry's indexes. Omitted when the app has no top-level nav.
   readonly navs?: readonly NavDefinition[];
+  // Server-authored `r.translations({ keys })`, projected verbatim — byte-
+  // identical keys, NOT re-prefixed with featureName (unlike the registry's
+  // internal mergedTranslations, which double-prefixes features that
+  // already qualify their own keys — see registry-ingest.ts populate
+  // Translations). Nav/screen labels resolve these keys directly via
+  // `t(label)`, so shipping anything other than the raw authored string
+  // would break the lookup. Omitted when a feature declares none. #1059:
+  // without this, nav labels only resolved when an app ALSO duplicated the
+  // key in `web/i18n.ts` — most bundled features never did, so labels
+  // rendered as raw i18n keys in the shell.
+  readonly translations?: TranslationKeys;
   // Workspaces — Legacy-Slot für single-feature-Apps. Bevorzugt liegt
   // workspaces auf der AppSchema-Ebene weil ihre navMembers regelmäßig
   // Cross-Feature-Navs referenzieren (siehe AppSchema-Doc). Hier als

package/src/ui-types/index.ts

@@ -22,6 +22,13 @@
 
 export type { ParsedRefTarget } from "../engine/parse-ref-target";
 export { parseRefTarget } from "../engine/parse-ref-target";
+export {
+  evalFieldCondition,
+  isExtensionEditSection,
+  isFormatSpec,
+  normalizeEditField,
+  normalizeListColumn,
+} from "../engine/screen-helpers";
 // Entity + field types. EntityDefinition is the canonical shape that
 // view-model builders iterate; FieldDefinition is the per-field union
 // (text, number, boolean, ...) they branch on. AccessRule is used by
@@ -46,6 +53,16 @@ export type {
   ConfigEditScreenDefinition,
   CustomScreenDefinition,
   CustomScreenRoute,
+  DashboardChartPanel,
+  DashboardCustomPanel,
+  DashboardFeedPanel,
+  DashboardFilterDefinition,
+  DashboardListPanel,
+  DashboardPanelDefinition,
+  DashboardProgressListPanel,
+  DashboardScreenDefinition,
+  DashboardStatGroupPanel,
+  DashboardStatPanel,
   EditExtensionSection,
   EditFieldSpec,
   EditFieldsSection,
@@ -57,6 +74,8 @@ export type {
   FieldRenderer,
   ListColumnSpec,
   PlatformComponent,
+  ProjectionDetailScreenDefinition,
+  ProjectionListScreenDefinition,
   RowAction,
   RowActionNavigate,
   RowActionWriteHandler,
@@ -67,14 +86,8 @@ export type {
   ScreenSlots,
   ToolbarAction,
 } from "../engine/types/screen";
-export {
-  evalFieldCondition,
-  isExtensionEditSection,
-  isFormatSpec,
-  normalizeEditField,
-  normalizeListColumn,
-} from "../engine/types/screen";
 export type { TargetRef } from "../engine/types/target-ref";
 export type { TreeAction, TreeNode, TreeNodeState } from "../engine/types/tree-node";
 export type { WorkspaceDefinition } from "../engine/types/workspace";
+export { PROJECTION_DETAIL_ENTITY } from "../i18n/required-surface-keys";
 export type { AppSchema, FeatureSchema, WorkspaceSchema } from "./app-schema";

package/src/utils/__tests__/safe-json-temporal.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+import { Temporal as PolyfillTemporal } from "temporal-polyfill";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
+import { stringifyJson } from "../safe-json";
+
+describe("stringifyJson — Temporal.Instant (native + polyfill)", () => {
+  test("serializes polyfill Instant", () => {
+    const instant = PolyfillTemporal.Instant.from("2026-01-01T00:00:00Z");
+    expect(stringifyJson({ at: instant })).toBe('{"at":"2026-01-01T00:00:00Z"}');
+  });
+
+  test("serializes ambient/native Instant when present", async () => {
+    await ensureTemporalPolyfill();
+    const T = (globalThis as unknown as { Temporal: typeof PolyfillTemporal }).Temporal;
+    const instant = T.Instant.from("2026-06-15T12:00:00Z");
+    expect(stringifyJson({ at: instant })).toBe('{"at":"2026-06-15T12:00:00Z"}');
+  });
+});

package/src/utils/safe-json.ts

@@ -29,6 +29,15 @@ export function parseJsonOrThrow<T>(raw: string, context: string): T {
   }
 }
 
+/** True for native or polyfill Temporal.Instant (distinct constructors). */
+function isTemporalInstant(v: unknown): v is { toString(): string } {
+  return (
+    typeof v === "object" &&
+    v !== null &&
+    Object.prototype.toString.call(v) === "[object Temporal.Instant]"
+  );
+}
+
 /** JSON.stringify that survives BigInt / Temporal values from DB rows. */
 export function stringifyJson(value: unknown): string {
   return JSON.stringify(value, (_key, v) => {
@@ -43,7 +52,10 @@ export function stringifyJson(value: unknown): string {
       }
       return v.toString();
     }
-    if (v instanceof Temporal.Instant) return v.toString();
+    // Duck-tag, not instanceof: ensureTemporalPolyfill keeps native
+    // globalThis.Temporal when present, so DB Instants may be native while
+    // other code paths use temporal-polyfill's Instant (fw#1550 / Bugbot).
+    if (isTemporalInstant(v)) return v.toString();
     return v;
   });
 }

package/src/__tests__/raw-table.integration.test.ts

@@ -1,116 +0,0 @@
-// Integration test for r.rawTable() — proves the full boot path:
-// defineFeature declares a raw table → setupTestStack auto-pushes it →
-// INSERT/SELECT against the real DB roundtrip. Plan reference:
-// kumiko-platform/docs/plans/architecture/table-ddl-guard.md (Stufe 3).
-
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { table, text, timestamp } from "../db/dialect";
-import { asRawClient, insertOne, selectMany } from "../db/query";
-import { defineFeature } from "../engine";
-import { setupTestStack, type TestStack, unsafePushTables } from "../stack";
-
-// External-system payload cache — the textbook r.rawTable() use case:
-// write-only by an integration handler, read-only by a query, never
-// event-sourced (the data isn't a domain fact, it's a side-effect
-// snapshot).
-const stripeWebhookCache = table("rt_int_stripe_webhook_cache", {
-  eventId: text("event_id").primaryKey(),
-  payload: text("payload").notNull(),
-  receivedAt: timestamp("received_at", { withTimezone: true }).notNull().defaultNow(),
-});
-
-// A second physical table reachable through two distinct r.rawTable
-// registrations — pins the seenTables-by-reference dedupe at push time.
-// Two logical names, one CREATE.
-const sharedSyncCache = table("rt_int_shared_sync_cache", {
-  syncId: text("sync_id").primaryKey(),
-  payload: text("payload").notNull(),
-});
-
-const webhookCacheFeature = defineFeature("webhook-cache", (r) => {
-  r.rawTable("stripe", stripeWebhookCache, {
-    reason: "external Stripe webhook payload cache — write-only by webhook handler",
-  });
-  r.rawTable("primary-sync", sharedSyncCache, {
-    reason: "shared sync-state cache, primary writer",
-  });
-  r.rawTable("secondary-sync", sharedSyncCache, {
-    reason: "same physical table, different logical role for read consumers",
-  });
-});
-
-let stack: TestStack;
-
-beforeAll(async () => {
-  stack = await setupTestStack({ features: [webhookCacheFeature] });
-});
-
-afterAll(async () => {
-  await stack.cleanup();
-});
-
-describe("r.rawTable — DB roundtrip via setupTestStack", () => {
-  test("table is auto-pushed and accepts INSERT + SELECT", async () => {
-    const eventId = "evt_test_123";
-    const payload = JSON.stringify({ type: "invoice.paid", amount: 4200 });
-
-    await insertOne(stack.db, stripeWebhookCache, { eventId, payload });
-
-    const rows = await selectMany(stack.db, stripeWebhookCache, { eventId: eventId });
-
-    expect(rows).toHaveLength(1);
-    expect(rows[0]?.payload).toBe(payload);
-    expect(rows[0]?.receivedAt).toBeInstanceOf(Temporal.Instant);
-  });
-
-  test("registry exposes the raw table with its reason and featureName", () => {
-    const all = stack.registry.getAllRawTables();
-    const entry = all.get("stripe");
-    expect(entry).toBeDefined();
-    expect(entry?.featureName).toBe("webhook-cache");
-    expect(entry?.reason).toContain("Stripe webhook payload cache");
-    expect(entry?.table).toBe(stripeWebhookCache);
-  });
-
-  test("INSERT bypasses the event store — no kumiko_events row produced", async () => {
-    // Proves that the rawTable lives outside the event-sourcing graph:
-    // a write to it shouldn't append anything to kumiko_events. If a
-    // future regression accidentally routed raw-table writes through
-    // the executor, a row would show up here.
-    const before = await asRawClient(stack.db).unsafe<{ count: string }>(
-      `SELECT COUNT(*)::text AS count FROM kumiko_events`,
-    );
-    const beforeCount = Number(before[0]?.count ?? 0);
-
-    await insertOne(stack.db, stripeWebhookCache, {
-      eventId: "evt_no_event_emitted",
-      payload: "{}",
-    });
-
-    const after = await asRawClient(stack.db).unsafe<{ count: string }>(
-      `SELECT COUNT(*)::text AS count FROM kumiko_events`,
-    );
-    const afterCount = Number(after[0]?.count ?? 0);
-
-    expect(afterCount).toBe(beforeCount);
-  });
-
-  test("two registrations sharing one PgTable result in one CREATE (dedupe by reference)", async () => {
-    // primary-sync + secondary-sync both target sharedSyncCache. If the
-    // setupTestStack dedupe (seenTables-by-table-reference) had silently
-    // broken, beforeAll's setupTestStack would have raised a 42P07 on
-    // the second push and never reached this test.
-    await insertOne(stack.db, sharedSyncCache, { syncId: "sync_1", payload: "{}" });
-    const rows = await selectMany(stack.db, sharedSyncCache, { syncId: "sync_1" });
-    expect(rows).toHaveLength(1);
-    // Both registrations are visible in the registry — same physical
-    // target, different logical handles.
-    expect(stack.registry.getAllRawTables().get("primary-sync")?.table).toBe(sharedSyncCache);
-    expect(stack.registry.getAllRawTables().get("secondary-sync")?.table).toBe(sharedSyncCache);
-  });
-
-  test("a second push on the same rawTable is idempotent — CREATE IF NOT EXISTS", async () => {
-    // unsafePushTables uses CREATE TABLE IF NOT EXISTS — idempotent by design.
-    await expect(unsafePushTables(stack.db, { idem: stripeWebhookCache })).resolves.toBeUndefined();
-  });
-});

package/src/bun-db/__tests__/bun-test-stack.ts

@@ -1,6 +0,0 @@
-// Provider-agnostic Test-Stack — re-exported from stack/test-stack.ts.
-// setupBunTestStack / BunTestStack sind Aliase für setupTestStack / TestStack.
-// "Bun" ist historisch, jetzt provider-neutral (DB_PROVIDER env).
-
-export type { TestStack as BunTestStack } from "../../stack/test-stack";
-export { setupTestStack as setupBunTestStack } from "../../stack/test-stack";

package/src/db/__tests__/encryption.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createEncryptionProvider } from "../encryption";
-
-// 32 bytes base64-encoded for AES-256
-const TEST_KEY = Buffer.from("a]bJm#kP9xQ2@wN!vL$hR5yT8eU0iO3f").toString("base64");
-
-describe("EncryptionProvider", () => {
-  test("encrypt + decrypt roundtrip returns original", () => {
-    const provider = createEncryptionProvider(TEST_KEY);
-    const ciphertext = provider.encrypt("hello world");
-    expect(provider.decrypt(ciphertext)).toBe("hello world");
-  });
-
-  test("same plaintext produces different ciphertexts (random IV)", () => {
-    const provider = createEncryptionProvider(TEST_KEY);
-    const a = provider.encrypt("same");
-    const b = provider.encrypt("same");
-    expect(a).not.toBe(b);
-  });
-
-  test("decrypt with different key throws", () => {
-    const key2 = Buffer.from("x]bJm#kP9xQ2@wN!vL$hR5yT8eU0iO3f").toString("base64");
-    const p1 = createEncryptionProvider(TEST_KEY);
-    const p2 = createEncryptionProvider(key2);
-    const ciphertext = p1.encrypt("secret");
-    expect(() => p2.decrypt(ciphertext)).toThrow();
-  });
-
-  test("handles unicode and emoji", () => {
-    const provider = createEncryptionProvider(TEST_KEY);
-    const ciphertext = provider.encrypt("Ünïcödé 🔐");
-    expect(provider.decrypt(ciphertext)).toBe("Ünïcödé 🔐");
-  });
-
-  test("throws on invalid key length", () => {
-    const shortKey = Buffer.from("too-short").toString("base64");
-    expect(() => createEncryptionProvider(shortKey)).toThrow(/32 bytes/);
-  });
-});

package/src/db/encryption.ts

@@ -1,39 +0,0 @@
-import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
-
-const ALGORITHM = "aes-256-gcm";
-const IV_LENGTH = 12;
-const TAG_LENGTH = 16;
-
-export type EncryptionProvider = {
-  encrypt(plaintext: string): string;
-  decrypt(ciphertext: string): string;
-};
-
-export function createEncryptionProvider(key: string): EncryptionProvider {
-  // Key must be 32 bytes for AES-256
-  const keyBuffer = Buffer.from(key, "base64");
-  if (keyBuffer.length !== 32) {
-    throw new Error("ENCRYPTION_KEY must be 32 bytes (base64 encoded)");
-  }
-
-  return {
-    encrypt(plaintext: string): string {
-      const iv = randomBytes(IV_LENGTH);
-      const cipher = createCipheriv(ALGORITHM, keyBuffer, iv);
-      const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-      const tag = cipher.getAuthTag();
-      // Format: base64(iv + tag + ciphertext)
-      return Buffer.concat([iv, tag, encrypted]).toString("base64");
-    },
-
-    decrypt(ciphertext: string): string {
-      const data = Buffer.from(ciphertext, "base64");
-      const iv = data.subarray(0, IV_LENGTH);
-      const tag = data.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
-      const encrypted = data.subarray(IV_LENGTH + TAG_LENGTH);
-      const decipher = createDecipheriv(ALGORITHM, keyBuffer, iv);
-      decipher.setAuthTag(tag);
-      return decipher.update(encrypted) + decipher.final("utf8");
-    },
-  };
-}

package/src/db/row-helpers.ts

@@ -1,4 +0,0 @@
-// Legacy re-export shim — fetchOne lebt jetzt in src/bun-db/query.ts.
-
-export type { WhereObject } from "../db/query";
-export { fetchOne } from "../db/query";

package/src/engine/__tests__/raw-table.test.ts

@@ -1,150 +0,0 @@
-// Unit tests for r.rawTable() — declaration-time validation + registry
-// aggregation. Full DB roundtrip (setupTestStack pushes the table → INSERT
-// / SELECT) lives in src/__tests__/raw-table.integration.ts.
-
-import { describe, expect, test } from "bun:test";
-import type { SchemaTable } from "../../db/dialect";
-import { table, text } from "../../db/dialect";
-import { defineFeature } from "../define-feature";
-import { createRegistry } from "../registry";
-import type { ProjectionDefinition } from "../types";
-
-const probeTable = table("rt_probe_table", {
-  id: text("id").primaryKey(),
-});
-const probeTableTwo = table("rt_probe_table_two", {
-  id: text("id").primaryKey(),
-});
-
-describe("r.rawTable — declaration", () => {
-  test("rejects non-kebab-case names", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.rawTable("BadName", probeTable, { reason: "test" });
-      }),
-    ).toThrow(/must be kebab-case/);
-  });
-
-  test("rejects duplicate names within one feature", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.rawTable("cache", probeTable, { reason: "test" });
-        r.rawTable("cache", probeTableTwo, { reason: "test" });
-      }),
-    ).toThrow(/already registered/);
-  });
-
-  test("rejects empty reason", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.rawTable("cache", probeTable, { reason: "" });
-      }),
-    ).toThrow(/options\.reason must be a non-empty string/);
-  });
-
-  test("rejects whitespace-only reason", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.rawTable("cache", probeTable, { reason: "   " });
-      }),
-    ).toThrow(/options\.reason must be a non-empty string/);
-  });
-
-  test("accepts valid registration and stores reason verbatim", () => {
-    const feature = defineFeature("probe", (r) => {
-      r.rawTable("cache", probeTable, {
-        reason: "external Stripe webhook cache, write-only by webhook handler",
-      });
-    });
-    expect(feature.rawTables).toHaveProperty("cache");
-    expect(feature.rawTables["cache"]?.reason).toBe(
-      "external Stripe webhook cache, write-only by webhook handler",
-    );
-    expect(feature.rawTables["cache"]?.table).toBe(probeTable);
-  });
-});
-
-describe("createRegistry — rawTable aggregation", () => {
-  test("aggregates raw tables across features and tags featureName", () => {
-    const featA = defineFeature("billing", (r) => {
-      r.rawTable("stripe-cache", probeTable, { reason: "external API cache" });
-    });
-    const featB = defineFeature("inventory", (r) => {
-      r.rawTable("legacy-import", probeTableTwo, { reason: "imported pre-ES" });
-    });
-
-    const registry = createRegistry([featA, featB]);
-    const all = registry.getAllRawTables();
-
-    expect(all.size).toBe(2);
-    expect(all.get("stripe-cache")?.featureName).toBe("billing");
-    expect(all.get("stripe-cache")?.reason).toBe("external API cache");
-    expect(all.get("legacy-import")?.featureName).toBe("inventory");
-  });
-
-  test("rejects cross-feature name collisions at boot", () => {
-    const featA = defineFeature("a", (r) => {
-      r.rawTable("shared", probeTable, { reason: "first" });
-    });
-    const featB = defineFeature("b", (r) => {
-      r.rawTable("shared", probeTableTwo, { reason: "second" });
-    });
-
-    expect(() => createRegistry([featA, featB])).toThrow(
-      /Raw-table "shared" registered by both feature "a" and "b"/,
-    );
-  });
-
-  test("absent rawTables block on a feature is ok (legacy / hand-built features)", () => {
-    const featNoRaw = defineFeature("no-raw", () => {
-      // no r.rawTable calls
-    });
-    const registry = createRegistry([featNoRaw]);
-    expect(registry.getAllRawTables().size).toBe(0);
-  });
-
-  test("two raw tables on the same PgTable register under both names", () => {
-    // Different logical names, identical physical target — legitimate
-    // when one role writes (primary cache) and a second role reads
-    // (alias view). Push-time dedupe keeps the boot to a single CREATE;
-    // the registry keeps both entries so callers can resolve either name.
-    const sharedT = table("rt_shared_dedupe", {
-      id: text("id").primaryKey(),
-    }) as unknown as SchemaTable;
-    const feat = defineFeature("dedupe", (r) => {
-      r.rawTable("primary", sharedT, { reason: "main writer" });
-      r.rawTable("alias", sharedT, { reason: "alias for read consumers" });
-    });
-    const registry = createRegistry([feat]);
-
-    expect(registry.getAllRawTables().size).toBe(2);
-    expect(registry.getAllRawTables().get("primary")?.table).toBe(sharedT);
-    expect(registry.getAllRawTables().get("alias")?.table).toBe(sharedT);
-  });
-
-  test("rejects rawTable that shares a PgTable with an explicit projection", () => {
-    // A r.rawTable() declaring the same physical table as a registered
-    // r.projection() is almost always an authoring bug — two owners on
-    // the same physical table, one event-sourced, one bypass. Boot
-    // throws so the failure points at the misconfiguration site.
-    const sharedT = table("rt_collision_phys", {
-      id: text("id").primaryKey(),
-    }) as unknown as SchemaTable;
-    const projection: ProjectionDefinition = {
-      name: "shared-summary",
-      source: "shared",
-      table: sharedT,
-      apply: {},
-    };
-    const featProj = defineFeature("proj-owner", (r) => {
-      r.projection(projection);
-    });
-    const featRaw = defineFeature("raw-owner", (r) => {
-      r.rawTable("collision", sharedT, { reason: "intentionally bad" });
-    });
-
-    expect(() => createRegistry([featProj, featRaw])).toThrow(
-      /shares a Drizzle PgTable with a registered projection/,
-    );
-  });
-});

package/src/engine/__tests__/unmanaged-table.test.ts

@@ -1,127 +0,0 @@
-// Unit tests for r.unmanagedTable() — the EntityTableMeta cousin of
-// r.rawTable. Same audit-trail contract, different storage shape (post-
-// drizzle migrate-runner). See define-feature.ts / DX-4.
-
-import { describe, expect, test } from "bun:test";
-import { defineUnmanagedTable, resolveTableName } from "../../db/entity-table-meta";
-import { defineFeature } from "../define-feature";
-import { createEntity, createTextField } from "../index";
-import { createRegistry } from "../registry";
-
-const probeMeta = defineUnmanagedTable({
-  tableName: "ut_probe",
-  columns: [{ name: "id", pgType: "text", notNull: true, primaryKey: true }],
-});
-const probeMetaTwo = defineUnmanagedTable({
-  tableName: "ut_probe_two",
-  columns: [{ name: "id", pgType: "text", notNull: true, primaryKey: true }],
-});
-
-describe("r.unmanagedTable — declaration", () => {
-  test("rejects duplicate registrations within one feature", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.unmanagedTable(probeMeta, { reason: "test" });
-        r.unmanagedTable(probeMeta, { reason: "test" });
-      }),
-    ).toThrow(/already registered/);
-  });
-
-  test("rejects empty reason", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.unmanagedTable(probeMeta, { reason: "" });
-      }),
-    ).toThrow(/options\.reason must be a non-empty string/);
-  });
-
-  test("rejects whitespace-only reason", () => {
-    expect(() =>
-      defineFeature("probe", (r) => {
-        r.unmanagedTable(probeMeta, { reason: "   " });
-      }),
-    ).toThrow(/options\.reason must be a non-empty string/);
-  });
-
-  test("accepts valid registration and stores meta + reason", () => {
-    const feature = defineFeature("probe", (r) => {
-      r.unmanagedTable(probeMeta, {
-        reason: "read-side projection of an event-stream",
-      });
-    });
-    expect(feature.unmanagedTables).toHaveProperty("ut_probe");
-    expect(feature.unmanagedTables["ut_probe"]?.reason).toBe(
-      "read-side projection of an event-stream",
-    );
-    expect(feature.unmanagedTables["ut_probe"]?.meta).toBe(probeMeta);
-  });
-
-  test("two unmanaged tables on one feature register under their tableName", () => {
-    const feature = defineFeature("dual", (r) => {
-      r.unmanagedTable(probeMeta, { reason: "one" });
-      r.unmanagedTable(probeMetaTwo, { reason: "two" });
-    });
-    expect(Object.keys(feature.unmanagedTables).sort()).toEqual(["ut_probe", "ut_probe_two"]);
-  });
-
-  test("absent unmanagedTables on a feature is ok", () => {
-    const feat = defineFeature("plain", () => {
-      // no r.unmanagedTable calls
-    });
-    expect(feat.unmanagedTables).toEqual({});
-  });
-});
-
-describe("createRegistry — unmanagedTable aggregation", () => {
-  test("rejects cross-feature tableName collisions at boot", () => {
-    // Two features can't share the same physical tableName — migrate-runner
-    // would race two CREATE TABLE statements. Boot-validator catches it.
-    const featA = defineFeature("a", (r) => {
-      r.unmanagedTable(probeMeta, { reason: "first" });
-    });
-    const featB = defineFeature("b", (r) => {
-      r.unmanagedTable(probeMeta, { reason: "second" });
-    });
-    expect(() => createRegistry([featA, featB])).toThrow(
-      /Unmanaged-table "ut_probe" registered by both feature "a" and "b"/,
-    );
-  });
-
-  test("two features with distinct tableNames register cleanly", () => {
-    const featA = defineFeature("a", (r) => {
-      r.unmanagedTable(probeMeta, { reason: "first" });
-    });
-    const featB = defineFeature("b", (r) => {
-      r.unmanagedTable(probeMetaTwo, { reason: "second" });
-    });
-    expect(() => createRegistry([featA, featB])).not.toThrow();
-  });
-
-  test("rejects an unmanaged-table that collides with an entity's physical name", () => {
-    const widget = createEntity({ fields: { name: createTextField() } });
-    // resolveTableName mirrors the migrate-runner — pin the exact physical name.
-    const physical = resolveTableName("widget", widget, "shop");
-    const clashing = defineUnmanagedTable({
-      tableName: physical,
-      columns: [{ name: "id", pgType: "text", notNull: true, primaryKey: true }],
-    });
-    const entityFeature = defineFeature("shop", (r) => {
-      r.entity("widget", widget);
-    });
-    const tableFeature = defineFeature("other", (r) => {
-      r.unmanagedTable(clashing, { reason: "clash" });
-    });
-
-    // Entity registered first, then the colliding unmanaged table.
-    expect(() => createRegistry([entityFeature, tableFeature])).toThrow(
-      new RegExp(
-        `Unmanaged-table "${physical}".*collides with the physical table of entity "widget"`,
-      ),
-    );
-
-    // Order-independent: unmanaged table registered first, then the entity.
-    expect(() => createRegistry([tableFeature, entityFeature])).toThrow(
-      new RegExp(`Entity "widget".*collides with r.unmanagedTable\\("${physical}"\\)`),
-    );
-  });
-});