@cosmicdrift/kumiko-framework 0.367.0 → 0.369.0

package/dist/db/api.d.ts

@@ -1,19 +0,0 @@
-import type { PgListenClient } from "@cosmicdrift/kumiko-types/db-connection";
-export type DbConnectionOptions = {
-    readonly maxConnections?: number;
-    readonly idleTimeoutSeconds?: number;
-    readonly connectTimeoutSeconds?: number;
-    readonly closeTimeoutSeconds?: number;
-};
-export declare const DEFAULT_DB_CLOSE_TIMEOUT_SECONDS = 5;
-export type DbPoolHandle = {
-    /** Provider Connection — Calls gehen über asRawClient() oder direkt. */
-    readonly db: any;
-    /** Raw driver client (postgres-js or Bun.SQL) */
-    readonly client: any;
-    /** LISTEN-capable client; Bun.SQL serves it from its own dedicated connection */
-    readonly listenClient?: PgListenClient;
-    /** Pool schliessen */
-    close: () => Promise<void>;
-};
-export declare function createConnection(url: string, options?: DbConnectionOptions): Promise<DbPoolHandle>;

package/dist/db/api.js

@@ -1,23 +0,0 @@
-// DB-API: Unified Types und Connection-Factory.
-// Provider-agnostic code verwendet ausschliesslich diese Types.
-// Provider-Implementierungen: postgres-provider.ts, bun-provider.ts.
-//
-// `asRawClient(db)` aus bun-db/query.ts normalisiert beide Provider
-// zu { unsafe, begin } — business code ist provider-neutral.
-//
-// Default: postgres-js. Set DB_PROVIDER=bun für Bun.SQL (experimentell).
-// A DB outage can leave an in-flight query referenced on a dead connection,
-// so a plain end() (no timeout = wait for queries to finish) hangs forever —
-// close() must always bound how long shutdown waits.
-export const DEFAULT_DB_CLOSE_TIMEOUT_SECONDS = 5;
-let _provider;
-export async function createConnection(url, options = {}) {
-    const p = process.env["DB_PROVIDER"];
-    if (p === "bun" || p === "bun-sql") {
-        const { createBunConnection } = await import("./bun-provider.js");
-        return createBunConnection(url, options);
-    }
-    // postgres-js: sync, kein async import nötig
-    const { createPgConnection } = await import("./postgres-provider.js");
-    return createPgConnection(url, options);
-}

package/dist/db/bun-provider.d.ts

@@ -1,2 +0,0 @@
-import { type DbConnectionOptions, type DbPoolHandle } from "./api.js";
-export declare function createBunConnection(url: string, options?: DbConnectionOptions): DbPoolHandle;

package/dist/db/bun-provider.js

@@ -1,28 +0,0 @@
-// Bun.SQL provider, opt-in via DB_PROVIDER=bun; postgres-js stays the default.
-// Known bug (Bun <= 1.4.3, oven-sh/bun#29484): a cached plan is not re-prepared
-// after DDL, so e.g. `SELECT *` after ADD COLUMN fails on that connection with
-// 0A000 "cached plan must not change result type". prepare:false is no fix,
-// it changes how jsonb params are bound.
-//
-// LISTEN runs on Bun.SQL's own dedicated connection, which is exempt from the
-// pool's idleTimeout and maxLifetime and re-LISTENs after a drop.
-import { DEFAULT_DB_CLOSE_TIMEOUT_SECONDS, } from "./api.js";
-export function createBunConnection(url, options = {}) {
-    const bunOpts = {};
-    if (options.maxConnections !== undefined)
-        bunOpts.max = options.maxConnections;
-    if (options.idleTimeoutSeconds !== undefined)
-        bunOpts.idleTimeout = options.idleTimeoutSeconds;
-    if (options.connectTimeoutSeconds !== undefined)
-        bunOpts.connectionTimeout = options.connectTimeoutSeconds;
-    const db = new Bun.SQL(url, bunOpts);
-    const closeTimeout = options.closeTimeoutSeconds ?? DEFAULT_DB_CLOSE_TIMEOUT_SECONDS;
-    return {
-        db,
-        client: db,
-        listenClient: db,
-        close: async () => {
-            await db.end({ timeout: closeTimeout });
-        },
-    };
-}

package/dist/db/postgres-provider.d.ts

