@cosmicdrift/kumiko-framework 0.13.0 → 0.15.0

package/src/compliance/__tests__/duration-spec.test.ts

@@ -5,8 +5,8 @@
 // Singular/Plural). Der Bug aus dem U5a-Review (`{hours: 6}` fiel auf
 // 30d-Default) wird hier zentral verhindert.
 
+import { beforeAll, describe, expect, test } from "bun:test";
 import { ensureTemporalPolyfill, getTemporal } from "@cosmicdrift/kumiko-framework/time";
-import { beforeAll, describe, expect, test } from "vitest";
 import { addDurationSpec, describeDurationSpec, durationSpecToMs } from "../duration-spec";
 
 beforeAll(async () => {

package/src/compliance/__tests__/profiles.test.ts

@@ -6,7 +6,7 @@
 //   3. Deep-merge-Semantik beim Override (rekursiv, Top-Level-Replace nicht)
 //   4. Override darf einzelne Felder gezielt setzen ohne Required-Drops
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { complianceProfileOverrideSchema } from "../override-schema";
 import {
   COMPLIANCE_PROFILES,

package/src/compliance/__tests__/sub-processors.test.ts

@@ -4,7 +4,7 @@
 // oder hinzufuegt ohne dass die DPA/Tenant-Notification-Pipeline das
 // mitbekommt.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   getActiveSubProcessors,
   getPlannedSubProcessors,

package/src/db/__tests__/{apply-entity-event-tenant.integration.ts → apply-entity-event-tenant.integration.test.ts}

@@ -15,15 +15,16 @@
 // zerbrechen — der bestehende seed-Test wäre der einzige Catcher, und
 // der lief vor dem Refactor durch Zufall grün.
 
-import { eq, sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient, selectMany } from "../../db/query";
 import { createEntity, createTextField } from "../../engine/factories";
 import type { TenantId } from "../../engine/types";
 import type { StoredEvent } from "../../event-store";
 import { createEventsTable } from "../../event-store";
-import { createTestDb, type TestDb } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { applyEntityEvent } from "../apply-entity-event";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 
 const entity = createEntity({
   table: "read_apply_tenant_check",
@@ -31,14 +32,15 @@ const entity = createEntity({
     name: createTextField({ required: true }),
   },
 });
-const table = buildDrizzleTable("apply-tenant-check", entity);
+const table = buildEntityTable("apply-tenant-check", entity);
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await createEventsTable(testDb.db);
-  await testDb.db.execute(sql`
+  await asRawClient(testDb.db).unsafe(`
     CREATE TABLE read_apply_tenant_check (
       id uuid PRIMARY KEY,
       tenant_id uuid NOT NULL,
@@ -57,7 +59,7 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE read_apply_tenant_check`);
+  await asRawClient(testDb.db).unsafe(`TRUNCATE read_apply_tenant_check`);
 });
 
 const TENANT_OPERATOR = "11111111-1111-1111-1111-111111111111" as TenantId;
@@ -85,7 +87,7 @@ describe("applyEntityEvent — tenantId-Defaulting", () => {
     const result = await applyEntityEvent(event, table, entity, testDb.db);
     expect(result.kind).toBe("applied");
 
-    const [row] = await testDb.db.select().from(table).where(eq(table["id"], event.aggregateId));
+    const [row] = await selectMany(testDb.db, table, { id: event.aggregateId });
     expect(row?.["tenantId"]).toBe(TENANT_OPERATOR);
     expect(row?.["name"]).toBe("without-tenantId-in-payload");
   });
@@ -101,7 +103,7 @@ describe("applyEntityEvent — tenantId-Defaulting", () => {
     const result = await applyEntityEvent(event, table, entity, testDb.db);
     expect(result.kind).toBe("applied");
 
-    const [row] = await testDb.db.select().from(table).where(eq(table["id"], event.aggregateId));
+    const [row] = await selectMany(testDb.db, table, { id: event.aggregateId });
     expect(row?.["tenantId"]).toBe(TENANT_TARGET);
     expect(row?.["tenantId"]).not.toBe(TENANT_OPERATOR);
   });
@@ -148,7 +150,7 @@ describe("applyEntityEvent — tenantId-Defaulting", () => {
     const result = await applyEntityEvent(event, table, entity, testDb.db);
     expect(result.kind).toBe("applied");
 
-    const [row] = await testDb.db.select().from(table).where(eq(table["id"], event.aggregateId));
+    const [row] = await selectMany(testDb.db, table, { id: event.aggregateId });
     // event.aggregateId wins, nicht payload.id
     expect(row?.["id"]).toBe(event.aggregateId);
     // event.version wins, nicht payload.version

package/src/db/__tests__/big-int-field.test.ts

@@ -3,7 +3,7 @@
 //
 // Pinst:
 //   - createBigIntField liefert FieldDefinition.type === "bigInt"
-//   - buildDrizzleTable mappt auf bigint(name, mode:"number"), nicht
+//   - buildEntityTable mappt auf bigint(name, mode:"number"), nicht
 //     integer (32-bit) → kein silent 2 GB-Cap
 //   - Zod-Schema akzeptiert int + safe-integer + lehnt non-int + Float
 //     + non-safe-integer ab
@@ -15,19 +15,20 @@
 // einrichten — pinst dort auf realer Postgres + Drizzle-customType-
 // Path statt parallel-mock hier.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createBigIntField, createEntity, createNumberField } from "../../engine";
 import { buildInsertSchema } from "../../engine/schema-builder";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 
-function colByName(table: ReturnType<typeof buildDrizzleTable>, dbName: string) {
-  for (const col of Object.values(table) as Array<{
-    name?: string;
-    notNull?: boolean;
-    columnType?: string;
-    dataType?: string;
-  }>) {
-    if (col && typeof col === "object" && col.name === dbName) return col;
+function colByName(table: unknown, dbName: string) {
+  const cols = (
+    table as { columns?: ReadonlyArray<{ name: string; notNull?: boolean; pgType?: string }> }
+  ).columns;
+  if (!cols) throw new Error("Table has no columns metadata");
+  for (const c of cols) {
+    if (c.name === dbName) {
+      return { name: c.name, notNull: c.notNull, columnType: c.pgType, dataType: c.pgType };
+    }
   }
   throw new Error(`Column ${dbName} not found in table`);
 }
@@ -53,7 +54,7 @@ describe("createBigIntField factory", () => {
   });
 });
 
-describe("buildDrizzleTable — bigInt-Mapping", () => {
+describe("buildEntityTable — bigInt-Mapping", () => {
   test("bigInt-Spalte ist DISTINCT von number-Spalte (number=integer/32-bit, bigInt=bigint/64-bit)", () => {
     const entity = createEntity({
       fields: {
@@ -61,7 +62,7 @@ describe("buildDrizzleTable — bigInt-Mapping", () => {
         bigCount: createBigIntField({}),
       },
     });
-    const table = buildDrizzleTable("counters", entity);
+    const table = buildEntityTable("counters", entity);
 
     const small = colByName(table, "small_count");
     const big = colByName(table, "big_count");
@@ -79,7 +80,7 @@ describe("buildDrizzleTable — bigInt-Mapping", () => {
         optionalBig: createBigIntField({}),
       },
     });
-    const table = buildDrizzleTable("t", entity);
+    const table = buildEntityTable("t", entity);
     expect(colByName(table, "required_big").notNull).toBe(true);
     expect(colByName(table, "optional_big").notNull).toBe(false);
   });

package/src/db/__tests__/column-ddl.integration.test.ts

@@ -0,0 +1,113 @@
+// DDL-Render-Test: alle pgTable Column-Types + Builder-Optionen.
+import { describe, expect, test } from "bun:test";
+import {
+  bigint,
+  bigserial,
+  integer,
+  jsonb,
+  boolean as pgBoolean,
+  table as pgTable,
+  serial,
+  text,
+  timestamp,
+  uuid,
+} from "../dialect";
+import { renderTableDdl } from "../render-ddl";
+
+function findIndex(ddl: readonly string[], pattern: RegExp): boolean {
+  return ddl.some((s) => pattern.test(s));
+}
+
+describe("renderTableDdl — column types", () => {
+  test("uuid notNull primaryKey defaultRandom", () => {
+    const t = pgTable("t_uuid", { id: uuid("id").primaryKey().defaultRandom() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"id" uuid PRIMARY KEY DEFAULT gen_random_uuid()');
+  });
+
+  test("text notNull unique", () => {
+    const t = pgTable("t_text", { slug: text("slug").notNull().unique() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"slug" text NOT NULL');
+    expect(findIndex(ddl, /UNIQUE INDEX/)).toBe(true);
+  });
+
+  test("integer default", () => {
+    const t = pgTable("t_int", { count: integer("count").default(0) });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"count" integer DEFAULT 0');
+  });
+
+  test("serial primaryKey", () => {
+    const t = pgTable("t_serial", { id: serial("id").primaryKey() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"id" serial PRIMARY KEY');
+  });
+
+  test("bigserial primaryKey", () => {
+    const t = pgTable("t_bigserial", { id: bigserial("id").primaryKey() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"id" bigserial PRIMARY KEY');
+  });
+
+  test("bigint notNull", () => {
+    const t = pgTable("t_bigint", { amount: bigint("amount").notNull() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"amount" bigint NOT NULL');
+  });
+
+  test("boolean default", () => {
+    const t = pgTable("t_bool", { active: pgBoolean("active").default(true) });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"active" boolean DEFAULT true');
+  });
+
+  test("jsonb notNull", () => {
+    const t = pgTable("t_jsonb", { data: jsonb("data").notNull() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"data" jsonb NOT NULL');
+  });
+
+  test("timestamptz defaultNow", () => {
+    const t = pgTable("t_ts", {
+      created: timestamp("created", { withTimezone: true }).notNull().defaultNow(),
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain('"created" timestamp with time zone DEFAULT now() NOT NULL');
+  });
+
+  test("bigint generatedAlwaysAsIdentity primaryKey", () => {
+    const t = pgTable("t_ident", { id: bigint("id").primaryKey().generatedAlwaysAsIdentity() });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain("GENERATED ALWAYS AS IDENTITY");
+    expect(ddl[0]).not.toContain("DEFAULT"); // identity replaces default
+  });
+
+  test("composite: multiple columns with various options", () => {
+    const t = pgTable("t_composite", {
+      pk: bigint("pk").primaryKey().generatedAlwaysAsIdentity(),
+      name: text("name").notNull(),
+      slug: text("slug").notNull().unique(),
+      active: pgBoolean("active").default(true),
+      data: jsonb("data"),
+      created: timestamp("created", { withTimezone: true }).notNull().defaultNow(),
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: DDL test uses cast for mock tables
+    const ddl = renderTableDdl(t as any);
+    expect(ddl[0]).toContain("GENERATED ALWAYS AS IDENTITY");
+    expect(ddl[0]).toContain('"name" text NOT NULL');
+    expect(ddl[0]).toContain('"active" boolean DEFAULT true');
+    expect(ddl[0]).toContain('"data" jsonb');
+    expect(findIndex(ddl, /UNIQUE INDEX.*slug/)).toBe(true);
+  });
+});

package/src/db/__tests__/compound-types.test.ts

@@ -5,7 +5,7 @@
 //   - Reihenfolge ist deterministisch + Konverter überlappen nicht
 //   - Pure (kein input-mutate)
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   createEntity,
   createLocatedTimestampField,

package/src/db/__tests__/{config-seed.integration.ts → config-seed.integration.test.ts}

@@ -1,5 +1,6 @@
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
 import {
   createEntity,
   createSystemConfig,
@@ -9,10 +10,11 @@ import {
   SYSTEM_TENANT_ID,
 } from "../../engine";
 import type { ConfigSeedDef, Registry } from "../../engine/types";
-import { createTestDb, type TestDb, unsafeCreateEntityTable } from "../../stack";
+import { unsafeCreateEntityTable } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { seedConfigValues } from "../config-seed";
 import { createEncryptionProvider } from "../encryption";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 
 // --- Test Entity ---
 // Mirrors the config-value entity from bundled-features with a unique
@@ -32,7 +34,7 @@ const configEntity = createEntity({
     },
   ],
 });
-const configTable = buildDrizzleTable("cfgSeedTest", configEntity);
+const configTable = buildEntityTable("cfgSeedTest", configEntity);
 
 // --- Registry Stub ---
 const KEY_DEFS = {
@@ -53,24 +55,25 @@ const encryption = createEncryptionProvider(
   Buffer.from("0123456789abcdef0123456789abcdef").toString("base64"),
 );
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 
 async function countRows(): Promise<number> {
-  const [r] = await testDb.db.execute<{ count: number }>(
-    sql`SELECT COUNT(*)::int AS count FROM read_cfg_seed_test`,
+  const [r] = await asRawClient(testDb.db).unsafe<{ count: number }>(
+    `SELECT COUNT(*)::int AS count FROM read_cfg_seed_test`,
   );
   return r?.count ?? 0;
 }
 
 async function countEvents(): Promise<number> {
-  const [r] = await testDb.db.execute<{ count: number }>(
-    sql`SELECT COUNT(*)::int AS count FROM kumiko_events`,
+  const [r] = await asRawClient(testDb.db).unsafe<{ count: number }>(
+    `SELECT COUNT(*)::int AS count FROM kumiko_events`,
   );
   return r?.count ?? 0;
 }
 
 // --- Setup ---
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await unsafeCreateEntityTable(testDb.db, configEntity, "cfgSeedTest");
 });
@@ -80,7 +83,9 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events, read_cfg_seed_test RESTART IDENTITY CASCADE`);
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_cfg_seed_test RESTART IDENTITY CASCADE`,
+  );
 });
 
 // --- Tests ---
@@ -150,8 +155,8 @@ describe("seedConfigValues", () => {
     expect(result).toEqual({ created: 0, skipped: 1 });
 
     // Old value persists
-    const [row] = await testDb.db.execute<{ value: string }>(
-      sql`SELECT value FROM read_cfg_seed_test WHERE key = 'test:config:max-upload' LIMIT 1`,
+    const [row] = await asRawClient(testDb.db).unsafe<{ value: string }>(
+      `SELECT value FROM read_cfg_seed_test WHERE key = 'test:config:max-upload' LIMIT 1`,
     );
     expect(row).toBeDefined();
     expect(JSON.parse(row!.value)).toBe(10);
@@ -168,28 +173,28 @@ describe("seedConfigValues", () => {
 
     await seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db);
 
-    const rows = await testDb.db.execute<{
+    const rows = await asRawClient(testDb.db).unsafe<{
       key: string;
-      tenantId: string;
+      tenantId: string | null;
       userId: string | null;
     }>(
-      sql`SELECT key, tenant_id AS "tenantId", user_id AS "userId" FROM read_cfg_seed_test ORDER BY key`,
+      `SELECT key, tenant_id AS "tenantId", user_id AS "userId" FROM read_cfg_seed_test ORDER BY key`,
     );
 
-    const sys = rows.find((r) => r.key === "test:config:service-url");
-    const tnt = rows.find((r) => r.key === "test:config:max-upload");
-    const usr = rows.find((r) => r.key === "test:config:theme");
+    const sys = rows.find((r: Record<string, unknown>) => r["key"] === "test:config:service-url");
+    const tnt = rows.find((r: Record<string, unknown>) => r["key"] === "test:config:max-upload");
+    const usr = rows.find((r: Record<string, unknown>) => r["key"] === "test:config:theme");
 
-    expect(sys!.tenantId).toBe(SYSTEM_TENANT_ID);
-    expect(sys!.userId).toBeNull();
+    expect(sys!["tenantId"]).toBe(SYSTEM_TENANT_ID);
+    expect(sys!["userId"]).toBeNull();
 
-    expect(tnt!.tenantId).toBe(SYSTEM_TENANT_ID);
-    expect(tnt!.userId).toBeNull();
+    expect(tnt!["tenantId"]).toBe(SYSTEM_TENANT_ID);
+    expect(tnt!["userId"]).toBeNull();
 
     // user-scope seed must live under the user's actual tenantId so the
     // resolver cascade can match it — never under SYSTEM_TENANT_ID.
-    expect(usr!.tenantId).toBe(TENANT_A);
-    expect(usr!.userId).toBe("u-1");
+    expect(usr!["tenantId"]).toBe(TENANT_A);
+    expect(usr!["userId"]).toBe("u-1");
   });
 
   test("user-scope seed without tenantId throws (would be unreachable)", async () => {
@@ -227,8 +232,8 @@ describe("seedConfigValues", () => {
     );
     expect(result).toEqual({ created: 1, skipped: 0 });
 
-    const [row] = await testDb.db.execute<{ value: string }>(
-      sql`SELECT value FROM read_cfg_seed_test WHERE key = 'test:config:stripe-key' LIMIT 1`,
+    const [row] = await asRawClient(testDb.db).unsafe<{ value: string }>(
+      `SELECT value FROM read_cfg_seed_test WHERE key = 'test:config:stripe-key' LIMIT 1`,
     );
     expect(row).toBeDefined();
     // value column holds ciphertext, never the plain token. The

package/src/db/__tests__/connection-options.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { dbConnectionOptionsFromEnv } from "../connection";
 
 // createDbConnection itself opens a real postgres.js socket, so it's

package/src/db/__tests__/dialect-instant.test.ts

@@ -15,7 +15,7 @@ import { ensureTemporalPolyfill } from "../../time/polyfill";
 
 await ensureTemporalPolyfill();
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { instantToDriver as toDriver } from "../dialect";
 
 describe("instant() customType — toDriver", () => {

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { createEncryptionProvider } from "../encryption";
 
 // 32 bytes base64-encoded for AES-256

package/src/db/__tests__/{drizzle-table-types.test.ts → entity-table-types.test.ts}

@@ -1,5 +1,5 @@
-// Type-Tests für DrizzleTable<E>: pinned das vertragliche Verhalten der
-// Generic-Inferenz-Pipeline createEntity → buildDrizzleTable. Wenn ein
+// Type-Tests für EntityTable<E>: pinned das vertragliche Verhalten der
+// Generic-Inferenz-Pipeline createEntity → buildEntityTable. Wenn ein
 // Branch in `fieldToColumns` driftet aber `ColumnsForField` im Type-
 // System nicht mitkommt (oder umgekehrt), schlagen diese Tests fehl
 // BEVOR ein Consumer in den Wald läuft.
@@ -8,7 +8,7 @@
 // repräsentative Fälle: required-Literal, required-Default, money-Pair,
 // locatedTimestamp-Pair, multiSelect-jsonb-default, idType-Variation.
 
-import { describe, expect, expectTypeOf, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "bun:test";
 import {
   createBooleanField,
   createDateField,
@@ -22,9 +22,9 @@ import {
   createTimestampField,
   createTzField,
 } from "../../engine";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 
-describe("DrizzleTable<E> — Property-Names existieren", () => {
+describe("EntityTable<E> — Property-Names existieren", () => {
   const sampleEntity = createEntity({
     table: "x",
     fields: {
@@ -33,7 +33,7 @@ describe("DrizzleTable<E> — Property-Names existieren", () => {
       priority: createSelectField({ options: ["low", "high"] as const }),
     },
   });
-  const t = buildDrizzleTable("sample", sampleEntity);
+  const t = buildEntityTable("sample", sampleEntity);
 
   test("base-columns sind getypt", () => {
     expectTypeOf(t.id).not.toBeNever();
@@ -61,7 +61,7 @@ describe("DrizzleTable<E> — Property-Names existieren", () => {
   });
 });
 
-describe("DrizzleTable<E> — Money produces two columns", () => {
+describe("EntityTable<E> — Money produces two columns", () => {
   const ent = createEntity({
     table: "invoice",
     fields: {
@@ -69,7 +69,7 @@ describe("DrizzleTable<E> — Money produces two columns", () => {
       shipping: createMoneyField(),
     },
   });
-  const t = buildDrizzleTable("invoice", ent);
+  const t = buildEntityTable("invoice", ent);
 
   test("money-amount column existiert", () => {
     expectTypeOf(t.amount).not.toBeNever();
@@ -82,14 +82,14 @@ describe("DrizzleTable<E> — Money produces two columns", () => {
   });
 });
 
-describe("DrizzleTable<E> — locatedTimestamp produces Utc + Tz", () => {
+describe("EntityTable<E> — locatedTimestamp produces Utc + Tz", () => {
   const ent = createEntity({
     table: "delivery",
     fields: {
       pickup: createLocatedTimestampField({ required: true }),
     },
   });
-  const t = buildDrizzleTable("delivery", ent);
+  const t = buildEntityTable("delivery", ent);
 
   test("Utc und Tz Spalten existieren", () => {
     expectTypeOf(t.pickupUtc).not.toBeNever();
@@ -104,7 +104,7 @@ describe("DrizzleTable<E> — locatedTimestamp produces Utc + Tz", () => {
   });
 });
 
-describe("DrizzleTable<E> — files/images produzieren keine columns", () => {
+describe("EntityTable<E> — files/images produzieren keine columns", () => {
   // files/images werden über fileRefsTable resolved, nicht in der entity-table.
   // Ein Type-Test der das pinnt würde createFilesField verlangen — wir lassen
   // das hier weg, weil das Authoring-Pattern "createXField" ohne file-helper
@@ -115,7 +115,7 @@ describe("DrizzleTable<E> — files/images produzieren keine columns", () => {
   });
 });
 
-describe("DrizzleTable<E> — verschiedene Feld-Typen existieren", () => {
+describe("EntityTable<E> — verschiedene Feld-Typen existieren", () => {
   const ent = createEntity({
     table: "many",
     fields: {
@@ -127,7 +127,7 @@ describe("DrizzleTable<E> — verschiedene Feld-Typen existieren", () => {
       tags: createMultiSelectField({ options: ["a", "b"] as const }),
     },
   });
-  const t = buildDrizzleTable("many", ent);
+  const t = buildEntityTable("many", ent);
 
   test("alle Felder als columns sichtbar", () => {
     expectTypeOf(t.txt).not.toBeNever();
@@ -139,7 +139,7 @@ describe("DrizzleTable<E> — verschiedene Feld-Typen existieren", () => {
   });
 });
 
-describe("DrizzleTable<E> — idType wirkt", () => {
+describe("EntityTable<E> — idType wirkt", () => {
   const uuidEnt = createEntity({
     table: "uuid_ent",
     fields: { name: createTextField() },
@@ -150,8 +150,8 @@ describe("DrizzleTable<E> — idType wirkt", () => {
     fields: { name: createTextField() },
     idType: "serial",
   });
-  const tu = buildDrizzleTable("uuid_ent", uuidEnt);
-  const ts = buildDrizzleTable("serial_ent", serialEnt);
+  const tu = buildEntityTable("uuid_ent", uuidEnt);
+  const ts = buildEntityTable("serial_ent", serialEnt);
 
   test("uuid-Entity exposed id existiert", () => {
     expectTypeOf(tu.id).not.toBeNever();

package/src/db/__tests__/{event-store-executor-list.integration.ts → event-store-executor-list.integration.test.ts}

@@ -4,13 +4,15 @@
 // items-create.integration im Showcase abgedeckt — nicht ausreichend
 // für Framework-Code der von jeder App genutzt wird.
 
-import { sql } from "drizzle-orm";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { type BunTestDb, createTestDb } from "../../bun-db/__tests__/bun-test-db";
+import { asRawClient } from "../../db/query";
 import { createEntity, createNumberField, createTextField } from "../../engine";
 import { createEventsTable } from "../../event-store";
-import { createTestDb, type TestDb, TestUsers, unsafeCreateEntityTable } from "../../stack";
+import { TestUsers, unsafeCreateEntityTable } from "../../stack";
+import { ensureTemporalPolyfill } from "../../time/polyfill";
 import { createEventStoreExecutor } from "../event-store-executor";
-import { buildDrizzleTable } from "../table-builder";
+import { buildEntityTable } from "../table-builder";
 import { createTenantDb, type TenantDb } from "../tenant-db";
 
 const entity = createEntity({
@@ -20,13 +22,14 @@ const entity = createEntity({
     rank: createNumberField({ sortable: true }),
   },
 });
-const table = buildDrizzleTable("pagerItem", entity);
+const table = buildEntityTable("pagerItem", entity);
 
-let testDb: TestDb;
+let testDb: BunTestDb;
 let tdb: TenantDb;
 const admin = TestUsers.admin;
 
 beforeAll(async () => {
+  await ensureTemporalPolyfill();
   testDb = await createTestDb();
   await unsafeCreateEntityTable(testDb.db, entity, "pagerItem");
   await createEventsTable(testDb.db);
@@ -38,7 +41,9 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await testDb.db.execute(sql`TRUNCATE kumiko_events, read_pager_items RESTART IDENTITY CASCADE`);
+  await asRawClient(testDb.db).unsafe(
+    `TRUNCATE kumiko_events, read_pager_items RESTART IDENTITY CASCADE`,
+  );
 });
 
 describe("event-store-executor.list — offset + totalCount (Tier 2.6d)", () => {