@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

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

@@ -1,292 +0,0 @@
-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,
-  createTenantConfig,
-  createTextField,
-  createUserConfig,
-  SYSTEM_TENANT_ID,
-} from "../../engine";
-import type { ConfigSeedDef, Registry } from "../../engine/types";
-import { createEnvMasterKeyProvider } from "../../secrets/env-master-key-provider";
-import { createEnvelopeCipher } from "../../secrets/envelope-cipher";
-import { unsafeCreateEntityTable } from "../../stack";
-import { ensureTemporalPolyfill } from "../../time/polyfill";
-import { seedConfigValues } from "../config-seed";
-import { buildEntityTable } from "../table-builder";
-
-// --- Test Entity ---
-// Mirrors the config-value entity from bundled-features with a unique
-// table name so it never collides with the real config table.
-const configEntity = createEntity({
-  table: "read_cfg_seed_test",
-  fields: {
-    key: createTextField({ required: true, personal: false, reason: "test_fixture" }),
-    value: createTextField({ personal: false, reason: "test_fixture" }),
-    userId: createTextField({ personal: false, reason: "test_fixture" }),
-  },
-  indexes: [
-    {
-      unique: true,
-      columns: ["key", "tenantId", "userId"],
-      name: "cfg_seed_test_unique",
-    },
-  ],
-});
-const configTable = buildEntityTable("cfgSeedTest", configEntity);
-
-// --- Registry Stub ---
-const KEY_DEFS = {
-  "test:config:service-url": createSystemConfig("text", {
-    default: "https://default.example.com",
-  }),
-  "test:config:max-upload": createTenantConfig("number", { default: 10 }),
-  "test:config:stripe-key": createTenantConfig("text", { encrypted: true }),
-  "test:config:theme": createUserConfig("text", { default: "blue" }),
-};
-
-const mockRegistry = {
-  getConfigKey: (key: string) => KEY_DEFS[key as keyof typeof KEY_DEFS] ?? undefined,
-} as unknown as Registry;
-
-// --- Helpers ---
-const encryption = createEnvelopeCipher(
-  createEnvMasterKeyProvider({
-    env: {
-      KUMIKO_SECRETS_MASTER_KEY_CURRENT_VERSION: "1",
-      KUMIKO_SECRETS_MASTER_KEY_V1: Buffer.from("0123456789abcdef0123456789abcdef").toString(
-        "base64",
-      ),
-    },
-  }),
-);
-
-let testDb: BunTestDb;
-
-async function countRows(): Promise<number> {
-  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 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");
-});
-
-afterAll(async () => {
-  await testDb.cleanup();
-});
-
-beforeEach(async () => {
-  await asRawClient(testDb.db).unsafe(
-    `TRUNCATE kumiko_events, read_cfg_seed_test RESTART IDENTITY CASCADE`,
-  );
-});
-
-// --- Tests ---
-
-describe("seedConfigValues", () => {
-  test("inserts initial seeds — creates rows + events", async () => {
-    const TENANT_A = "22222222-2222-4222-8222-222222222222";
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:service-url", value: "https://prod.example.com", scope: "system" },
-      { key: "test:config:max-upload", value: 50, scope: "tenant" },
-      {
-        key: "test:config:theme",
-        value: "dark",
-        scope: "user",
-        tenantId: TENANT_A,
-        userId: "u-123",
-      },
-    ];
-
-    const result = await seedConfigValues(
-      seeds,
-      configTable,
-      configEntity,
-      mockRegistry,
-      testDb.db,
-    );
-
-    expect(result.created).toBe(3);
-    expect(result.skipped).toBe(0);
-    expect(await countRows()).toBe(3);
-    expect(await countEvents()).toBe(3);
-  });
-
-  test("idempotent re-run — all skipped", async () => {
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:service-url", value: "https://prod.example.com", scope: "system" },
-    ];
-
-    const first = await seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db);
-    expect(first).toEqual({ created: 1, skipped: 0 });
-
-    const second = await seedConfigValues(
-      seeds,
-      configTable,
-      configEntity,
-      mockRegistry,
-      testDb.db,
-    );
-    expect(second).toEqual({ created: 0, skipped: 1 });
-  });
-
-  test("insert-only — value change ignored on re-boot", async () => {
-    const seeds: ConfigSeedDef[] = [{ key: "test:config:max-upload", value: 10, scope: "tenant" }];
-
-    await seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db);
-
-    const seedsChanged: ConfigSeedDef[] = [
-      { key: "test:config:max-upload", value: 999, scope: "tenant" },
-    ];
-    const result = await seedConfigValues(
-      seedsChanged,
-      configTable,
-      configEntity,
-      mockRegistry,
-      testDb.db,
-    );
-    expect(result).toEqual({ created: 0, skipped: 1 });
-
-    // Old value persists
-    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);
-  });
-
-  test("scope mapping — system/tenant under SYSTEM_TENANT_ID, user under real tenantId", async () => {
-    const TENANT_A = "11111111-1111-4111-8111-111111111111";
-
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:service-url", value: "x", scope: "system" },
-      { key: "test:config:max-upload", value: 20, scope: "tenant" },
-      { key: "test:config:theme", value: "dark", scope: "user", tenantId: TENANT_A, userId: "u-1" },
-    ];
-
-    await seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db);
-
-    const rows = await asRawClient(testDb.db).unsafe<{
-      key: string;
-      tenantId: string | null;
-      userId: string | null;
-    }>(
-      `SELECT key, tenant_id AS "tenantId", user_id AS "userId" FROM read_cfg_seed_test ORDER BY key`,
-    );
-
-    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(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");
-  });
-
-  test("user-scope seed without tenantId throws (would be unreachable)", async () => {
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:theme", value: "dark", scope: "user", userId: "u-1" },
-    ];
-
-    await expect(
-      seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db),
-    ).rejects.toThrow(/user-scope seed.*requires both tenantId and userId/);
-  });
-
-  test("encrypted seed without EncryptionProvider throws — fail loud at boot", async () => {
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:stripe-key", value: "sk_live_xxx", scope: "tenant" },
-    ];
-
-    await expect(
-      seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db),
-    ).rejects.toThrow(/encrypted but no EnvelopeCipher/);
-  });
-
-  test("encrypted seed with provider stores ciphertext, not plaintext", async () => {
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:stripe-key", value: "sk_live_secret_token", scope: "tenant" },
-    ];
-
-    const result = await seedConfigValues(
-      seeds,
-      configTable,
-      configEntity,
-      mockRegistry,
-      testDb.db,
-      encryption,
-    );
-    expect(result).toEqual({ created: 1, skipped: 0 });
-
-    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
-    // resolver later runs `decrypt → JSON.parse` to get the primitive
-    // back; we replay the same round-trip here.
-    expect(row!.value).not.toContain("sk_live_secret_token");
-    expect(JSON.parse(await encryption.decrypt(row!.value))).toBe("sk_live_secret_token");
-  });
-
-  test("race-safe parallel boot — two concurrent calls result in 1 created + 1 skipped", async () => {
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:service-url", value: "race-target", scope: "system" },
-    ];
-
-    const [a, b] = await Promise.all([
-      seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db),
-      seedConfigValues(seeds, configTable, configEntity, mockRegistry, testDb.db),
-    ]);
-
-    const totalCreated = (a.created ?? 0) + (b.created ?? 0);
-    const totalSkipped = (a.skipped ?? 0) + (b.skipped ?? 0);
-    expect(totalCreated).toBe(1);
-    expect(totalSkipped).toBe(1);
-    expect(await countRows()).toBe(1);
-  });
-
-  test("unknown key — skipped gracefully", async () => {
-    const seeds: ConfigSeedDef[] = [
-      { key: "test:config:nonexistent", value: "nope", scope: "tenant" },
-    ];
-
-    const result = await seedConfigValues(
-      seeds,
-      configTable,
-      configEntity,
-      mockRegistry,
-      testDb.db,
-    );
-
-    expect(result).toEqual({ created: 0, skipped: 1 });
-    expect(await countRows()).toBe(0);
-  });
-
-  test("empty seeds returns 0/0", async () => {
-    const result = await seedConfigValues([], configTable, configEntity, mockRegistry, testDb.db);
-    expect(result).toEqual({ created: 0, skipped: 0 });
-  });
-});