@@ -1,2 +0,0 @@
-import { type DbConnectionOptions, type DbPoolHandle } from "./api.js";
-export declare function createPgConnection(url: string, options?: DbConnectionOptions): DbPoolHandle;

package/dist/db/postgres-provider.js

@@ -1,21 +0,0 @@
-// PostgreSQL Provider: postgres-js.
-// Standard-Provider — stabil, keine bekannten Protocol-Level-Bugs.
-// `asRawClient(db)` wrappt .unsafe und .begin transparent.
-import postgres from "postgres";
-import { DEFAULT_DB_CLOSE_TIMEOUT_SECONDS, } from "./api.js";
-export function createPgConnection(url, options = {}) {
-    const pgOptions = {};
-    if (options.maxConnections !== undefined)
-        pgOptions.max = options.maxConnections;
-    if (options.idleTimeoutSeconds !== undefined)
-        pgOptions.idle_timeout = options.idleTimeoutSeconds;
-    if (options.connectTimeoutSeconds !== undefined) {
-        pgOptions.connect_timeout = options.connectTimeoutSeconds;
-    }
-    const client = postgres(url, pgOptions);
-    return {
-        db: client,
-        client,
-        close: () => client.end({ timeout: options.closeTimeoutSeconds ?? DEFAULT_DB_CLOSE_TIMEOUT_SECONDS }),
-    };
-}

package/dist/db/query-api.d.ts

@@ -1,2 +0,0 @@
-export type { JsonTextMatch, SelectOptions, WhereObject, WhereOperator, WhereValue, } from "../db/query.js";
-export { aggregateWhere, asRawClient, countWhere, deleteMany, fetchOne, insertMany, insertOne, runInSavepoint, selectMany, transaction, updateMany, } from "../db/query.js";

package/dist/db/query-api.js

@@ -1,6 +0,0 @@
-// Legacy re-export shim — query-api.ts hat früher drizzle gewrapped.
-// Heute liegen die Helpers in src/bun-db/. Wir re-exportieren von dort
-// damit existing imports `@cosmicdrift/kumiko-framework/db` weiterhin
-// funktionieren während wir die Callers schrittweise auf den direkten
-// bun-db-Import migrieren.
-export { aggregateWhere, asRawClient, countWhere, deleteMany, fetchOne, insertMany, insertOne, runInSavepoint, selectMany, transaction, updateMany, } from "../db/query.js";

package/dist/stack/db.d.ts

@@ -1,22 +0,0 @@
-import type { DbConnection, PgListenClient } from "@cosmicdrift/kumiko-types/db-connection";
-declare function requireEnv(name: string): string;
-export type TestDb = {
-    db: DbConnection;
-    outsideTransactionDb: DbConnection;
-    client: PgListenClient;
-    dbName: string;
-    cleanup: () => Promise<void>;
-};
-export type CreateTestDbOptions = {
-    readonly baseUrl?: string;
-    readonly dbName?: string;
-    readonly persistent?: boolean;
-    readonly poolMax?: number;
-    readonly outsideTransactionPoolMax?: number;
-};
-/**
- * Provider-agnostische Test-DB. createConnection liest DB_PROVIDER.
- * Für Bun.SQL: DB_PROVIDER=bun setzen (experimentell — siehe db/bun-provider.ts).
- */
-export declare function createTestDb(arg?: string | CreateTestDbOptions): Promise<TestDb>;
-export { requireEnv };

package/dist/stack/db.js

