@cosmicdrift/kumiko-bundled-features 0.14.0 → 0.15.0

package/src/delivery/tables.ts

@@ -1,8 +1,11 @@
 import {
   boolean,
   buildBaseColumns,
+  defineUnmanagedTable,
+  type EntityTableMeta,
   instant,
   table as pgTable,
+  sql,
   text,
   uniqueIndex,
   uuid,
@@ -12,7 +15,6 @@ import {
   createEntity,
   createTextField,
 } from "@cosmicdrift/kumiko-framework/engine";
-import { sql } from "drizzle-orm";
 
 // Delivery-log is an append-only stream of per-attempt records. The stream
 // of truth lives in the events-Tabelle (one aggregate per attempt, event
@@ -39,6 +41,29 @@ export const deliveryAttemptsTable = pgTable("read_delivery_attempts", {
   createdAt: instant("created_at").default(sql`now()`).notNull(),
 });
 
+// **Unmanaged table** — bewusst KEIN createEntity. Begründung:
+//   - id kommt aus dem Aggregate-Stream (kein gen_random_uuid()-DEFAULT)
+//   - kein version/inserted_by/modified_by/modified_at — keine in-place-
+//     Edits, keine Audit-Spalten nötig (idempotent-on-replay via PK-Konflikt)
+//   - created_at statt inserted_at — historischer Naming-Drift, kein Bug
+// App trägt Verantwortung für tenant-scoping in Queries + replay-idempotency.
+// pgTable bleibt source-of-truth für Query-API; Phase 4 leitet das pgTable
+// aus dieser Meta ab.
+export const deliveryAttemptsTableMeta: EntityTableMeta = defineUnmanagedTable({
+  tableName: "read_delivery_attempts",
+  columns: [
+    { name: "id", pgType: "uuid", notNull: true, primaryKey: true },
+    { name: "tenant_id", pgType: "uuid", notNull: true },
+    { name: "notification_type", pgType: "text", notNull: true },
+    { name: "channel", pgType: "text", notNull: true },
+    { name: "recipient_id", pgType: "text", notNull: false },
+    { name: "recipient_address", pgType: "text", notNull: false },
+    { name: "status", pgType: "text", notNull: true },
+    { name: "error", pgType: "text", notNull: false },
+    { name: "created_at", pgType: "timestamptz", notNull: true, defaultSql: "now()" },
+  ],
+});
+
 // User-scoped opt-in/opt-out for (notificationType, channel) pairs. Post-ES
 // refactor: each row is a notificationPreference aggregate with
 // `.created / .updated / .deleted` lifecycle events written via the

package/src/delivery/upsert-preference.ts

@@ -10,13 +10,9 @@
 // through to update. Worst case: one extra roundtrip for the loser of
 // the race. Happy path: same number of queries as the pre-ES upsert.
 
-import {
-  createEventStoreExecutor,
-  fetchOne,
-  type TenantDb,
-} from "@cosmicdrift/kumiko-framework/db";
+import { fetchOne } from "@cosmicdrift/kumiko-framework/bun-db";
+import { createEventStoreExecutor, type TenantDb } from "@cosmicdrift/kumiko-framework/db";
 import type { SessionUser, TenantId, WriteResult } from "@cosmicdrift/kumiko-framework/engine";
-import { eq } from "drizzle-orm";
 import { notificationPreferenceEntity, notificationPreferencesTable } from "./tables";
 
 const executor = createEventStoreExecutor(
@@ -38,14 +34,12 @@ async function lookup(
   notificationType: string,
   channel: string,
 ): Promise<PreferenceLookupRow | undefined> {
-  return fetchOne<PreferenceLookupRow>(
-    db,
-    notificationPreferencesTable,
-    eq(notificationPreferencesTable.tenantId, tenantId),
-    eq(notificationPreferencesTable.userId, userId),
-    eq(notificationPreferencesTable.notificationType, notificationType),
-    eq(notificationPreferencesTable.channel, channel),
-  );
+  return fetchOne<PreferenceLookupRow>(db, notificationPreferencesTable, {
+    tenantId,
+    userId,
+    notificationType,
+    channel,
+  });
 }
 
 export type UpsertPreferenceInput = {

package/src/feature-toggles/__tests__/feature-toggles.integration.ts

@@ -1,5 +1,7 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { asRawClient, insertOne, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import {
-  buildDrizzleTable,
+  buildEntityTable,
   createEventStoreExecutor,
   entityEventName,
   integer,
@@ -24,9 +26,7 @@ import {
 } from "@cosmicdrift/kumiko-framework/stack";
 import { createLateBoundHolder } from "@cosmicdrift/kumiko-framework/testing";
 import { generateId } from "@cosmicdrift/kumiko-framework/utils";
-import { sql } from "drizzle-orm";
 import { Temporal } from "temporal-polyfill";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { FEATURE_TOGGLE_SET_EVENT_NAME } from "../constants";
 import { createFeatureTogglesFeature } from "../feature";
@@ -44,7 +44,7 @@ const widgetEntity = createEntity({
     active: createBooleanField({ default: true }),
   },
 });
-const widgetTable = buildDrizzleTable("widget", widgetEntity);
+const widgetTable = buildEntityTable("widget", widgetEntity);
 
 const widgetCrud = createEventStoreExecutor(widgetTable, widgetEntity, {
   entityName: "widget",
@@ -79,7 +79,7 @@ const widgetAuditEntity = createEntity({
     widgetName: createTextField({ required: true, maxLength: 100 }),
   },
 });
-const widgetAuditTable = buildDrizzleTable("widget-audit", widgetAuditEntity);
+const widgetAuditTable = buildEntityTable("widget-audit", widgetAuditEntity);
 
 function widgetAuditFeature(): FeatureDefinition {
   return defineFeature("widget-audit", (r) => {
@@ -92,7 +92,7 @@ function widgetAuditFeature(): FeatureDefinition {
       if (!ctx.db) return;
       const name = result.changes!["name"] as string | undefined;
       if (!name) return;
-      await ctx.db.insert(widgetAuditTable).values({
+      await insertOne(ctx.db, widgetAuditTable, {
         id: generateId(),
         widgetName: name,
         version: 1,
@@ -128,13 +128,10 @@ function widgetTrackerFeature(): FeatureDefinition {
       table: widgetTrackerTable,
       apply: {
         [entityEventName("widget", "created")]: async (event, tx) => {
-          await tx
-            .insert(widgetTrackerTable)
-            .values({ tenantId: event.tenantId, count: 1 })
-            .onConflictDoUpdate({
-              target: widgetTrackerTable.tenantId,
-              set: { count: sql`${widgetTrackerTable.count} + 1` },
-            });
+          await asRawClient(tx).unsafe(
+            `INSERT INTO "widget_tracker" (tenant_id, count) VALUES ($1::uuid, 1) ON CONFLICT (tenant_id) DO UPDATE SET count = widget_tracker.count + 1`,
+            [event.tenantId],
+          );
         },
       },
     });
@@ -183,15 +180,17 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await stack.db.delete(widgetAuditTable);
-  await stack.db.delete(widgetTable);
-  await stack.db.delete(widgetTrackerTable);
-  await stack.db.delete(globalFeatureStateTable);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${widgetAuditTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${widgetTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${widgetTrackerTable.tableName}"`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM "${globalFeatureStateTable.tableName}"`);
   // Wipe the event log + reset every consumer cursor so each test starts
   // from event-id 0. Tests that drain via eventDispatcher.runOnce() need
   // this or they drain a shared backlog and see false-positive counters.
-  await stack.db.execute(sql`DELETE FROM kumiko_events`);
-  await stack.db.execute(sql`UPDATE kumiko_event_consumers SET last_processed_event_id = 0`);
+  await asRawClient(stack.db).unsafe(`DELETE FROM kumiko_events`);
+  await asRawClient(stack.db).unsafe(
+    `UPDATE kumiko_event_consumers SET last_processed_event_id = 0`,
+  );
   await runtime.refresh();
 });
 
@@ -212,17 +211,17 @@ async function createWidget(name: string) {
 }
 
 async function countWidgets(): Promise<number> {
-  const rows = await stack.db.select().from(widgetTable);
+  const rows = await selectMany(stack.db, widgetTable);
   return rows.length;
 }
 
 async function countAuditRows(): Promise<number> {
-  const rows = await stack.db.select().from(widgetAuditTable);
+  const rows = await selectMany(stack.db, widgetAuditTable);
   return rows.length;
 }
 
 async function trackerCount(): Promise<number> {
-  const rows = await stack.db.select().from(widgetTrackerTable);
+  const rows = await selectMany(stack.db, widgetTrackerTable);
   return rows[0]?.count ?? 0;
 }
 
@@ -231,15 +230,16 @@ async function trackerCount(): Promise<number> {
 // explicit shape — typed access everywhere else.
 type ConsumerCursorRow = { last_processed_event_id: number | string };
 async function trackerCursor(): Promise<number> {
-  const rows = (await stack.db.execute(
-    sql`SELECT last_processed_event_id FROM kumiko_event_consumers WHERE name LIKE '%tracker%' LIMIT 1`,
+  const rows = (await asRawClient(stack.db).unsafe(
+    `SELECT last_processed_event_id FROM kumiko_event_consumers WHERE name LIKE '%tracker%' LIMIT 1`,
   )) as unknown as readonly ConsumerCursorRow[];
   return Number(rows[0]?.last_processed_event_id ?? 0);
 }
 
 async function setTrackerCursor(value: number): Promise<void> {
-  await stack.db.execute(
-    sql`UPDATE kumiko_event_consumers SET last_processed_event_id = ${value} WHERE name LIKE '%tracker%'`,
+  await asRawClient(stack.db).unsafe(
+    `UPDATE kumiko_event_consumers SET last_processed_event_id = $1 WHERE name LIKE '%tracker%'`,
+    [value],
   );
 }
 
@@ -252,7 +252,7 @@ describe("feature-toggles runtime cache", () => {
   });
 
   test("refresh() re-reads the DB snapshot", async () => {
-    await stack.db.insert(globalFeatureStateTable).values({
+    await insertOne(stack.db, globalFeatureStateTable, {
       featureName: "widget",
       enabled: false,
       version: 1,
@@ -330,7 +330,7 @@ describe("runtime on/off/on — the user's scenario", () => {
     expect(body.data?.previousEnabled).toBeNull();
 
     // Row persisted.
-    const rows = await stack.db.select().from(globalFeatureStateTable);
+    const rows = await selectMany(stack.db, globalFeatureStateTable);
     expect(rows).toHaveLength(1);
 
     // Snapshot updated — widget:create now 403s.
@@ -517,8 +517,8 @@ describe("feature-toggles queries + audit automation", () => {
       admin,
     );
 
-    const events = (await stack.db.execute(
-      sql`SELECT type, payload FROM kumiko_events WHERE type = 'feature-toggles:event:toggle-set'`,
+    const events = (await asRawClient(stack.db).unsafe(
+      `SELECT type, payload FROM kumiko_events WHERE type = 'feature-toggles:event:toggle-set'`,
     )) as unknown as readonly {
       type: string;
       payload: Record<string, unknown>;

package/src/feature-toggles/__tests__/registered-system-tenant.test.ts

@@ -11,6 +11,7 @@
 // durchläuft. Die Convention-Pin ist die einzige Aussage des tests —
 // echtes integration-Verhalten deckt feature-toggles.integration.ts ab.
 
+import { describe, expect, test } from "bun:test";
 import {
   createEntity,
   createRegistry,
@@ -21,7 +22,6 @@ import {
 } from "@cosmicdrift/kumiko-framework/engine";
 import { createDispatcher } from "@cosmicdrift/kumiko-framework/pipeline";
 import { createTestUser } from "@cosmicdrift/kumiko-framework/stack";
-import { describe, expect, test } from "vitest";
 import { createFeatureTogglesFeature } from "../feature";
 import type { GlobalFeatureToggleRuntime } from "../toggle-runtime";
 
@@ -43,12 +43,13 @@ describe("Sprint 8a: registered.query SYSTEM_TENANT_ID convention", () => {
 
     const registry = createRegistry([dummy, featureToggles]);
 
-    // Mock ctx.db.select-chain damit der handler durch den DB-Pfad
-    // kommt. Wir liefern leere overrides (.from() returnt []), das
-    // genügt — registered.query iteriert dann über registry.features
-    // und ruft ctx.effectiveFeatures, was unser observable ist.
+    // Mock ctx.db via bun-db's asRawClient surface: handler ruft
+    // selectMany(ctx.db.raw, ...) → asRawClient(raw).unsafe(...). Wir
+    // liefern leere overrides damit der handler durch den DB-Pfad kommt
+    // und dann ctx.effectiveFeatures aufruft (das observable hier).
     const mockDb = {
-      select: () => ({ from: async () => [] as unknown[] }),
+      unsafe: async () => [] as unknown[],
+      begin: async () => undefined,
     } as unknown as Parameters<typeof createDispatcher>[1]["db"];
 
     const callerTenant = "00000000-0000-4000-8000-0000000000c1" as TenantId;

package/src/feature-toggles/db/queries/toggle-state.ts

@@ -0,0 +1,25 @@
+import { asRawClient } from "@cosmicdrift/kumiko-framework/bun-db";
+import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
+import type { Temporal } from "temporal-polyfill";
+
+export async function updateFeatureToggleOptimistic(
+  db: DbRunner,
+  params: {
+    readonly enabled: boolean;
+    readonly updatedBy: string;
+    readonly updatedAt: Temporal.Instant;
+    readonly featureName: string;
+    readonly expectedVersion: number;
+  },
+): Promise<readonly unknown[]> {
+  return asRawClient(db).unsafe(
+    'UPDATE "read_global_feature_state" SET enabled = $1, version = version + 1, updated_by = $2, updated_at = $3 WHERE feature_name = $4 AND version = $5 RETURNING *',
+    [
+      params.enabled,
+      params.updatedBy,
+      params.updatedAt,
+      params.featureName,
+      params.expectedVersion,
+    ],
+  );
+}

package/src/feature-toggles/feature.ts

@@ -24,10 +24,18 @@ export type FeatureTogglesOptions = {
   //
   // Production setup: resolve the runtime after buildServer returns, then
   // pass `() => runtime`. For tests, use createLateBoundHolder + .get().
-  readonly getRuntime: () => GlobalFeatureToggleRuntime;
+  //
+  // **Optional** — boot-mode (KUMIKO_DRY_RUN_ENV=boot) wires the feature
+  // up without ever calling the set-handler, so a runtime-stub is then
+  // pure cargo-cult. Omit `getRuntime` and the handler throws lazily on
+  // first call with an actionable message. App-authors who DO route to
+  // the set-handler at runtime MUST supply the accessor.
+  readonly getRuntime?: () => GlobalFeatureToggleRuntime;
 };
 
-export function createFeatureTogglesFeature(options: FeatureTogglesOptions): FeatureDefinition {
+export function createFeatureTogglesFeature(
+  options: FeatureTogglesOptions = {},
+): FeatureDefinition {
   return defineFeature("feature-toggles", (r) => {
     r.systemScope();
 
@@ -79,6 +87,12 @@ export function createFeatureTogglesFeature(options: FeatureTogglesOptions): Fea
           // than re-parsing — the payload round-trips through JSON and is
           // fixed at the source.
           const payload = event.payload as { featureName: string; enabled: boolean }; // @cast-boundary engine-payload
+          if (!options.getRuntime) {
+            throw new Error(
+              "[feature-toggles] toggle-cache-sync MSP fired but createFeatureTogglesFeature " +
+                "was wired up without `getRuntime`. Wire the accessor in your app-config.",
+            );
+          }
           options.getRuntime().apply(payload.featureName, payload.enabled);
         },
       },

package/src/feature-toggles/global-feature-state-table.ts

@@ -3,9 +3,9 @@ import {
   instant,
   integer,
   table as pgTable,
+  sql,
   text,
 } from "@cosmicdrift/kumiko-framework/db";
-import { sql } from "drizzle-orm";
 
 // Global feature-toggle override state. One row per feature that has ever
 // been explicitly flipped by an operator. Missing row = "no override,

package/src/feature-toggles/handlers/list.query.ts

@@ -1,3 +1,4 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
 import { z } from "zod";
 import { globalFeatureStateTable } from "../global-feature-state-table";
@@ -11,8 +12,14 @@ export const listQuery = defineQueryHandler({
   schema: z.object({}),
   access: { roles: ["SystemAdmin", "Admin"] },
   handler: async (_event, ctx) => {
-    type Row = typeof globalFeatureStateTable.$inferSelect;
-    const rows = (await ctx.db.select().from(globalFeatureStateTable)) as Row[]; // @cast-boundary db-row
+    type Row = {
+      featureName: string;
+      enabled: boolean;
+      version: number;
+      updatedAt: Temporal.Instant;
+      updatedBy: string;
+    };
+    const rows = await selectMany<Row>(ctx.db.raw, globalFeatureStateTable);
     return {
       items: rows.map((r) => ({
         featureName: r.featureName,

package/src/feature-toggles/handlers/registered.query.ts

@@ -1,3 +1,4 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineQueryHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
 import { z } from "zod";
 import { globalFeatureStateTable } from "../global-feature-state-table";
@@ -15,13 +16,8 @@ export const registeredQuery = defineQueryHandler({
   schema: z.object({}),
   access: { roles: ["SystemAdmin", "Admin"] },
   handler: async (_event, ctx) => {
-    type OverrideRow = Pick<typeof globalFeatureStateTable.$inferSelect, "featureName" | "enabled">;
-    const overrideRows = (await ctx.db
-      .select({
-        featureName: globalFeatureStateTable.featureName,
-        enabled: globalFeatureStateTable.enabled,
-      })
-      .from(globalFeatureStateTable)) as OverrideRow[]; // @cast-boundary db-row
+    type OverrideRow = { featureName: string; enabled: boolean };
+    const overrideRows = await selectMany<OverrideRow>(ctx.db.raw, globalFeatureStateTable);
     const overrides = new Map(overrideRows.map((r) => [r.featureName, r.enabled]));
 
     // SystemAdmin operator-tooling: das listing soll die PLATTFORM-truth

package/src/feature-toggles/handlers/set.write.ts

@@ -1,11 +1,10 @@
+import { insertOne, selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import { defineWriteHandler, SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
-
 import {
   UnprocessableError,
   VersionConflictError,
   writeFailure,
 } from "@cosmicdrift/kumiko-framework/errors";
-import { and, eq, sql } from "drizzle-orm";
 import { Temporal } from "temporal-polyfill";
 import { z } from "zod";
 import {
@@ -13,6 +12,7 @@ import {
   FEATURE_TOGGLE_SET_EVENT_NAME,
   FeatureToggleErrors,
 } from "../constants";
+import { updateFeatureToggleOptimistic } from "../db/queries/toggle-state";
 import { globalFeatureStateTable } from "../global-feature-state-table";
 import type { GlobalFeatureToggleRuntime } from "../toggle-runtime";
 
@@ -25,7 +25,13 @@ import type { GlobalFeatureToggleRuntime } from "../toggle-runtime";
 // flow: tests + setupTestStack construct the feature definition BEFORE the
 // runtime exists (the runtime needs the registry, which setupTestStack
 // builds from the features). The accessor is resolved lazily, at call time.
-export function createSetWriteHandler(getRuntime: () => GlobalFeatureToggleRuntime) {
+//
+// `undefined` accessor is legitimate at registration-time for boot-mode
+// smoke-apps (`KUMIKO_DRY_RUN_ENV=boot`) that never dispatch a set-call.
+// We throw lazily on first call with an actionable message — `as
+// GlobalFeatureToggleRuntime`-casts at the registration site are no
+// longer needed.
+export function createSetWriteHandler(getRuntime: (() => GlobalFeatureToggleRuntime) | undefined) {
   return defineWriteHandler({
     name: "set",
     schema: z.object({
@@ -66,18 +72,25 @@ export function createSetWriteHandler(getRuntime: () => GlobalFeatureToggleRunti
       // Read current state for event payload + optimistic-lock version.
       // `$inferSelect` narrows the result shape to the real table schema —
       // no hand-rolled cast, no drift if a column is added later.
-      type StateRow = typeof globalFeatureStateTable.$inferSelect;
-      const [existing] = (await ctx.db
-        .select()
-        .from(globalFeatureStateTable)
-        .where(eq(globalFeatureStateTable.featureName, featureName))
-        .limit(1)) as StateRow[]; // @cast-boundary db-row
+      type StateRow = {
+        featureName: string;
+        enabled: boolean;
+        version: number;
+        updatedAt: Temporal.Instant;
+        updatedBy: string;
+      };
+      const [existing] = await selectMany<StateRow>(
+        ctx.db,
+        globalFeatureStateTable,
+        { featureName },
+        { limit: 1 },
+      );
 
       const previousEnabled = existing?.enabled ?? null;
 
       if (!existing) {
         // First-time override: insert.
-        await ctx.db.insert(globalFeatureStateTable).values({
+        await insertOne(ctx.db, globalFeatureStateTable, {
           featureName,
           enabled,
           version: 1,
@@ -88,21 +101,13 @@ export function createSetWriteHandler(getRuntime: () => GlobalFeatureToggleRunti
         // Upsert with optimistic lock. Two operators flipping the same
         // toggle simultaneously is rare but possible — the version-WHERE
         // ensures only one wins; the loser sees VersionConflictError.
-        const updated = await ctx.db
-          .update(globalFeatureStateTable)
-          .set({
-            enabled,
-            version: sql<number>`${globalFeatureStateTable.version} + 1`,
-            updatedBy: event.user.id,
-            updatedAt: Temporal.Now.instant(),
-          })
-          .where(
-            and(
-              eq(globalFeatureStateTable.featureName, featureName),
-              eq(globalFeatureStateTable.version, existing.version),
-            ),
-          )
-          .returning();
+        const updated = await updateFeatureToggleOptimistic(ctx.db, {
+          enabled,
+          updatedBy: event.user.id,
+          updatedAt: Temporal.Now.instant(),
+          featureName,
+          expectedVersion: existing.version,
+        });
 
         if (updated.length === 0) {
           return writeFailure(
@@ -147,6 +152,13 @@ export function createSetWriteHandler(getRuntime: () => GlobalFeatureToggleRunti
       // the `toggle-cache-sync` MSP (see feature-toggles-feature.ts). Both
       // paths are idempotent — Map.set is last-write-wins and the DB is
       // the source of truth after boot-time initialize().
+      if (!getRuntime) {
+        throw new Error(
+          "[feature-toggles] set-handler called but createFeatureTogglesFeature " +
+            "was wired up without `getRuntime`. Wire the accessor in your app-config " +
+            "(production: `() => runtime` after buildServer; tests: createLateBoundHolder.get).",
+        );
+      }
       getRuntime().apply(featureName, enabled);
 
       return {

package/src/feature-toggles/toggle-runtime.ts

@@ -1,3 +1,4 @@
+import { selectMany } from "@cosmicdrift/kumiko-framework/bun-db";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import {
   computeEffectiveFeatures,
@@ -25,12 +26,8 @@ export class GlobalFeatureToggleRuntime {
   ) {}
 
   async initialize(): Promise<void> {
-    const rows = await this.db
-      .select({
-        featureName: globalFeatureStateTable.featureName,
-        enabled: globalFeatureStateTable.enabled,
-      })
-      .from(globalFeatureStateTable);
+    type Row = { featureName: string; enabled: boolean };
+    const rows = await selectMany<Row>(this.db, globalFeatureStateTable);
     this.snapshot = new Map(rows.map((r) => [r.featureName, r.enabled]));
   }
 

package/src/file-foundation/__tests__/feature.test.ts

@@ -2,7 +2,7 @@
 // Plugin-API-shaped file-foundation. Provider-specific configs/secrets
 // are tested in their own provider-feature (file-provider-s3/__tests__).
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { fileFoundationFeature } from "../feature";
 
 describe("fileFoundationFeature — shape", () => {

package/src/file-foundation/__tests__/file-foundation.integration.ts

@@ -2,6 +2,7 @@
 // provider-factory through the dispatcher so the real config-resolver
 // + secrets-context + tenant-scoped reads are exercised.
 
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
 import { createEncryptionProvider, type DbConnection } from "@cosmicdrift/kumiko-framework/db";
 import { defineFeature, defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
@@ -19,7 +20,6 @@ import {
   createMutableMasterKeyProvider,
   type MutableMasterKeyProvider,
 } from "@cosmicdrift/kumiko-framework/testing";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { createConfigFeature } from "../../config";
 import { ConfigHandlers } from "../../config/constants";

package/src/file-provider-inmemory/__tests__/feature.test.ts

@@ -1,6 +1,6 @@
 // feature.ts contract tests for file-provider-inmemory.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { clearStorage, fileProviderInMemoryFeature, listKeys } from "../feature";
 
 describe("fileProviderInMemoryFeature — shape", () => {

package/src/file-provider-s3/__tests__/feature.test.ts

@@ -1,6 +1,6 @@
 // feature.ts contract tests for file-provider-s3.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { fileProviderS3Feature, S3_SECRET_ACCESS_KEY } from "../feature";
 
 describe("fileProviderS3Feature — shape", () => {

package/src/files/__tests__/files.integration.ts

@@ -12,8 +12,14 @@
 import { defineFeature, EXT_USER_DATA } from "@cosmicdrift/kumiko-framework/engine";
 import { FILE_UPLOADED_EVENT_TYPE, fileRefsTable } from "@cosmicdrift/kumiko-framework/files";
 import { setupTestStack, type TestStack } from "@cosmicdrift/kumiko-framework/stack";
-import { getTableColumns } from "drizzle-orm";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+
+// Native dialect exposes column metadata on the `columns` array (EntityTableMeta)
+// and on the Symbol.for("kumiko:schema:Columns") map (compat shape). Tests use the
+// Symbol map because keys are JS field-names (camelCase), matching what
+// feature-entity definitions declare.
+const KUMIKO_COLUMNS_SYMBOL = Symbol.for("kumiko:schema:Columns");
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { createFilesFeature, fileRefEntity } from "../feature";
 
 let stack: TestStack;
@@ -101,11 +107,16 @@ describe("files :: cross-feature behavior (F1, S1.7)", () => {
 });
 
 describe("files :: DDL-Konsistenz (M3, S1.7)", () => {
-  // Drizzle's getTableColumns liefert die typed column-map ohne den
-  // Symbol-Properties-Junk. Sauberer als Object.keys(table) das auch
-  // interne Drizzle-Symbols mitnimmt.
+  // The native dialect's SchemaTable exposes its column map via the
+  // Symbol.for("kumiko:schema:Columns") metadata (kept for back-compat with
+  // anything that previously introspected pgTable that way). Keys are
+  // JS field-names — exactly the level feature-entity declarations live at.
   function pgColumnNames(): Set<string> {
-    return new Set(Object.keys(getTableColumns(fileRefsTable)));
+    const cols = (fileRefsTable as unknown as Record<symbol, unknown>)[KUMIKO_COLUMNS_SYMBOL];
+    if (typeof cols !== "object" || cols === null) {
+      throw new Error("files.integration: fileRefsTable has no kumiko:schema:Columns symbol");
+    }
+    return new Set(Object.keys(cols as Record<string, unknown>));
   }
 
   test("Feature-Entity-Felder matchen die Framework-pgTable column-set", () => {
@@ -117,7 +128,7 @@ describe("files :: DDL-Konsistenz (M3, S1.7)", () => {
     // Vergleich: alle Feature-Felder muessen als Spalten in der pgTable
     // existieren (umgekehrt darf pgTable framework-managed Spalten haben
     // wie tenantId/createdAt/updatedAt/deletedAt — die deklariert das
-    // Framework automatisch beim buildDrizzleTable-Mapping).
+    // Framework automatisch beim buildEntityTable-Mapping).
     const pgColumns = pgColumnNames();
     const featureFields = Object.keys(fileRefEntity.fields);
 

package/src/files/schema/file-ref.ts

@@ -25,7 +25,7 @@ import {
 //      in Sprint 5 — Tenant-Lifecycle löscht alle FileRefs.
 //   3. Boot-Validation für PII-Annotations greift (fileName, originalName).
 //
-// Kein buildDrizzleTable hier — die Mapping-Tabelle existiert schon im
+// Kein buildEntityTable hier — die Mapping-Tabelle existiert schon im
 // Framework. Drizzle-Reads in den Sprint-2+-Hooks gehen direkt über
 // `fileRefsTable` aus `@cosmicdrift/kumiko-framework/files`.
 //

package/src/files-provider-s3/__tests__/env-helper.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { parseS3EnvConfig } from "../env-helper";
 
 // Tests run against real process.env — we snapshot + restore per-test so

package/src/files-provider-s3/__tests__/s3-provider.integration.ts

@@ -1,6 +1,6 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { FileStorageProvider } from "@cosmicdrift/kumiko-framework/files";
 import { generateId } from "@cosmicdrift/kumiko-framework/utils";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { createS3ProviderFromEnv } from "../env-helper";
 import { createS3Provider } from "../s3-provider";