package/src/db/__tests__/connection-close-outage.integration.test.ts

@@ -1,110 +0,0 @@
-// A DB outage must not turn process shutdown into a hang: postgres.js keeps
-// an in-flight query referenced on a dead socket, so a plain end() (no
-// timeout = wait for queries to finish) never resolves once the DB is gone.
-// close() has to bound that wait (db/api.ts's closeTimeoutSeconds). Routes
-// createDbConnection through a TCP proxy that stops forwarding bytes after
-// connect ("blackhole") — same simulated-outage approach as
-// pipeline/__tests__/event-dispatcher-db-outage.integration.test.ts, but
-// without touching the shared test DB's actual availability.
-
-import { afterAll, describe, expect, test } from "bun:test";
-import net from "node:net";
-import { waitFor } from "../../testing";
-import { testDatabaseUrl } from "../../testing/closed-connection-error";
-import { createDbConnection } from "../connection";
-
-function startBlackholeProxy(dbUrl: URL): {
-  readonly server: net.Server;
-  blackhole: () => void;
-  swallowedBytes: () => number;
-  destroy: () => void;
-} {
-  let blackholed = false;
-  let swallowed = 0;
-  const sockets = new Set<net.Socket>();
-  const server = net.createServer((downstream) => {
-    sockets.add(downstream);
-    const upstream = net.connect(Number(dbUrl.port), dbUrl.hostname);
-    sockets.add(upstream);
-    downstream.on("data", (chunk: Buffer) => {
-      if (blackholed) {
-        swallowed += chunk.length;
-        return;
-      }
-      upstream.write(chunk);
-    });
-    upstream.on("data", (chunk: Buffer) => {
-      if (!blackholed) downstream.write(chunk);
-    });
-    downstream.on("error", () => {});
-    upstream.on("error", () => {});
-    downstream.on("close", () => sockets.delete(downstream));
-    upstream.on("close", () => sockets.delete(upstream));
-  });
-  return {
-    server,
-    blackhole: () => {
-      blackholed = true;
-    },
-    swallowedBytes: () => swallowed,
-    destroy: () => {
-      for (const socket of sockets) socket.destroy();
-      server.close();
-    },
-  };
-}
-
-async function listenOn(server: net.Server, port: number): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(port, resolve);
-  });
-}
-
-let proxy: ReturnType<typeof startBlackholeProxy>;
-
-afterAll(() => {
-  proxy?.destroy();
-});
-
-describe("createDbConnection close() bounds shutdown during a DB outage", () => {
-  test("close() resolves within the bounded timeout even with in-flight queries on a dead socket", async () => {
-    const dbUrl = new URL(testDatabaseUrl());
-    proxy = startBlackholeProxy(dbUrl);
-    await listenOn(proxy.server, 0);
-    const address = proxy.server.address();
-    if (address === null || typeof address === "string") {
-      throw new Error("proxy did not bind to a TCP port");
-    }
-
-    const proxiedUrl = new URL(dbUrl.toString());
-    proxiedUrl.hostname = "127.0.0.1";
-    proxiedUrl.port = String(address.port);
-
-    const conn = createDbConnection(proxiedUrl.toString(), {
-      maxConnections: 1,
-      closeTimeoutSeconds: 1,
-    });
-
-    // Establish the connection while the proxy still forwards normally —
-    // isolates the assertion to close()'s own timeout, not connect_timeout.
-    await conn.client.unsafe("select 1");
-
-    // Fired without awaiting: once the socket goes dead, end() has to
-    // reject these instead of waiting on them forever. .catch prevents an
-    // unhandled rejection when end() tears the connection down.
-    const inFlightBeforeBlackhole = conn.client.unsafe("select 1").catch(() => undefined);
-    proxy.blackhole();
-    const inFlightAfterBlackhole = conn.client.unsafe("select 1").catch(() => undefined);
-
-    await waitFor(() => proxy.swallowedBytes() > 0);
-
-    const start = Date.now();
-    await conn.close();
-    const elapsed = Date.now() - start;
-
-    expect(elapsed).toBeLessThan(3000);
-
-    await Promise.all([inFlightBeforeBlackhole, inFlightAfterBlackhole]);
-  });
-});

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