@@ -1,67 +0,0 @@
-// Test-DB Factory: CREATE DATABASE → connect → createEventsTable.
-// Provider-agnostic via createConnection (DB_PROVIDER env).
-// postgres-js = default. DB_PROVIDER=bun = Bun.SQL (experimentell).
-import { createConnection } from "../db/api.js";
-import { DEFAULT_OUTSIDE_TRANSACTION_POOL_MAX } from "../db/connection.js";
-import { createDatabase, databaseExists, dropDatabaseIfExists } from "../db/queries/test-stack.js";
-import { ensureTemporalPolyfill } from "../time/polyfill.js";
-import { generateId } from "../utils/index.js";
-function requireEnv(name) {
-    const value = process.env[name];
-    if (!value) {
-        throw new Error(`Missing required env var: ${name}. Copy .env.example to .env and fill in values. Tests also need the test services (Postgres, Redis) running, e.g. "docker compose up -d".`);
-    }
-    return value;
-}
-/**
- * Provider-agnostische Test-DB. createConnection liest DB_PROVIDER.
- * Für Bun.SQL: DB_PROVIDER=bun setzen (experimentell — siehe db/bun-provider.ts).
- */
-export async function createTestDb(arg) {
-    await ensureTemporalPolyfill();
-    const opts = typeof arg === "string" ? { baseUrl: arg } : (arg ?? {});
-    const url = opts.baseUrl ?? requireEnv("TEST_DATABASE_URL");
-    const dbName = opts.dbName ?? `kumiko_test_${generateId().slice(-8)}`;
-    const adminUrl = url.replace(/\/[^/]+$/, "/postgres");
-    const admin = await createConnection(adminUrl, { maxConnections: 1 });
-    try {
-        if (opts.persistent) {
-            if (!(await databaseExists(admin.db, dbName))) {
-                await createDatabase(admin.db, dbName);
-            }
-        }
-        else {
-            await createDatabase(admin.db, dbName);
-        }
-    }
-    finally {
-        await admin.close();
-    }
-    const testUrl = url.replace(/\/[^/]+$/, `/${dbName}`);
-    const conn = await createConnection(testUrl, opts.poolMax !== undefined ? { maxConnections: opts.poolMax } : {});
-    const outsideConn = await createConnection(testUrl, {
-        maxConnections: opts.outsideTransactionPoolMax ?? DEFAULT_OUTSIDE_TRANSACTION_POOL_MAX,
-    });
-    const { createEventsTable } = await import("../event-store/index.js");
-    await createEventsTable(conn.db);
-    return {
-        db: conn.db,
-        outsideTransactionDb: outsideConn.db,
-        client: conn.client,
-        dbName,
-        cleanup: async () => {
-            await conn.close();
-            await outsideConn.close();
-            if (!opts.persistent) {
-                const admin2 = await createConnection(adminUrl, { maxConnections: 1 });
-                try {
-                    await dropDatabaseIfExists(admin2.db, dbName);
-                }
-                finally {
-                    await admin2.close();
-                }
-            }
-        },
-    };
-}
-export { requireEnv };

package/dist/stack/drain-event-consumers.d.ts

@@ -1,4 +0,0 @@
-import type { TestStack } from "./test-stack.js";
-export declare function drainEventConsumers(stack: Pick<TestStack, "db" | "eventDispatcher">, consumerNames: readonly [string, ...string[]], options?: {
-    readonly maxPasses?: number;
-}): Promise<void>;

package/dist/stack/drain-event-consumers.js

@@ -1,51 +0,0 @@
-import { getEventsHighWaterMark } from "../event-store/index.js";
-import { getConsumerState } from "../pipeline/index.js";
-const DEFAULT_MAX_PASSES = 25;
-// Drives eventDispatcher.runOnce() until every named consumer has caught up
-// to the events high-water mark captured at call time. No "no progress ⇒
-// throw" shortcut: a pass can legitimately advance zero cursors even though
-// work remains — runOnce's FOR UPDATE SKIP LOCKED lets a concurrent pass
-// (the test stack's own 50ms poll timer) hold a consumer's row, and a
-// consumer coming off a thrown-pass backoff sits idle until its retryAtMs
-// elapses. A bounded pass budget tolerates both without pretending to detect
-// "stuck" from a single empty pass. The target is a snapshot: events a
-// consumer's own handler writes afterward (cascades) are not waited on.
-export async function drainEventConsumers(stack, consumerNames, options) {
-    const { db, eventDispatcher } = stack;
-    if (!eventDispatcher) {
-        throw new Error("drainEventConsumers: stack.eventDispatcher is undefined — no system consumer or " +
-            "multiStreamProjection is wired for this stack.");
-    }
-    const maxPasses = options?.maxPasses ?? DEFAULT_MAX_PASSES;
-    if (!Number.isInteger(maxPasses) || maxPasses < 1) {
-        throw new Error("drainEventConsumers: maxPasses must be a positive integer");
-    }
-    const target = await getEventsHighWaterMark(db);
-    for (let pass = 0; pass < maxPasses; pass++) {
-        await eventDispatcher.runOnce();
-        const states = await loadConsumerStates(db, consumerNames);
-        // skip: every named consumer has already caught up to the target snapshot — the
-        // remaining budgeted passes are unnecessary, not a swallowed error.
-        if (states.every((state) => state.lastProcessedEventId >= target))
-            return;
-        if (pass === maxPasses - 1) {
-            throw budgetExhaustedError(maxPasses, target, states);
-        }
-    }
-}
-async function loadConsumerStates(db, consumerNames) {
-    return Promise.all(consumerNames.map(async (name) => {
-        const state = await getConsumerState(db, name);
-        if (!state) {
-            throw new Error(`drainEventConsumers: consumer "${name}" not registered or per-instance`);
-        }
-        return state;
-    }));
-}
-function budgetExhaustedError(maxPasses, target, states) {
-    const unfinished = states.filter((state) => state.lastProcessedEventId < target);
-    const lines = unfinished.map((state) => `  ${state.name}: lastProcessedEventId=${state.lastProcessedEventId} target=${target} ` +
-        `status=${state.status} attempts=${state.attempts} lastError=${state.lastError ?? "null"}`);
-    return new Error(`drainEventConsumers: budget of ${maxPasses} passes exhausted, consumers still behind target:\n` +
-        lines.join("\n"));
-}

