@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/pipeline/event-retention.ts

@@ -1,5 +1,6 @@
-import { and, getTableName, inArray, lt, sql } from "drizzle-orm";
 import type { DbConnection } from "../db/connection";
+import { lockEventConsumersShareMode } from "../db/queries/event-consumer";
+import { deleteMany, selectMany, transaction } from "../db/query";
 import { eventsTable } from "../event-store";
 import { eventConsumerStateTable } from "./event-consumer-state";
 
@@ -83,7 +84,7 @@ export async function pruneEvents(
   const aggregateTypes = options.aggregateTypes;
   const dryRun = options.dryRun === true;
 
-  return db.transaction(async (tx) => {
+  return transaction(db, async (tx) => {
     // Serialise against consumer-bootstrap INSERTs. Without this, the race
     // is: prune reads consumers (snapshot misses a consumer bootstrapping
     // in a parallel tx) → consumer commits its row with
@@ -96,21 +97,13 @@ export async function pruneEvents(
     // (cursor advances) do too, but prune is measured in milliseconds and
     // pausing cursor advances for that window is cheap insurance against
     // a silent data-loss bug.
-    //
-    // Drizzle can't express LOCK TABLE — drop to raw SQL with the table
-    // name identifier so a future table-rename is caught at compile time.
-    await tx.execute(sql.raw(`LOCK TABLE ${getTableName(eventConsumerStateTable)} IN SHARE MODE`));
+    await lockEventConsumersShareMode(tx);
 
     // Step 1 — collect candidate event ids.
-    const candidates = await tx
-      .select({ id: eventsTable.id })
-      .from(eventsTable)
-      .where(
-        and(
-          inArray(eventsTable.aggregateType, [...aggregateTypes]),
-          lt(eventsTable.createdAt, cutoff),
-        ),
-      );
+    const candidates = await selectMany<{ id: bigint }>(tx, eventsTable, {
+      aggregateType: [...aggregateTypes],
+      createdAt: { lt: cutoff },
+    });
 
     if (candidates.length === 0) {
       return { deletedCount: 0, cutoff, aggregateTypes, dryRun };
@@ -127,10 +120,10 @@ export async function pruneEvents(
     // The SHARE lock above guarantees this SELECT sees a complete view:
     // no new consumer can INSERT a fresh-cursor row between here and the
     // DELETE below.
-    const activeConsumers = await tx
-      .select()
-      .from(eventConsumerStateTable)
-      .where(sql`${eventConsumerStateTable.status} <> 'disabled'`);
+    const activeConsumers = await selectMany<{
+      name: string;
+      lastProcessedEventId: bigint;
+    }>(tx, eventConsumerStateTable, { status: { ne: "disabled" } });
 
     for (const consumer of activeConsumers) {
       if (consumer.lastProcessedEventId < maxCandidateId) {
@@ -144,11 +137,8 @@ export async function pruneEvents(
 
     // Step 3 — actual delete, bounded to the candidate set.
     const candidateIds = candidates.map((c) => c.id);
-    const deleted = await tx
-      .delete(eventsTable)
-      .where(inArray(eventsTable.id, candidateIds))
-      .returning({ id: eventsTable.id });
+    await deleteMany(tx, eventsTable, { id: candidateIds });
 
-    return { deletedCount: deleted.length, cutoff, aggregateTypes, dryRun: false };
+    return { deletedCount: candidateIds.length, cutoff, aggregateTypes, dryRun: false };
   });
 }

package/src/pipeline/msp-rebuild.ts

@@ -1,5 +1,12 @@
-import { and, asc, eq, getTableName, inArray, sql } from "drizzle-orm";
-import type { DbConnection, DbRunner } from "../db/connection";
+import type { DbConnection, DbRunner, DbTx } from "../db/connection";
+import {
+  markConsumerRebuildFailed,
+  resetConsumerForMspRebuild,
+  selectConsumerForUpdate,
+  updateConsumerRebuildCursor,
+} from "../db/queries/event-consumer";
+import { truncateTable } from "../db/queries/table-ops";
+import { selectMany } from "../db/query";
 import type { Registry, TenantId } from "../engine/types";
 import { InternalError } from "../errors";
 import { eventsTable, type StoredEvent, upcastStoredEvent } from "../event-store";
@@ -7,7 +14,7 @@ import { loadAggregate, loadAggregateAsOf } from "../event-store/event-store";
 import { upcastStoredEvents } from "../event-store/upcaster";
 import { emitProjectionRebuild } from "../observability/standard-metrics";
 import type { Meter } from "../observability/types/metric";
-import { eventConsumerStateTable, SHARED_INSTANCE_SENTINEL } from "./event-consumer-state";
+import { SHARED_INSTANCE_SENTINEL } from "./event-consumer-state";
 import type { MultiStreamApplyContext } from "./multi-stream-apply-context";
 import type { RebuildResult } from "./projection-rebuild";
 
@@ -101,57 +108,35 @@ export async function rebuildMultiStreamProjection(
   let lastProcessedEventId = 0n;
 
   try {
-    await db.transaction(async (tx) => {
-      // Upsert + lock the consumer row. Rebuild always targets the
-      // SHARED-delivery shard: per-instance MSPs are side-effect-only (no
-      // table, so the guard above refuses them anyway), and rebuild's
-      // purpose is to rematerialize one persistent read-model, not fan
-      // out a local cache reset across instances. The FOR UPDATE on the
-      // next SELECT is what blocks concurrent rebuilds of the same MSP;
-      // live dispatcher passes use SKIP LOCKED on this row and will bail
-      // silently while we hold it.
-      await tx
-        .insert(eventConsumerStateTable)
-        .values({
-          name: mspName,
-          instanceId: SHARED_INSTANCE_SENTINEL,
-          lastProcessedEventId: 0n,
-          status: "idle",
-        })
-        .onConflictDoUpdate({
-          target: [eventConsumerStateTable.name, eventConsumerStateTable.instanceId],
-          set: {
-            lastProcessedEventId: 0n,
-            status: "idle",
-            attempts: 0,
-            lastError: null,
-            updatedAt: sql`now()`,
-          },
-        });
-      await tx
-        .select()
-        .from(eventConsumerStateTable)
-        .where(
-          and(
-            eq(eventConsumerStateTable.name, mspName),
-            eq(eventConsumerStateTable.instanceId, SHARED_INSTANCE_SENTINEL),
-          ),
-        )
-        .for("update");
+    await db.begin(async (tx: DbTx) => {
+      await resetConsumerForMspRebuild(tx, mspName, SHARED_INSTANCE_SENTINEL);
+      await selectConsumerForUpdate(tx, mspName, SHARED_INSTANCE_SENTINEL);
 
-      // msp.table is narrowed by the upfront guard; the assertion here is
-      // for TS inside the async closure (narrowing doesn't cross the
-      // transaction boundary).
-      const tableName = getTableName(msp.table as NonNullable<typeof msp.table>); // @cast-boundary db-operator
-      await tx.execute(sql.raw(`TRUNCATE TABLE ${quoteIdent(tableName)}`));
+      const mspTable = msp.table as NonNullable<typeof msp.table>;
+      const tableName = getTableName(mspTable);
+      await truncateTable(tx, tableName);
 
       const subscribedTypes = Object.keys(msp.apply);
       if (subscribedTypes.length > 0) {
-        const events = (await tx
-          .select()
-          .from(eventsTable)
-          .where(inArray(eventsTable.type, subscribedTypes))
-          .orderBy(asc(eventsTable.id))) as ReadonlyArray<typeof eventsTable.$inferSelect>; // @cast-boundary db-row
+        type EventRow = {
+          id: bigint;
+          aggregateId: string;
+          aggregateType: string;
+          tenantId: TenantId;
+          version: number;
+          type: string;
+          eventVersion: number;
+          payload: Record<string, unknown>;
+          metadata: import("../event-store/event-store").EventMetadata;
+          createdAt: Temporal.Instant;
+          createdBy: string;
+        };
+        const events = await selectMany<EventRow>(
+          tx,
+          eventsTable,
+          { type: [...subscribedTypes] },
+          { orderBy: { col: "id", direction: "asc" } },
+        );
 
         const upcasters = registry.getEventUpcasters();
         for (const row of events) {
@@ -170,44 +155,27 @@ export async function rebuildMultiStreamProjection(
           };
           const storedEvent = await upcastStoredEvent(raw, upcasters, {
             db: tx,
-            tenantId: row.tenantId as TenantId, // @cast-boundary db-row
+            tenantId: row.tenantId,
           });
           const applyFn = msp.apply[row.type];
           if (!applyFn) continue;
-          const rebuildCtx = createRebuildCtx(registry, tx, row.tenantId as TenantId); // @cast-boundary db-row
+          const rebuildCtx = createRebuildCtx(registry, tx, row.tenantId);
           await applyFn(storedEvent, tx, rebuildCtx);
           eventsProcessed++;
           lastProcessedEventId = row.id;
         }
       }
 
-      await tx
-        .update(eventConsumerStateTable)
-        .set({
-          lastProcessedEventId,
-          status: "idle",
-          attempts: 0,
-          lastError: null,
-          updatedAt: sql`now()`,
-        })
-        .where(
-          and(
-            eq(eventConsumerStateTable.name, mspName),
-            eq(eventConsumerStateTable.instanceId, SHARED_INSTANCE_SENTINEL),
-          ),
-        );
+      await updateConsumerRebuildCursor(
+        tx,
+        mspName,
+        SHARED_INSTANCE_SENTINEL,
+        lastProcessedEventId,
+      );
     });
   } catch (e) {
     const message = e instanceof Error ? e.message : String(e);
-    await db
-      .update(eventConsumerStateTable)
-      .set({ status: "dead", lastError: message, updatedAt: sql`now()` })
-      .where(
-        and(
-          eq(eventConsumerStateTable.name, mspName),
-          eq(eventConsumerStateTable.instanceId, SHARED_INSTANCE_SENTINEL),
-        ),
-      );
+    await markConsumerRebuildFailed(db, mspName, SHARED_INSTANCE_SENTINEL, message);
     if (deps.meter) {
       emitProjectionRebuild(
         deps.meter,
@@ -237,6 +205,14 @@ export async function rebuildMultiStreamProjection(
   return result;
 }
 
-function quoteIdent(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`;
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+function getTableName(table: unknown): string {
+  if (typeof table !== "object" || table === null) {
+    throw new InternalError({ message: "msp-rebuild: msp.table is not a pgTable object" });
+  }
+  const name = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  if (typeof name !== "string") {
+    throw new InternalError({ message: "msp-rebuild: msp.table missing drizzle name symbol" });
+  }
+  return name;
 }

package/src/pipeline/projection-rebuild.ts

@@ -1,5 +1,12 @@
-import { asc, eq, getTableName, inArray, sql } from "drizzle-orm";
-import type { DbConnection } from "../db/connection";
+import type { DbConnection, DbTx } from "../db/connection";
+import {
+  finalizeProjectionRebuild,
+  markProjectionRebuildFailed,
+  markProjectionRebuilding,
+  selectEventsForProjectionRebuild,
+} from "../db/queries/projection-rebuild";
+import { truncateTable } from "../db/queries/table-ops";
+import { coerceRow, extractTableInfo, selectMany } from "../db/query";
 import type { Registry, TenantId } from "../engine/types";
 import {
   eventsTable,
@@ -86,53 +93,43 @@ export async function rebuildProjection(
   let lastProcessedEventId = 0n;
 
   try {
-    await db.transaction(async (tx) => {
-      // Lock the state row. Use upsert so a never-rebuilt projection also
-      // gets a row. FOR UPDATE would need the row to exist — upsert-first
-      // keeps it idempotent.
-      await tx
-        .insert(projectionStateTable)
-        .values({ name: projectionName, status: "rebuilding" })
-        .onConflictDoUpdate({
-          target: projectionStateTable.name,
-          set: {
-            status: "rebuilding",
-            lastError: null,
-            updatedAt: sql`now()`,
-          },
-        });
+    await db.begin(async (tx: DbTx) => {
+      await markProjectionRebuilding(tx, projectionName);
 
-      // Wipe the projection table. drizzle-orm's public API doesn't expose
-      // TRUNCATE, so we issue raw SQL — but `getTableName()` is the public
-      // accessor for the table's registered name, avoiding Symbol.for()
-      // internal lookups. The identifier is still quoted defensively.
       const tableName = getTableName(projection.table);
-      await tx.execute(sql.raw(`TRUNCATE TABLE ${quoteIdent(tableName)}`));
+      await truncateTable(tx, tableName);
 
       // Stream events in chronological order for every source. The event
-      // type filter (inArray(type, validTypes)) prunes events the projection
-      // doesn't care about early — important when a single source has more
-      // event types than the projection subscribes to.
+      // type filter prunes events the projection doesn't care about early.
       const subscribed = Object.keys(projection.apply);
       if (subscribed.length === 0) {
         // nothing to replay, just mark idle — projection exists but doesn't
         // subscribe to any event types on its sources yet.
       } else {
-        const events = (await tx
-          .select()
-          .from(eventsTable)
-          .where(
-            sql`${inArray(eventsTable.aggregateType, sources)} AND ${inArray(
-              eventsTable.type,
-              subscribed,
-            )}`,
-          )
-          .orderBy(asc(eventsTable.id))) as ReadonlyArray<typeof eventsTable.$inferSelect>; // @cast-boundary db-row
+        type EventRow = {
+          id: bigint;
+          aggregateId: string;
+          aggregateType: string;
+          tenantId: string;
+          version: number;
+          type: string;
+          eventVersion: number;
+          payload: Record<string, unknown>;
+          metadata: import("../event-store/event-store").EventMetadata;
+          createdAt: Temporal.Instant;
+          createdBy: string;
+        };
+        const sourcesList = [...sources];
+        const subscribedList = [...subscribed];
+        const rawEvents = await selectEventsForProjectionRebuild(tx, sourcesList, subscribedList);
+        const events = rawEvents.map((r) => {
+          const info = extractTableInfo(eventsTable);
+          return coerceRow(r, info) as EventRow;
+        });
 
         // Upcasters run at read time: older stored payloads get walked
         // through the registered r.eventMigration chain until their shape
-        // matches the current event version. An apply() written against the
-        // v3 shape stays oblivious to v1 payloads still on disk.
+        // matches the current event version.
         const upcasters = registry.getEventUpcasters();
         for (const row of events) {
           deps.signal?.throwIfAborted();
@@ -163,30 +160,13 @@ export async function rebuildProjection(
         }
       }
 
-      // Finalize state row.
-      await tx
-        .update(projectionStateTable)
-        .set({
-          lastProcessedEventId,
-          status: "idle",
-          lastRebuildAt: sql`now()`,
-          lastError: null,
-          updatedAt: sql`now()`,
-        })
-        .where(eq(projectionStateTable.name, projectionName));
+      await finalizeProjectionRebuild(tx, projectionName, lastProcessedEventId);
     });
   } catch (e) {
     // Outer catch: TX has been rolled back by Postgres already. Record the
-    // failure in a SEPARATE write so ops can see what happened — the
-    // rolled-back status change is gone, so we write failed+error now.
+    // failure in a SEPARATE write so ops can see what happened.
     const message = e instanceof Error ? e.message : String(e);
-    await db
-      .insert(projectionStateTable)
-      .values({ name: projectionName, status: "failed", lastError: message })
-      .onConflictDoUpdate({
-        target: projectionStateTable.name,
-        set: { status: "failed", lastError: message, updatedAt: sql`now()` },
-      });
+    await markProjectionRebuildFailed(db, projectionName, message);
     // Failure metric: duration until throw, 0 events "delivered" (the replayed
     // rows were rolled back — counting them would overstate live delivery).
     // success=false label distinguishes these in Prom dashboards.
@@ -219,11 +199,16 @@ export async function rebuildProjection(
   return result;
 }
 
-// Identifier quoting for raw TRUNCATE. Drizzle doesn't expose a safe helper
-// for table-name interpolation in raw SQL; double-quote + escape double-quote
-// matches Postgres identifier rules.
-function quoteIdent(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`;
+const KUMIKO_NAME_SYMBOL = Symbol.for("kumiko:schema:Name");
+function getTableName(table: unknown): string {
+  if (typeof table !== "object" || table === null) {
+    throw new Error("projection-rebuild: projection.table is not a pgTable object");
+  }
+  const name = (table as Record<symbol, unknown>)[KUMIKO_NAME_SYMBOL];
+  if (typeof name !== "string") {
+    throw new Error("projection-rebuild: projection.table missing drizzle name symbol");
+  }
+  return name;
 }
 
 // Read-only status for one projection. Returns null if the projection was
@@ -239,10 +224,15 @@ export async function getProjectionState(
   readonly lastError: string | null;
   readonly updatedAt: Temporal.Instant;
 } | null> {
-  const [row] = await db
-    .select()
-    .from(projectionStateTable)
-    .where(eq(projectionStateTable.name, projectionName));
+  type Row = {
+    readonly name: string;
+    readonly status: string;
+    readonly lastProcessedEventId: bigint;
+    readonly lastRebuildAt: Temporal.Instant | null;
+    readonly lastError: string | null;
+    readonly updatedAt: Temporal.Instant;
+  };
+  const [row] = await selectMany<Row>(db, projectionStateTable, { name: projectionName });
   if (!row) return null;
   return {
     name: row.name,
@@ -277,8 +267,16 @@ export async function listProjectionsWithState(
     readonly lastError: string | null;
   }>
 > {
+  type StateRow = {
+    name: string;
+    status: string;
+    lastProcessedEventId: bigint;
+    lastRebuildAt: Temporal.Instant | null;
+    lastError: string | null;
+    updatedAt: Temporal.Instant;
+  };
   const projections = registry.getAllProjections();
-  const stateRows = await db.select().from(projectionStateTable);
+  const stateRows = await selectMany<StateRow>(db, projectionStateTable);
   const stateByName = new Map(stateRows.map((r) => [r.name, r]));
 
   return [...projections.values()]

package/src/pipeline/projection-state.ts

@@ -1,6 +1,6 @@
-import { sql } from "drizzle-orm";
+// sql now comes from native dialect
 import type { DbConnection } from "../db/connection";
-import { bigint, index, instant, table as pgTable, text } from "../db/dialect";
+import { bigint, index, instant, table as pgTable, sql, text } from "../db/dialect";
 import { tableExists } from "../db/schema-inspection";
 import { unsafePushTables } from "../stack";
 

package/src/random/__tests__/generate.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import {
   ADJECTIVES,
   generateAdjNounName,
@@ -12,16 +12,16 @@ describe("generateAdjNounName", () => {
     const name = generateAdjNounName();
     const [adj, noun, ...rest] = name.split("-");
     expect(rest).toEqual([]);
-    expect(ADJECTIVES).toContain(adj);
-    expect(NOUNS).toContain(noun);
+    expect(ADJECTIVES).toContain(adj!);
+    expect(NOUNS).toContain(noun!);
   });
 
   test("custom separator", () => {
     const name = generateAdjNounName({ separator: "_" });
     expect(name).toMatch(/^[a-z]+_[a-z]+$/);
     const [adj, noun] = name.split("_");
-    expect(ADJECTIVES).toContain(adj);
-    expect(NOUNS).toContain(noun);
+    expect(ADJECTIVES).toContain(adj!);
+    expect(NOUNS).toContain(noun!);
   });
 
   test("mit suffix: <adj>-<noun>-<suffix>", () => {
@@ -29,11 +29,11 @@ describe("generateAdjNounName", () => {
     const parts = name.split("-");
     expect(parts).toHaveLength(3);
     const [adj, noun, suffix] = parts;
-    expect(ADJECTIVES).toContain(adj);
-    expect(NOUNS).toContain(noun);
-    expect(suffix).toMatch(/^[a-z2-9]{3}$/);
+    expect(ADJECTIVES).toContain(adj!);
+    expect(NOUNS).toContain(noun!);
+    expect(suffix!).toMatch(/^[a-z2-9]{3}$/);
     // No-confusable: keine 0/1/o/l/i
-    expect(suffix).not.toMatch(/[01oli]/);
+    expect(suffix!).not.toMatch(/[01oli]/);
   });
 
   test("custom adjectives + nouns Wahl", () => {
@@ -94,7 +94,7 @@ describe("generateUniqueName", () => {
       },
     });
     expect(seen).toHaveLength(1);
-    expect(name).toBe(seen[0]);
+    expect(name).toBe(seen[0]!);
     // Clean = nur 2 Teile (adj + noun), kein suffix
     expect(name.split("-")).toHaveLength(2);
   });
@@ -112,11 +112,11 @@ describe("generateUniqueName", () => {
     expect(tried).toHaveLength(4);
     // Erste 3 ohne suffix
     for (let i = 0; i < 3; i++) {
-      expect(tried[i]?.split("-")).toHaveLength(2);
+      expect(tried[i]!.split("-")).toHaveLength(2);
     }
     // 4. Versuch hat suffix
-    expect(tried[3]?.split("-")).toHaveLength(3);
-    expect(name).toBe(tried[3]);
+    expect(tried[3]!.split("-")).toHaveLength(3);
+    expect(name).toBe(tried[3]!);
   });
 
   test("wirft wenn maxTotalAttempts erschöpft", async () => {

package/src/rate-limit/__tests__/{dispatcher-l3.integration.ts → dispatcher-l3.integration.test.ts}

@@ -1,5 +1,5 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { defineFeature, defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { z } from "zod";
 import { createTestUser, setupTestStack, type TestStack, TestUsers } from "../../stack";
 

package/src/rate-limit/__tests__/{middleware.integration.ts → middleware.integration.test.ts}

@@ -1,5 +1,5 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { Hono } from "hono";
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
 import { createTestRedis, type TestRedis } from "../../stack";
 import { authEndpointRateLimit, globalIpRateLimit } from "../middleware";
 import { createRateLimitResolver, type RateLimitResolver } from "../resolver";

package/src/rate-limit/__tests__/{resolver.integration.ts → resolver.integration.test.ts}

@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { RateLimitError } from "../../errors";
 import { createTestRedis, type TestRedis } from "../../stack";
 import {

package/src/redis/__tests__/redis-options.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { redisClientOptionsFromEnv } from "../index";
 
 describe("redisClientOptionsFromEnv", () => {

package/src/search/__tests__/{meilisearch-adapter.integration.ts → meilisearch-adapter.integration.test.ts}

@@ -1,7 +1,7 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
 import { generateId as uuid } from "@cosmicdrift/kumiko-framework/utils";
 import { Meilisearch } from "meilisearch";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
 import { createMeilisearchAdapter } from "../meilisearch-adapter";
 import type { SearchAdapter } from "../types";
 

package/src/search/__tests__/search-adapter.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, test } from "vitest";
+import { beforeEach, describe, expect, test } from "bun:test";
 import { createInMemorySearchAdapter } from "../in-memory-adapter";
 import type { SearchAdapter } from "../types";
 

package/src/secrets/__tests__/dek-cache.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test, vi } from "vitest";
 import { createDekCache } from "../dek-cache";
 import type { MasterKeyProvider } from "../types";
 
@@ -153,8 +153,6 @@ describe("DekCache", () => {
     t = 5 * 60 * 1000 + 1; // just past 5 min
     await cache.unwrapDek(Buffer.from("x"), 1, provider);
     expect(provider.unwrapCallCount()).toBe(2);
-    // avoid vitest unused-import warning
-    void vi;
   });
 
   test("LRU: evicts oldest when maxEntries is reached", async () => {

package/src/secrets/__tests__/env-master-key-provider.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test } from "vitest";
 import { createEnvMasterKeyProvider } from "../env-master-key-provider";
 
 function env(vars: Record<string, string>): Record<string, string> {

package/src/secrets/__tests__/envelope.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test } from "vitest";
 import { createEnvMasterKeyProvider } from "../env-master-key-provider";
 import { decryptValue, encryptValue } from "../envelope";
 

package/src/secrets/__tests__/leak-guard.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { assertNoSecretLeak } from "../leak-guard";
 import { createSecret } from "../types";
 

package/src/secrets/__tests__/rotation.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
-import { describe, expect, test } from "vitest";
 import { createEnvMasterKeyProvider } from "../env-master-key-provider";
 import { decryptValue, encryptValue } from "../envelope";
 import { rewrapDek } from "../rotation";