@@ -1,68 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { dbConnectionOptionsFromEnv } from "../connection";
-
-// createDbConnection itself opens a real postgres.js socket, so it's
-// exercised in the DB-integration suite. The env-parsing + validation
-// logic is pure and worth pinning as a unit — misconfig at boot is the
-// whole point of parsing strictly.
-
-describe("dbConnectionOptionsFromEnv", () => {
-  test("empty env → empty options (falls back to postgres.js defaults)", () => {
-    expect(dbConnectionOptionsFromEnv({})).toEqual({});
-  });
-
-  test("reads all three supported keys", () => {
-    const opts = dbConnectionOptionsFromEnv({
-      DATABASE_POOL_MAX: "25",
-      DATABASE_POOL_IDLE_TIMEOUT: "60",
-      DATABASE_POOL_CONNECT_TIMEOUT: "5",
-    });
-    expect(opts).toEqual({
-      maxConnections: 25,
-      idleTimeoutSeconds: 60,
-      connectTimeoutSeconds: 5,
-    });
-  });
-
-  test("empty string is treated as unset", () => {
-    const opts = dbConnectionOptionsFromEnv({
-      DATABASE_POOL_MAX: "",
-      DATABASE_POOL_IDLE_TIMEOUT: "30",
-    });
-    expect(opts).toEqual({ idleTimeoutSeconds: 30 });
-  });
-
-  test("zero is allowed (idle_timeout=0 disables idle eviction in postgres.js)", () => {
-    const opts = dbConnectionOptionsFromEnv({
-      DATABASE_POOL_IDLE_TIMEOUT: "0",
-    });
-    expect(opts).toEqual({ idleTimeoutSeconds: 0 });
-  });
-
-  test("negative number → throws (misconfig catches at boot)", () => {
-    expect(() => dbConnectionOptionsFromEnv({ DATABASE_POOL_MAX: "-5" })).toThrow(
-      /DATABASE_POOL_MAX="-5".*non-negative/i,
-    );
-  });
-
-  test("non-numeric → throws", () => {
-    expect(() => dbConnectionOptionsFromEnv({ DATABASE_POOL_CONNECT_TIMEOUT: "five" })).toThrow(
-      /DATABASE_POOL_CONNECT_TIMEOUT="five"/,
-    );
-  });
-
-  test("decimal → throws (postgres.js expects integer seconds)", () => {
-    expect(() => dbConnectionOptionsFromEnv({ DATABASE_POOL_IDLE_TIMEOUT: "1.5" })).toThrow(
-      /DATABASE_POOL_IDLE_TIMEOUT="1.5".*integer/i,
-    );
-  });
-
-  test("unrelated env vars are ignored", () => {
-    const opts = dbConnectionOptionsFromEnv({
-      HOME: "/home/user",
-      PATH: "/usr/bin",
-      DATABASE_POOL_MAX: "10",
-    });
-    expect(opts).toEqual({ maxConnections: 10 });
-  });
-});

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