package/dist/stack/drain-jobs.d.ts

@@ -1,22 +0,0 @@
-import type { DbConnection } from "../db/index.js";
-import type { JobRunner } from "../jobs/index.js";
-import { type EventDispatcher } from "../pipeline/index.js";
-export type JobFailureTracker = {
-    readonly onJobComplete: (jobName: string, jobId: string) => void;
-    readonly onJobFailed: (jobName: string, jobId: string, error: string) => void;
-    waitForActivity(): Promise<void>;
-    readonly failures: ReadonlyMap<string, {
-        readonly jobName: string;
-        readonly error: string;
-    }>;
-    clear(): void;
-};
-export declare function createJobFailureTracker(): JobFailureTracker;
-export type DrainJobsStack = {
-    readonly db: DbConnection;
-    readonly eventDispatcher?: EventDispatcher;
-    readonly jobRunner?: JobRunner;
-};
-export declare function drainJobs(stack: DrainJobsStack, tracker: JobFailureTracker, options?: {
-    readonly timeoutMs?: number;
-}): Promise<void>;

package/dist/stack/drain-jobs.js

@@ -1,141 +0,0 @@
-import { getEventsHighWaterMark } from "../event-store/index.js";
-import { getConsumerState } from "../pipeline/index.js";
-// Gap between idle-checks while waiting for a job hook to fire. Short enough
-// that a test never feels it, long enough that consecutive idle passes don't
-// hammer Postgres/Redis with pointless polling between hook-driven wakeups.
-const DRAIN_IDLE_POLL_MS = 25;
-// Two consecutive idle passes (not one) before declaring the stack drained —
-// a single "pending===0 and consumers caught up" pass can be a race: a job
-// hook fires and enqueues a follow-up between the countPendingJobs() read
-// and the consumer check of the SAME pass. A DRAIN_IDLE_POLL_MS wait sits
-// between every pass, including the first and second idle one, so an
-// enqueue that lands just after the first idle read still gets picked up
-// by the second pass instead of racing straight past it.
-const REQUIRED_IDLE_PASSES = 2;
-// Below the 15s per-test budget so a stuck drain reports what is open rather
-// than surfacing as a bare test timeout.
-const DEFAULT_DRAIN_TIMEOUT_MS = 10_000;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export function createJobFailureTracker() {
-    const failures = new Map();
-    let wake;
-    let armed;
-    function fire() {
-        wake?.();
-        armed = undefined;
-        wake = undefined;
-    }
-    return {
-        onJobComplete(_jobName, jobId) {
-            // A retry that eventually succeeds must not leave a stale failure
-            // behind from its earlier attempt(s).
-            failures.delete(jobId);
-            fire();
-        },
-        onJobFailed(jobName, jobId, error) {
-            failures.set(jobId, { jobName, error });
-            fire();
-        },
-        waitForActivity() {
-            armed ??= new Promise((resolve) => {
-                wake = resolve;
-            });
-            return armed;
-        },
-        failures,
-        clear() {
-            failures.clear();
-        },
-    };
-}
-// Diagnostic only: lets the deadline error name what was still open.
-async function describeLaggingConsumers(db, consumerNames) {
-    // skip: no shared consumers wired — nothing to catch up on.
-    if (consumerNames.length === 0)
-        return [];
-    const target = await getEventsHighWaterMark(db);
-    const lagging = [];
-    for (const name of consumerNames) {
-        const state = await getConsumerState(db, name);
-        if (state && state.lastProcessedEventId < target) {
-            lagging.push(`${name} (status=${state.status}, lastProcessedEventId=${state.lastProcessedEventId}, target=${target})`);
-        }
-    }
-    return lagging;
-}
-async function drainTimeoutError(db, consumerNames, timeoutMs, pending) {
-    const lagging = await describeLaggingConsumers(db, consumerNames);
-    return new Error(`drainJobs: not drained after ${timeoutMs}ms — pending jobs: ${pending}, ` +
-        `consumers behind: ${lagging.length === 0 ? "none" : lagging.join("; ")}`);
-}
-async function sharedConsumersCaughtUp(db, consumerNames) {
-    // skip: no shared consumers wired — nothing to catch up on.
-    if (consumerNames.length === 0)
-        return true;
-    const target = await getEventsHighWaterMark(db);
-    let allCaughtUp = true;
-    for (const name of consumerNames) {
-        const state = await getConsumerState(db, name);
-        if (!state) {
-            throw new Error(`drainJobs: consumer "${name}" not registered or per-instance`);
-        }
-        if (state.status === "dead") {
-            throw new Error(`drainJobs: consumer "${state.name}" is dead — lastError: ${state.lastError ?? "unknown"}`);
-        }
-        if (state.lastProcessedEventId < target)
-            allCaughtUp = false;
-    }
-    return allCaughtUp;
-}
-// Fails a stuck drain with a diagnosis instead of a generic test-runner timeout.
-// It only bounds the loop; it never replaces waiting for real work.
-export async function drainJobs(stack, tracker, options) {
-    const { db, eventDispatcher, jobRunner } = stack;
-    const timeoutMs = options?.timeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
-    const deadline = Date.now() + timeoutMs;
-    if (!jobRunner) {
-        throw new Error("drainJobs: stack.jobRunner is undefined — pass `jobs: {...}` to setupTestStack and " +
-            "register at least one r.job(...) so a runner is built.");
-    }
-    const sharedConsumerNames = (eventDispatcher?.consumers ?? [])
-        .filter((consumer) => (consumer.delivery ?? "shared") === "shared")
-        .map((consumer) => consumer.name);
-    try {
-        try {
-            let consecutiveIdlePasses = 0;
-            while (consecutiveIdlePasses < REQUIRED_IDLE_PASSES) {
-                await eventDispatcher?.runOnce();
-                const pending = await jobRunner.countPendingJobs();
-                const caughtUp = await sharedConsumersCaughtUp(db, sharedConsumerNames);
-                consecutiveIdlePasses = pending === 0 && caughtUp ? consecutiveIdlePasses + 1 : 0;
-                if (consecutiveIdlePasses < REQUIRED_IDLE_PASSES) {
-                    if (Date.now() > deadline) {
-                        throw await drainTimeoutError(db, sharedConsumerNames, timeoutMs, pending);
-                    }
-                    await Promise.race([tracker.waitForActivity(), sleep(DRAIN_IDLE_POLL_MS)]);
-                }
-            }
-        }
-        catch (err) {
-            // A failed job often kills its consumer, so the drain error is only the follow-up symptom.
-            if (tracker.failures.size === 0)
-                throw err;
-            const message = err instanceof Error ? err.message : String(err);
-            throw new Error(`${message}; ${describeJobFailures(tracker)}`, { cause: err });
-        }
-        if (tracker.failures.size > 0) {
-            throw new Error(`drainJobs: ${describeJobFailures(tracker)}`);
-        }
-    }
-    finally {
-        tracker.clear();
-    }
-}
-function describeJobFailures(tracker) {
-    const details = [...tracker.failures.values()]
-        .map((failure) => `${failure.jobName}: ${failure.error}`)
-        .join("; ");
-    return `job(s) failed: ${details}`;
-}

package/dist/stack/event-collector.d.ts

@@ -1,9 +0,0 @@
-import type { SseEvent } from "../api/sse-broker.js";
-import type { SaveContext } from "../engine/types/index.js";
-export type EventCollector = {
-    readonly sse: SseEvent[];
-    readonly postSave: SaveContext[];
-    /** Clears all collected events — call in beforeEach for per-test isolation */
-    reset(): void;
-};
-export declare function createEventCollector(): EventCollector;

package/dist/stack/event-collector.js

@@ -1,12 +0,0 @@
-export function createEventCollector() {
-    const sse = [];
-    const postSave = [];
-    return {
-        sse,
-        postSave,
-        reset() {
-            sse.length = 0;
-            postSave.length = 0;
-        },
-    };
-}

package/dist/stack/push-entity-projection-tables.d.ts

@@ -1,24 +0,0 @@
-import type { DbConnection } from "../db/connection.js";
-import type { Registry } from "../engine/types/index.js";
-type DbHolder = {
-    readonly db: DbConnection;
-};
-/**
- * Push all implicit-projection tables — one per `r.entity()` — that the
- * registry knows about. setupTestStack already handles explicit
- * projections, MSPs, and `r.storeTable()` declarations in its own loop;
- * implicit projections are the missing piece for a fresh boot.
- *
- * Idempotent via `tableExists` so a persistent dev DB
- * (`KUMIKO_DEV_DB_NAME`) reuses existing tables on reboot. One batched
- * push at the end so drizzle-kit's `generateMigration` runs once over
- * the whole missing set.
- *
- * Lives next to `setupTestStack` because both are stack-bootstrap
- * helpers that legitimately speak the `unsafe*`-DDL layer; the
- * Table-DDL Guard's stack/** allowlist is the single shared exemption
- * site. Apps still declare data via `r.entity()` / `r.storeTable()` and
- * never call this directly.
- */
-export declare function pushEntityProjectionTables(stack: DbHolder, registry: Registry): Promise<void>;
-export {};