@@ -1,42 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { decodeCursor, decodeKeysetCursor, encodeCursor, encodeKeysetCursor } from "../cursor";
-
-describe("encodeCursor / decodeCursor", () => {
-  test("round-trips string ids", () => {
-    const id = "0194a1b2-c3d4-7890-abcd-ef1234567890";
-    expect(decodeCursor(encodeCursor(id))).toBe(id);
-  });
-
-  test("round-trips numeric ids", () => {
-    expect(decodeCursor(encodeCursor(42))).toBe("42");
-  });
-
-  test("decodeCursor throws on empty payload", () => {
-    expect(() => decodeCursor(encodeCursor(""))).toThrow(/Invalid cursor/);
-  });
-});
-
-describe("encodeKeysetCursor / decodeKeysetCursor", () => {
-  test("round-trips a sort value alongside the id", () => {
-    const id = "0194a1b2-c3d4-7890-abcd-ef1234567890";
-    const decoded = decodeKeysetCursor(encodeKeysetCursor("2026-03-01", id));
-    expect(decoded).toEqual({ id, sortValue: "2026-03-01" });
-  });
-
-  test("round-trips a null sort value as null, not undefined", () => {
-    const id = "0194a1b2-c3d4-7890-abcd-ef1234567890";
-    const decoded = decodeKeysetCursor(encodeKeysetCursor(null, id));
-    expect(decoded.sortValue).toBeNull();
-  });
-
-  test("decodes a legacy id-only cursor with sortValue undefined", () => {
-    const decoded = decodeKeysetCursor(encodeCursor("abc-123"));
-    expect(decoded).toEqual({ id: "abc-123", sortValue: undefined });
-  });
-
-  test("treats a JSON payload that isn't a valid keyset cursor as a legacy id", () => {
-    const cursor = encodeCursor('{"nope":1}');
-    expect(() => decodeKeysetCursor(cursor)).not.toThrow();
-    expect(decodeKeysetCursor(cursor)).toEqual({ id: '{"nope":1}', sortValue: undefined });
-  });
-});