package/dist/stack/push-entity-projection-tables.js

@@ -1,74 +0,0 @@
-import { columnNamesOf, tableExists } from "../db/schema-inspection.js";
-import { schemaTableName } from "../db/table-introspection.js";
-import { addMissingColumns, addMissingIndexes, tableToMeta, unsafePushTables, } from "./table-helpers.js";
-// biome-ignore lint/suspicious/noConsole: stack-internal status logging
-const logInfo = (msg) => console.log(msg);
-/**
- * Push all implicit-projection tables — one per `r.entity()` — that the
- * registry knows about. setupTestStack already handles explicit
- * projections, MSPs, and `r.storeTable()` declarations in its own loop;
- * implicit projections are the missing piece for a fresh boot.
- *
- * Idempotent via `tableExists` so a persistent dev DB
- * (`KUMIKO_DEV_DB_NAME`) reuses existing tables on reboot. One batched
- * push at the end so drizzle-kit's `generateMigration` runs once over
- * the whole missing set.
- *
- * Lives next to `setupTestStack` because both are stack-bootstrap
- * helpers that legitimately speak the `unsafe*`-DDL layer; the
- * Table-DDL Guard's stack/** allowlist is the single shared exemption
- * site. Apps still declare data via `r.entity()` / `r.storeTable()` and
- * never call this directly.
- */
-export async function pushEntityProjectionTables(stack, registry) {
-    const seen = new Set();
-    const missing = {};
-    for (const [projName, proj] of registry.getAllProjections()) {
-        if (!proj.isImplicit)
-            continue;
-        if (seen.has(proj.table))
-            continue;
-        seen.add(proj.table);
-        const physical = schemaTableName(proj.table) ?? tableToMeta(proj.table).tableName;
-        if (!(await tableExists(stack.db, `public.${physical}`))) {
-            missing[projName] = proj.table;
-            continue;
-        }
-        await syncExistingProjectionTable(stack, physical, proj.table);
-    }
-    if (Object.keys(missing).length > 0) {
-        await unsafePushTables(stack.db, missing);
-    }
-}
-function isUnsafeToAutoAdd(col) {
-    return col.notNull && !col.primaryKey && col.defaultSql === undefined;
-}
-// Backfills columns and indexes a persistent dev DB predates; a required column with no
-// default can't be added safely on a table that may hold rows, so that
-// stays a boot error instead.
-async function syncExistingProjectionTable(stack, physical, table) {
-    const meta = tableToMeta(table);
-    const liveColumns = await columnNamesOf(stack.db, physical);
-    const missingColumns = meta.columns.filter((c) => !liveColumns.has(c.name));
-    if (missingColumns.length === 0) {
-        logInfo(`[kumiko-stack] table ${physical} already exists — skipping create`);
-        await addMissingIndexes(stack.db, physical, meta.indexes);
-        // skip: table is already in sync, only indexes needed backfilling
-        return;
-    }
-    const unsafeColumns = missingColumns.filter(isUnsafeToAutoAdd);
-    if (unsafeColumns.length > 0) {
-        const devDbName = process.env["KUMIKO_DEV_DB_NAME"] ?? "<KUMIKO_DEV_DB_NAME>";
-        throw new Error(`[kumiko-stack] table "${physical}" is missing required column(s) ` +
-            `${unsafeColumns.map((c) => `"${c.name}"`).join(", ")} with no default. ` +
-            "Auto-sync only backfills nullable columns or columns with a default on an " +
-            "existing dev DB — a required column with no default can't be added safely " +
-            `once the table may hold rows. Drop the persistent dev database "${devDbName}" ` +
-            `(e.g. \`dropdb ${devDbName}\`, adjusted for your local Postgres host/port/user) ` +
-            "so the next boot recreates it from scratch.");
-    }
-    logInfo(`[kumiko-stack] table ${physical} is missing column(s) ` +
-        `${missingColumns.map((c) => `"${c.name}"`).join(", ")} — adding`);
-    await addMissingColumns(stack.db, physical, missingColumns);
-    await addMissingIndexes(stack.db, physical, meta.indexes);
-}