package/src/db/__tests__/decimal-field.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createDecimalField, createEntity } from "../../engine/factories";
-import { fieldToZod } from "../../engine/schema-builder";
-import { deriveEntityTableMeta } from "../entity-table-meta";
-import { coerceRow, extractTableInfo } from "../query";
-import { renderTableDdl } from "../render-ddl";
-import { buildEntityTable } from "../table-builder";
-
-// decimal field — Postgres numeric(precision, scale). A new framework
-// primitive (not a port), so these are correctness-of-the-primitive checks:
-// column mapping, DDL, the pg-string→number read codec, and the write-boundary
-// Zod bounds. The read codec is the load-bearing one — pg returns numeric as a
-// STRING, and a missed conversion feeds consumers a string that silently
-// breaks arithmetic.
-
-const entity = createEntity({
-  table: "read_decimal_probe",
-  fields: {
-    sum: createDecimalField({ precision: 14, scale: 2, required: true }),
-    interest: createDecimalField({ precision: 6, scale: 4, required: true }),
-    rate: createDecimalField({ precision: 12, scale: 2 }),
-  },
-});
-
-describe("decimal field — column + DDL", () => {
-  test("maps to numeric(precision,scale) with required→NOT NULL", () => {
-    const cols = new Map(
-      deriveEntityTableMeta("decimalProbe", entity).columns.map((c) => [c.name, c]),
-    );
-    expect(cols.get("sum")?.pgType).toBe("numeric(14,2)");
-    expect(cols.get("interest")?.pgType).toBe("numeric(6,4)");
-    expect(cols.get("rate")?.pgType).toBe("numeric(12,2)");
-    expect(cols.get("sum")?.notNull).toBe(true);
-    expect(cols.get("rate")?.notNull).toBe(false);
-  });
-
-  test("renders real numeric(p,s) DDL", () => {
-    const ddl = renderTableDdl(deriveEntityTableMeta("decimalProbe", entity)).join("\n");
-    expect(ddl).toContain('"interest" numeric(6,4) NOT NULL');
-    expect(ddl).toContain('"rate" numeric(12,2)');
-  });
-});
-
-describe("decimal field — read codec (pg numeric string → JS number)", () => {
-  const info = extractTableInfo(buildEntityTable("decimalProbe", entity));
-
-  test("parses numeric strings to exact numbers", () => {
-    // Record<string, unknown> so coerceRow's pass-through return type doesn't
-    // pin the keys to `string` — the runtime value is the coerced number.
-    const input: Record<string, unknown> = { sum: "1000.50", interest: "2.5000", rate: "5.83" };
-    const row = coerceRow(input, info);
-    expect(row["sum"]).toBe(1000.5);
-    expect(row["interest"]).toBe(2.5);
-    expect(row["rate"]).toBe(5.83);
-    expect(typeof row["rate"]).toBe("number");
-  });
-
-  test("null passes through untouched", () => {
-    expect(coerceRow({ rate: null }, info).rate).toBeNull();
-  });
-
-  test("already-number values are left as-is", () => {
-    expect(coerceRow({ interest: 2.5 }, info).interest).toBe(2.5);
-  });
-});
-
-describe("decimal field — write-boundary Zod bounds", () => {
-  const schema = fieldToZod(createDecimalField({ precision: 6, scale: 2 }), []);
-
-  test("accepts values within precision and scale", () => {
-    for (const v of [5.83, 2.5, 1000.5, -42.99, 0, 9999.99]) {
-      expect(schema.safeParse(v).success).toBe(true);
-    }
-  });
-
-  test("rejects more decimal places than scale", () => {
-    expect(schema.safeParse(1.234).success).toBe(false);
-  });
-
-  test("rejects values exceeding the precision−scale integer digits", () => {
-    // precision 6, scale 2 → at most 4 integer digits → |value| < 10000.
-    expect(schema.safeParse(10000).success).toBe(false);
-    expect(schema.safeParse(-10000).success).toBe(false);
-  });
-});
-
-describe("decimal field — factory", () => {
-  test("requires precision and scale, defaults to optional", () => {
-    const f = createDecimalField({ precision: 8, scale: 3 });
-    expect(f.type).toBe("decimal");
-    expect(f.precision).toBe(8);
-    expect(f.scale).toBe(3);
-    expect(f.required).toBe(false);
-  });
-});
-
-describe("known limitation: precision past 2^53 (same trade-off as bigInt number-mode)", () => {
-  test("a numeric string beyond Number.MAX_SAFE_INTEGER loses precision on read", () => {
-    const e = createEntity({
-      table: "read_decimal_big",
-      fields: { big: createDecimalField({ precision: 20, scale: 0 }) },
-    });
-    const info = extractTableInfo(buildEntityTable("decimalBig", e));
-    // 2^53 + 1 → surfaced as JS number rounds to 2^53. Documented, not a bug:
-    // keep precision − scale ≤ 15 to stay exact (see DecimalFieldDef doc).
-    const input: Record<string, unknown> = { big: "9007199254740993" };
-    expect(coerceRow(input, info)["big"]).toBe(2 ** 53);
-  });
-});

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