package/dist/stack/redis.d.ts

@@ -1,17 +0,0 @@
-export type TestRedis = {
-    redis: import("ioredis").Redis;
-    redisUrl: string;
-    /** The per-test `keyPrefix` on `redis`, e.g. `kt:1a2b3c4d:`. */
-    keyPrefix: string;
-    /** Delete every key this test created (prefix-scoped). Replaces the old
-     *  `redis.flushdb()` — that wiped other parallel tests' BullMQ state. */
-    flushNamespace: () => Promise<void>;
-    cleanup: () => Promise<void>;
-};
-export declare function queueNamePrefixForTestRedis(keyPrefix: string): string;
-export type CreateTestRedisOptions = {
-    /** Reuse another stack's keyPrefix on a fresh connection. cleanup() then only
-     *  disconnects — the owning stack flushes the namespace and its queues. */
-    readonly borrowKeyPrefix?: string;
-};
-export declare function createTestRedis(opts?: CreateTestRedisOptions): Promise<TestRedis>;

package/dist/stack/redis.js

@@ -1,52 +0,0 @@
-import { generateId } from "../utils/index.js";
-import { requireEnv } from "./db.js";
-// BullMQ queues live on the raw redisUrl, outside the test Redis keyPrefix, so
-// parallel stacks sharing the prod default queue name would consume each
-// other's jobs. BullMQ rejects `:` in queue names.
-export function queueNamePrefixForTestRedis(keyPrefix) {
-    return keyPrefix.split(":").filter(Boolean).join("-");
-}
-export async function createTestRedis(opts = {}) {
-    const Redis = (await import("ioredis")).Redis;
-    const redisUrl = requireEnv("REDIS_URL");
-    // Every test gets a per-file key prefix on a shared DB (no DB-pool-of-15
-    // round-robin). Collisions at birthday-paradox rates are gone — the
-    // prefix space is unbounded. See Track B.3 in docs/plans/tests-refactor.
-    const prefix = opts.borrowKeyPrefix ?? `kt:${generateId().slice(-8)}:`;
-    const redis = new Redis(redisUrl, { keyPrefix: prefix });
-    async function deleteKeysMatching(pattern) {
-        // Open a prefix-less client for the scan — ioredis' keyPrefix is applied
-        // per-command but SCAN's returned keys are full names, so managing the
-        // del set with the prefix already on the connection is error-prone.
-        const raw = new Redis(redisUrl);
-        try {
-            const stream = raw.scanStream({ match: pattern, count: 500 });
-            const keys = [];
-            for await (const batch of stream)
-                keys.push(...batch);
-            if (keys.length > 0)
-                await raw.del(...keys);
-        }
-        finally {
-            raw.disconnect();
-        }
-    }
-    const flushNamespace = () => deleteKeysMatching(`${prefix}*`);
-    return {
-        redis,
-        redisUrl,
-        keyPrefix: prefix,
-        flushNamespace,
-        cleanup: async () => {
-            if (opts.borrowKeyPrefix !== undefined) {
-                redis.disconnect();
-                // skip: the owning stack flushes the shared namespace and its queues
-                return;
-            }
-            await flushNamespace();
-            // The derived per-stack JobRunner queues sit outside the keyPrefix.
-            await deleteKeysMatching(`bull:${queueNamePrefixForTestRedis(prefix)}-*`);
-            redis.disconnect();
-        },
-    };
-}