@@ -1,47 +0,0 @@
-// instant() customType ist der Backing-Type für sowohl `type: "timestamp"`
-// als auch (heute aliased) `type: "date"`. Caller-Code schickt aber zwei
-// verschiedene String-Formate: zod-validate für date akzeptiert nur
-// YYYY-MM-DD, zod-validate für timestamp akzeptiert ISO-datetime. toDriver
-// muss BEIDE Formate coercen können — der Mismatch hat einen 500
-// internal_error in samples/apps/showcase produziert (Showcase-seed
-// schickte YYYY-MM-DD via item:create → dialect.toDriver → Temporal.Instant
-// wirft "Cannot parse: 2026-04-10").
-//
-// Tests pinnen alle drei Pfade (string-iso, date-only-string, instant) +
-// die invalid-Probe (echte Garbage muss weiterhin throwen — kein silent
-// swallowing).
-
-import { describe, expect, test } from "bun:test";
-import { Temporal } from "temporal-polyfill";
-import { instantToDriver as toDriver } from "../dialect";
-
-describe("instant() customType — toDriver", () => {
-  test("ISO-datetime mit Z: durchgereicht", () => {
-    expect(toDriver("2026-04-10T13:45:00Z")).toBe("2026-04-10T13:45:00Z");
-  });
-
-  test("ISO-datetime mit Offset: normalisiert auf UTC-Z", () => {
-    // Temporal.Instant.from normalisiert +02:00 → Z mit korrekter Zeit.
-    expect(toDriver("2026-04-10T13:45:00+02:00")).toBe("2026-04-10T11:45:00Z");
-  });
-
-  test("YYYY-MM-DD: coerced auf start-of-day UTC", () => {
-    // Forgiving overload für type:"date" — Zod-Validation lässt nur
-    // YYYY-MM-DD durch, dialect normalisiert auf instant.
-    expect(toDriver("2026-04-10")).toBe("2026-04-10T00:00:00Z");
-  });
-
-  test("Temporal.Instant: durchgereicht über .toString()", () => {
-    expect(toDriver(Temporal.Instant.from("2026-04-10T13:45:00Z"))).toBe("2026-04-10T13:45:00Z");
-  });
-
-  test("Garbage-String: wirft RangeError (kein silent swallow)", () => {
-    expect(() => toDriver("not-a-date")).toThrow(/Cannot parse/);
-  });
-
-  test("Date-only mit Trailing-Whitespace: kein Match (strict regex)", () => {
-    // Strict damit "2026-04-10 extra" nicht silently zu start-of-day
-    // wird — das ist garantiert ein Caller-Bug, nicht "nett gemeint".
-    expect(() => toDriver("2026-04-10 ")).toThrow(/Cannot parse/);
-  });
-});