@humwick/server 0.130.1 → 0.130.2

package/node_modules/@humwick/kernel/sqlite-kernel-persistence.ts

@@ -1,499 +0,0 @@
-import type { Database } from "bun:sqlite";
-import type { Clock, Scope } from "./contract";
-import { reclaimDeadWorkflowLeases, type WorkflowLeaseOwnerProbe } from "./workflow-lease-owner";
-import { ensureEventLogSchema, type EmittedEvent, type EventReplaySlice } from "./event-log";
-import type {
-  KernelEntityCatalog,
-  KernelEntityListRead,
-  KernelEntityMutation,
-  KernelEntityPointRead,
-  KernelEntityStoredRow,
-  KernelJournalOnlyCommitEnvelope,
-  KernelModuleCatalog,
-  KernelOpCommitEnvelope,
-  KernelOpCommitResult,
-  KernelPersistence,
-  KernelStepCommitEnvelope,
-  KernelStoredValue,
-} from "./kernel-persistence";
-import {
-  MessageAuthorityCommitRefusedError,
-  type MessageAuthorityOperation,
-  type MessageAuthorityStore,
-} from "./message-authority";
-import { EntityConflictError } from "./persistence";
-import { quoteIdentifier, type StorageKind } from "./persistence-schema";
-import {
-  WorkflowContendedError,
-  WorkflowJournalPersistence,
-  isSqliteBusy,
-  type AcquireLeaseParams,
-  type ListInstancesOptions,
-  type RenewLeaseParams,
-  type WorkflowInstancePage,
-  type WorkflowInstanceRow,
-  type WorkflowInstanceSeed,
-  type WorkflowStepJournalRow,
-} from "./workflow-journal";
-import type { WorkflowStepCommitFaults } from "./workflow-step-commit";
-
-const EVENTS_TABLE = "kernel_events";
-const SEQ_TABLE = "kernel_event_scope_seq";
-// The table is the idempotency authority; these bounded maps are only a hot-result optimization.
-const DEDUP_TABLE = "kernel_compat_request_results";
-export const SQLITE_COMPAT_DEDUP_MAX_ENTRIES = 1_024;
-
-class BoundedResultMap<V> {
-  readonly #entries = new Map<string, V>();
-
-  get size(): number { return this.#entries.size; }
-  get(key: string): V | undefined {
-    const value = this.#entries.get(key);
-    if (value !== undefined) {
-      this.#entries.delete(key);
-      this.#entries.set(key, value);
-    }
-    return value;
-  }
-  set(key: string, value: V): void {
-    this.#entries.delete(key);
-    this.#entries.set(key, value);
-    while (this.#entries.size > SQLITE_COMPAT_DEDUP_MAX_ENTRIES) this.#entries.delete(this.#entries.keys().next().value!);
-  }
-}
-
-interface CompatibilityOpFaults {
-  readonly afterParticipantBeforeEntities?: () => void;
-  readonly betweenEntitiesAndEvents?: () => void;
-  readonly afterEventsBeforeWorkflowSeeds?: () => void;
-  readonly afterWorkflowSeedsBeforeCommit?: () => void;
-}
-
-const opFaults = new WeakMap<KernelPersistence, Map<string, CompatibilityOpFaults>>();
-const stepFaults = new WeakMap<KernelPersistence, Map<string, WorkflowStepCommitFaults>>();
-
-/** Private compatibility-only side channel for existing in-process chaos hooks. */
-export function armCompatibilityOpFaults(port: KernelPersistence, requestKey: string, faults: CompatibilityOpFaults): void {
-  const entries = opFaults.get(port) ?? new Map();
-  entries.set(requestKey, faults);
-  opFaults.set(port, entries);
-}
-
-/** Private compatibility-only side channel for existing in-process chaos hooks. */
-export function armCompatibilityStepFaults(port: KernelPersistence, requestKey: string, faults: WorkflowStepCommitFaults): void {
-  const entries = stepFaults.get(port) ?? new Map();
-  entries.set(requestKey, faults);
-  stepFaults.set(port, entries);
-}
-
-function sqlType(kind: StorageKind): string {
-  if (kind === "integer" || kind === "boolean" || kind === "date") return "INTEGER";
-  if (kind === "real") return "REAL";
-  return "TEXT";
-}
-
-function installEntity(db: Database, entity: KernelEntityCatalog): void {
-  const table = quoteIdentifier(entity.tableName);
-  const fields = entity.fields.map((field) => `${quoteIdentifier(field.name)} ${sqlType(field.kind)}${field.nullable ? "" : " NOT NULL"}`);
-  const references = Object.entries(entity.references).map(([field, ref]) =>
-    `FOREIGN KEY (scope, ${quoteIdentifier(field)}) REFERENCES ${quoteIdentifier(`kernel_entity__${ref.module}__${ref.entity}`)}`,
-  );
-  db.run(`CREATE TABLE IF NOT EXISTS ${table} (
-    scope TEXT NOT NULL,
-    ${fields.join(",\n    ")},
-    version INTEGER NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL,
-    PRIMARY KEY (scope, ${quoteIdentifier(entity.key)})${references.length ? `,\n    ${references.join(",\n    ")}` : ""}
-  )`);
-  const info = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string; type: string; notnull: number; pk: number }>;
-  for (const [name, type] of [["scope", "TEXT"], ["version", "INTEGER"], ["created_at", "INTEGER"], ["updated_at", "INTEGER"]] as const) {
-    const stored = info.find((row) => row.name === name);
-    if (!stored || stored.type.toUpperCase() !== type || stored.notnull !== 1) {
-      throw new Error(`entity table '${entity.tableName}' has incompatible kernel column '${name}'`);
-    }
-  }
-  const primaryKey = info.filter((row) => row.pk > 0).sort((a, b) => a.pk - b.pk).map((row) => row.name);
-  if (primaryKey.length !== 2 || primaryKey[0] !== "scope" || primaryKey[1] !== entity.key) {
-    throw new Error(`entity table '${entity.tableName}' must have primary key (scope, ${entity.key})`);
-  }
-  for (const field of entity.fields) {
-    const stored = info.find((row) => row.name === field.name);
-    if (!stored) {
-      if (!field.nullable) throw new Error(`cannot add required field '${field.name}' to existing entity table '${entity.tableName}'`);
-      db.run(`ALTER TABLE ${table} ADD COLUMN ${quoteIdentifier(field.name)} ${sqlType(field.kind)}`);
-    } else if (stored.type.toUpperCase() !== sqlType(field.kind)) {
-      throw new Error(`entity field '${entity.moduleId}.${entity.entityName}.${field.name}' changed SQLite type`);
-    }
-  }
-  entity.indexes.forEach((names, index) => db.run(
-    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(`${entity.tableName}__idx_${index}`)} ON ${table} (scope, ${names.map(quoteIdentifier).join(", ")})`,
-  ));
-}
-
-function columns(entity: KernelEntityCatalog): string {
-  return entity.fields.map((field) => quoteIdentifier(field.name)).join(", ");
-}
-
-function storedRow(entity: KernelEntityCatalog, row: Record<string, unknown> | null): KernelEntityStoredRow | undefined {
-  if (!row) return undefined;
-  return {
-    values: Object.fromEntries(entity.fields.map((field) => [field.name, row[field.name] as KernelStoredValue])),
-    version: row.version as number,
-    createdAt: row.created_at as number,
-    updatedAt: row.updated_at as number,
-  };
-}
-
-function applyAuthority(db: Database, store: MessageAuthorityStore | undefined, operations: readonly MessageAuthorityOperation[]): void {
-  for (const operation of operations) {
-    const result = store?.executeInTransaction(db, operation);
-    if (!result) throw new Error("MESSAGE authority participation is not configured on this host");
-    if (!result.ok) throw new MessageAuthorityCommitRefusedError(result, operation);
-  }
-}
-
-function applyEntities(db: Database, mutations: readonly KernelEntityMutation[], now: number): void {
-  for (const mutation of mutations) {
-    const table = quoteIdentifier(mutation.entity.tableName);
-    const key = quoteIdentifier(mutation.entity.key);
-    let changes: number;
-    if (mutation.kind === "delete") {
-      changes = db.query(`DELETE FROM ${table} WHERE scope = ? AND ${key} = ? AND version = ?`)
-        .run(mutation.scope, mutation.key, mutation.expectedVersion).changes;
-    } else if (mutation.expectedVersion === null) {
-      const names = mutation.entity.fields.map((field) => field.name);
-      const values = names.map((name) => mutation.values?.[name] ?? null);
-      changes = db.query(`INSERT INTO ${table} (scope, ${names.map(quoteIdentifier).join(", ")}, version, created_at, updated_at)
-        VALUES (?, ${names.map(() => "?").join(", ")}, 0, ?, ?) ON CONFLICT DO NOTHING`)
-        .run(mutation.scope, ...values, now, now).changes;
-    } else {
-      const names = mutation.entity.fields.map((field) => field.name);
-      changes = db.query(`UPDATE ${table} SET ${names.map((name) => `${quoteIdentifier(name)} = ?`).join(", ")}, version = version + 1, updated_at = ?
-        WHERE scope = ? AND ${key} = ? AND version = ?`).run(
-          ...names.map((name) => mutation.values?.[name] ?? null), now, mutation.scope, mutation.key, mutation.expectedVersion,
-        ).changes;
-    }
-    if (changes !== 1) throw new EntityConflictError(mutation.entity.moduleId, mutation.entity.entityName, mutation.logicalKey);
-  }
-}
-
-function appendEvents(db: Database, events: KernelOpCommitEnvelope["events"]): void {
-  if (events.length === 0) return;
-  const groups = new Map<Scope, typeof events>();
-  for (const event of events) groups.set(event.scope, [...(groups.get(event.scope) ?? []), event]);
-  for (const [scope, scoped] of groups) {
-    const bumped = db.query(`INSERT INTO ${SEQ_TABLE} (scope, high_water) VALUES (?, ?)
-      ON CONFLICT(scope) DO UPDATE SET high_water = high_water + excluded.high_water RETURNING high_water`)
-      .get(scope, scoped.length) as { high_water: number };
-    const first = bumped.high_water - scoped.length + 1;
-    scoped.forEach((event, index) => db.run(
-      `INSERT INTO ${EVENTS_TABLE} (scope, seq, module_id, name, payload, created_at) VALUES (?, ?, ?, ?, ?, ?)`,
-      [scope, first + index, event.moduleId, event.name, event.payload, event.createdAt],
-    ));
-  }
-}
-
-/** Private K0 adapter. Production src gateway registration replaces this in K1. */
-export class SqliteKernelPersistence implements KernelPersistence {
-  readonly #journal: WorkflowJournalPersistence;
-  readonly #opResults = new BoundedResultMap<KernelOpCommitResult>();
-  readonly #stepResults = new BoundedResultMap<number>();
-  readonly #writeResults = new BoundedResultMap<unknown>();
-  readonly messageAuthorityAvailable: boolean;
-
-  constructor(
-    readonly db: Database,
-    readonly clock: Clock,
-    readonly messageAuthority: MessageAuthorityStore | undefined,
-    /** `null`: a borrowed connection whose owner sets busy_timeout (see WorkflowJournalOptions). */
-    busyTimeoutMs?: number | null,
-    bootstrap = true,
-    readonly leaseOwnerProbe?: WorkflowLeaseOwnerProbe,
-  ) {
-    db.run("PRAGMA foreign_keys = ON");
-    const foreignKeys = db.query("PRAGMA foreign_keys").get() as { foreign_keys: number } | undefined;
-    if (foreignKeys?.foreign_keys !== 1) throw new Error("kernel SQLite compatibility adapter requires foreign keys to be enabled");
-    if (bootstrap) ensureEventLogSchema(db);
-    if (bootstrap) db.run(`CREATE TABLE IF NOT EXISTS ${DEDUP_TABLE} (
-      operation TEXT NOT NULL,
-      request_key TEXT NOT NULL,
-      result TEXT NOT NULL,
-      PRIMARY KEY (operation, request_key)
-    )`);
-    this.#journal = new WorkflowJournalPersistence({ db, clock, installSchema: bootstrap, ...(busyTimeoutMs !== undefined ? { busyTimeoutMs } : {}) });
-    this.messageAuthorityAvailable = messageAuthority !== undefined;
-  }
-
-  installModule(catalog: KernelModuleCatalog): Promise<void> {
-    this.installModuleSync(catalog);
-    return Promise.resolve();
-  }
-
-  installModuleSync(catalog: KernelModuleCatalog): void {
-    const install = () => {
-      for (const entity of catalog.entities) installEntity(this.db, entity);
-    };
-    if (this.db.inTransaction) install();
-    else this.db.transaction(install).immediate();
-  }
-
-  moduleTableExistsSync(tableName: string): boolean {
-    return this.db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName) != null;
-  }
-
-  entityPointSync(input: KernelEntityPointRead): KernelEntityStoredRow | undefined {
-    const row = this.db.query(`SELECT ${columns(input.entity)}, version, created_at, updated_at FROM ${quoteIdentifier(input.entity.tableName)}
-      WHERE scope = ? AND ${quoteIdentifier(input.entity.key)} = ?`).get(input.scope, input.key) as Record<string, unknown> | null;
-    return storedRow(input.entity, row);
-  }
-
-  entityListSync(input: KernelEntityListRead): readonly KernelEntityStoredRow[] {
-    const clauses = ["scope = ?"];
-    const bindings: KernelStoredValue[] = [input.scope];
-    for (const [name, value] of Object.entries(input.where)) {
-      clauses.push(value === null ? `${quoteIdentifier(name)} IS NULL` : `${quoteIdentifier(name)} = ?`);
-      if (value !== null) bindings.push(value);
-    }
-    if (input.after !== undefined) { clauses.push(`${quoteIdentifier(input.entity.key)} > ?`); bindings.push(input.after); }
-    const rows = this.db.query(`SELECT ${columns(input.entity)}, version, created_at, updated_at FROM ${quoteIdentifier(input.entity.tableName)}
-      WHERE ${clauses.join(" AND ")} ORDER BY ${quoteIdentifier(input.entity.key)} ASC LIMIT ?`)
-      .all(...bindings, input.limit) as Array<Record<string, unknown>>;
-    return rows.map((row) => storedRow(input.entity, row)!);
-  }
-
-  replayEventsSync(scope: Scope, since: number, limit: number, moduleId?: string): EventReplaySlice {
-    const pageSize = Math.min(Math.max(Math.trunc(limit), 1), 5_000);
-    const rows = (moduleId === undefined
-      ? this.db.query(`SELECT scope, seq, module_id, name, payload, created_at FROM ${EVENTS_TABLE} WHERE scope = ? AND seq > ? ORDER BY seq LIMIT ?`).all(scope, since, pageSize)
-      : this.db.query(`SELECT scope, seq, module_id, name, payload, created_at FROM ${EVENTS_TABLE} WHERE scope = ? AND module_id = ? AND seq > ? ORDER BY seq LIMIT ?`).all(scope, moduleId, since, pageSize)) as Array<Record<string, unknown>>;
-    const events = rows.map((row) => ({ scope: row.scope as Scope, seq: row.seq as number, moduleId: row.module_id as string, name: row.name as EmittedEvent["name"], payload: JSON.parse(row.payload as string), createdAt: row.created_at as number }));
-    const lastSeq = events.at(-1)?.seq ?? since;
-    const more = moduleId === undefined
-      ? this.eventHighWaterSync(scope) > lastSeq
-      : this.db.query(`SELECT 1 FROM ${EVENTS_TABLE} WHERE scope = ? AND module_id = ? AND seq > ? LIMIT 1`).get(scope, moduleId, lastSeq) != null;
-    return { events, lastSeq, truncated: rows.length === pageSize && more };
-  }
-
-  eventHighWaterSync(scope: Scope): number {
-    return (this.db.query(`SELECT high_water FROM ${SEQ_TABLE} WHERE scope = ?`).get(scope) as { high_water: number } | undefined)?.high_water ?? 0;
-  }
-
-  eventHasMatchSync(scope: Scope, topic: string, correlationId?: string): boolean {
-    let since = 0;
-    for (;;) {
-      const page = this.replayEventsSync(scope, since, 5_000);
-      if (page.events.some((event) => event.name === topic && (correlationId === undefined || (event.payload as { correlationId?: unknown } | null)?.correlationId === correlationId))) return true;
-      if (!page.truncated) return false;
-      since = page.lastSeq;
-    }
-  }
-
-  getWorkflowInstanceSync(id: string) { return this.#journal.getInstance(id); }
-  getWorkflowInstanceByIdentitySync(moduleName: string, workflowName: string, idempotencyKey: string) { return this.#journal.getInstanceByIdentity(moduleName, workflowName, idempotencyKey); }
-  listWorkflowInstancesSync(options?: ListInstancesOptions): WorkflowInstancePage { return this.#journal.listInstances(options); }
-  listWorkflowStepsSync(instanceId: string): WorkflowStepJournalRow[] { return this.#journal.listSteps(instanceId); }
-  listResumableWorkflowsSync(moduleName: string, now: number) { return this.#journal.listResumable(moduleName, now); }
-  listDueWorkflowsSync(moduleName: string, now: number) { return this.#journal.listDueSleepers(moduleName, now); }
-  listWaitingWorkflowsSync(moduleName: string, now: number) { return this.#journal.listWaiters(moduleName, now); }
-  snapshotWorkflowResidualSync(moduleName: string, now: number) { return this.#journal.snapshotReconcileResidual(moduleName, now); }
-  seedWorkflowSync(requestKey: string, seed: WorkflowInstanceSeed, capturedAt: number) {
-    return this.#cachedWrite(requestKey, "seedWorkflow", () => this.#journal.createInstanceIfAbsent(seed, capturedAt));
-  }
-  acquireWorkflowLeaseSync(requestKey: string, params: AcquireLeaseParams) {
-    return this.#cachedWrite(requestKey, "acquireLease", () => this.#journal.acquireLease(params), params.instanceId);
-  }
-  reclaimDeadWorkflowLeasesSync(moduleName: string, now: number): void {
-    reclaimDeadWorkflowLeases(this.db, moduleName, now, this.leaseOwnerProbe);
-  }
-  renewWorkflowLeaseSync(requestKey: string, params: RenewLeaseParams) {
-    return this.#cachedWrite(requestKey, "renewLease", () => this.#journal.renewLease(params), params.instanceId);
-  }
-  releaseWorkflowLeaseSync(requestKey: string, instanceId: string, token: string, now: number) {
-    try {
-      return this.#cachedWrite(requestKey, "releaseWorkflowLease", () => this.#journal.releaseLease(instanceId, token, now));
-    } catch (error) {
-      if (isSqliteBusy(error)) return false;
-      throw error;
-    }
-  }
-  controlWorkflowSync(requestKey: string, operation: "cancel" | "pause" | "resume" | "reopen" | "fail", id: string, now: number, failure?: unknown) {
-    return this.#cachedWrite(requestKey, `controlWorkflow:${operation}`, () => {
-      if (operation === "cancel") return this.#journal.cancelInstance(id, now);
-      if (operation === "pause") return this.#journal.pauseInstance(id, now);
-      if (operation === "resume") return this.#journal.resumeInstance(id, now);
-      if (operation === "reopen") return this.#journal.reopenInstance(id, now);
-      return this.#journal.failInstance(id, failure as never, now);
-    });
-  }
-
-  opCommitSync(envelope: KernelOpCommitEnvelope): KernelOpCommitResult {
-    const operation = "opCommit";
-    const cacheKey = this.#cacheKey(operation, envelope.requestKey);
-    const prior = this.#knownResult(this.#opResults, operation, envelope.requestKey);
-    if (prior) return prior;
-    const faults = opFaults.get(this)?.get(envelope.requestKey);
-    const result = this.db.transaction(() => {
-      const durable = this.#durableResult<KernelOpCommitResult>(operation, envelope.requestKey);
-      if (durable !== undefined) return durable;
-      const workflowInstanceIds: string[] = [];
-      applyAuthority(this.db, this.messageAuthority, envelope.messageAuthority);
-      faults?.afterParticipantBeforeEntities?.();
-      applyEntities(this.db, envelope.entities, envelope.capturedAt);
-      faults?.betweenEntitiesAndEvents?.();
-      appendEvents(this.db, envelope.events);
-      faults?.afterEventsBeforeWorkflowSeeds?.();
-      for (const item of envelope.workflowSeeds) workflowInstanceIds[item.resultIndex] = this.#journal.createInstanceIfAbsent(item.seed, envelope.capturedAt).instance.id;
-      for (const control of envelope.workflowControls ?? []) {
-        const changed = control.operation === "cancel"
-          ? this.#journal.cancelInstance(control.instanceId, envelope.capturedAt)
-          : control.operation === "reopen"
-            ? this.#journal.reopenInstance(control.instanceId, envelope.capturedAt)
-            : this.#journal.failInstance(control.instanceId, control.failure ?? { code: "landing_controlled_failure" }, envelope.capturedAt);
-        if (!changed) {
-          throw new Error(`workflow control '${control.operation}' refused for instance '${control.instanceId}'`);
-        }
-      }
-      faults?.afterWorkflowSeedsBeforeCommit?.();
-      const committed = Object.freeze({ workflowInstanceIds: Object.freeze(workflowInstanceIds) });
-      this.#storeDurableResult(operation, envelope.requestKey, committed);
-      return committed;
-    }).immediate();
-    this.#opResults.set(cacheKey, result);
-    opFaults.get(this)?.delete(envelope.requestKey);
-    return result;
-  }
-
-  stepCommitSync(envelope: KernelStepCommitEnvelope): number {
-    const faults = stepFaults.get(this)?.get(envelope.requestKey);
-    const result = this.#commitStep(envelope.requestKey, envelope.lease.instanceId, "stepCommit", faults?.beforeCommit, () => {
-      this.#journal.fenceLeaseInTransaction(envelope.lease.instanceId, envelope.lease.token, envelope.lease.now);
-      faults?.afterFenceBeforeParticipant?.();
-      applyAuthority(this.db, this.messageAuthority, envelope.messageAuthority);
-      faults?.afterParticipantBeforeEntities?.(); faults?.afterFenceBeforeEntities?.();
-      applyEntities(this.db, envelope.entities, envelope.capturedAt);
-      faults?.betweenEntitiesAndEvents?.();
-      appendEvents(this.db, envelope.events);
-      faults?.insideTxBeforeJournal?.();
-      const seq = this.#journal.recordStepInTransaction(envelope.record, envelope.capturedAt);
-      faults?.afterJournalBeforeCommit?.();
-      return seq;
-    });
-    faults?.afterCommit?.();
-    return result;
-  }
-
-  failedStepCommitSync(envelope: KernelJournalOnlyCommitEnvelope): number { return this.#journalCommit(envelope, "failedStepCommit"); }
-  supersededStepCommitSync(envelope: KernelJournalOnlyCommitEnvelope): number { return this.#journalCommit(envelope, "supersededStepCommit"); }
-
-  async seedWorkflow(requestKey: string, seed: WorkflowInstanceSeed, capturedAt: number) { return this.seedWorkflowSync(requestKey, seed, capturedAt); }
-  async acquireWorkflowLease(requestKey: string, params: AcquireLeaseParams) { return this.acquireWorkflowLeaseSync(requestKey, params); }
-  async reclaimDeadWorkflowLeases(moduleName: string, now: number) { this.reclaimDeadWorkflowLeasesSync(moduleName, now); }
-  async renewWorkflowLease(requestKey: string, params: RenewLeaseParams) { return this.renewWorkflowLeaseSync(requestKey, params); }
-  async releaseWorkflowLease(requestKey: string, instanceId: string, token: string, now: number) { return this.releaseWorkflowLeaseSync(requestKey, instanceId, token, now); }
-  async controlWorkflow(requestKey: string, operation: "cancel" | "pause" | "resume" | "reopen" | "fail", id: string, now: number, failure?: unknown) { return this.controlWorkflowSync(requestKey, operation, id, now, failure); }
-  async opCommit(envelope: KernelOpCommitEnvelope): Promise<KernelOpCommitResult> { return this.opCommitSync(envelope); }
-  async stepCommit(envelope: KernelStepCommitEnvelope): Promise<number> { return this.stepCommitSync(envelope); }
-  async failedStepCommit(envelope: KernelJournalOnlyCommitEnvelope): Promise<number> { return this.failedStepCommitSync(envelope); }
-  async supersededStepCommit(envelope: KernelJournalOnlyCommitEnvelope): Promise<number> { return this.supersededStepCommitSync(envelope); }
-
-  #journalCommit(envelope: KernelJournalOnlyCommitEnvelope, operation: string): number {
-    const faults = stepFaults.get(this)?.get(envelope.requestKey);
-    return this.#commitStep(envelope.requestKey, envelope.lease.instanceId, operation, faults?.beforeCommit, () => {
-      this.#journal.fenceLeaseInTransaction(envelope.lease.instanceId, envelope.lease.token, envelope.lease.now);
-      faults?.insideTxBeforeJournal?.();
-      const seq = this.#journal.recordStepInTransaction(envelope.record, envelope.capturedAt);
-      faults?.afterJournalBeforeCommit?.();
-      return seq;
-    });
-  }
-
-  #commitStep(requestKey: string, instanceId: string, operation: string, beforeWrite: (() => void) | undefined, write: () => number): number {
-    const cacheKey = this.#cacheKey(operation, requestKey);
-    const prior = this.#knownResult(this.#stepResults, operation, requestKey);
-    if (prior !== undefined) return prior;
-    try {
-      beforeWrite?.();
-      const result = this.db.transaction(() => {
-        const durable = this.#durableResult<number>(operation, requestKey);
-        if (durable !== undefined) return durable;
-        const committed = write();
-        this.#storeDurableResult(operation, requestKey, committed);
-        return committed;
-      }).immediate();
-      this.#stepResults.set(cacheKey, result);
-      stepFaults.get(this)?.delete(requestKey);
-      return result;
-    } catch (error) {
-      stepFaults.get(this)?.delete(requestKey);
-      if (isSqliteBusy(error)) throw new WorkflowContendedError(instanceId, operation, { cause: error });
-      throw error;
-    }
-  }
-
-  #cachedWrite<T>(requestKey: string, operation: string, write: () => T, contendedInstanceId?: string): T {
-    const cacheKey = this.#cacheKey(operation, requestKey);
-    const prior = this.#knownResult(this.#writeResults as BoundedResultMap<T>, operation, requestKey);
-    if (prior !== undefined) return prior;
-    try {
-      const result = this.db.transaction(() => {
-        const durable = this.#durableResult<T>(operation, requestKey);
-        if (durable !== undefined) return durable;
-        const committed = write();
-        this.#storeDurableResult(operation, requestKey, committed);
-        return committed;
-      }).immediate();
-      this.#writeResults.set(cacheKey, result);
-      return result;
-    } catch (error) {
-      if (contendedInstanceId !== undefined && isSqliteBusy(error)) {
-        throw new WorkflowContendedError(contendedInstanceId, operation, { cause: error });
-      }
-      throw error;
-    }
-  }
-
-  #cacheKey(operation: string, requestKey: string): string {
-    return `${operation}\0${requestKey}`;
-  }
-
-  #knownResult<T>(cache: BoundedResultMap<T>, operation: string, requestKey: string): T | undefined {
-    const cacheKey = this.#cacheKey(operation, requestKey);
-    const cached = cache.get(cacheKey) as T | undefined;
-    if (cached !== undefined) return cached;
-    const durable = this.#durableResult<T>(operation, requestKey);
-    if (durable !== undefined) cache.set(cacheKey, durable);
-    return durable;
-  }
-
-  #durableResult<T>(operation: string, requestKey: string): T | undefined {
-    const row = this.db.query(`SELECT result FROM ${DEDUP_TABLE} WHERE operation = ? AND request_key = ?`)
-      .get(operation, requestKey) as { result: string } | undefined;
-    return row == null ? undefined : JSON.parse(row.result) as T;
-  }
-
-  #storeDurableResult(operation: string, requestKey: string, result: unknown): void {
-    if (!this.db.inTransaction) throw new Error("kernel compatibility request result must be stored inside its writer transaction");
-    this.db.run(`INSERT INTO ${DEDUP_TABLE} (operation, request_key, result) VALUES (?, ?, ?)`, [operation, requestKey, JSON.stringify(result)]);
-  }
-
-  async moduleTableExists(tableName: string): Promise<boolean> { return this.moduleTableExistsSync(tableName); }
-  async entityPoint(input: KernelEntityPointRead): Promise<KernelEntityStoredRow | undefined> { return this.entityPointSync(input); }
-  async entityList(input: KernelEntityListRead): Promise<readonly KernelEntityStoredRow[]> { return this.entityListSync(input); }
-  async replayEvents(scope: Scope, since: number, limit: number, moduleId?: string): Promise<EventReplaySlice> { return this.replayEventsSync(scope, since, limit, moduleId); }
-  async eventHighWater(scope: Scope): Promise<number> { return this.eventHighWaterSync(scope); }
-  async eventHasMatch(scope: Scope, topic: string, correlationId?: string): Promise<boolean> { return this.eventHasMatchSync(scope, topic, correlationId); }
-  async getWorkflowInstance(id: string) { return this.getWorkflowInstanceSync(id); }
-  async getWorkflowInstanceByIdentity(moduleName: string, workflowName: string, idempotencyKey: string) { return this.getWorkflowInstanceByIdentitySync(moduleName, workflowName, idempotencyKey); }
-  async listWorkflowInstances(options?: ListInstancesOptions): Promise<WorkflowInstancePage> { return this.listWorkflowInstancesSync(options); }
-  async listWorkflowSteps(instanceId: string): Promise<WorkflowStepJournalRow[]> { return this.listWorkflowStepsSync(instanceId); }
-  async listResumableWorkflows(moduleName: string, now: number) { return this.listResumableWorkflowsSync(moduleName, now); }
-  async listDueWorkflows(moduleName: string, now: number) { return this.listDueWorkflowsSync(moduleName, now); }
-  async listWaitingWorkflows(moduleName: string, now: number) { return this.listWaitingWorkflowsSync(moduleName, now); }
-  async snapshotWorkflowResidual(moduleName: string, now: number) { return this.snapshotWorkflowResidualSync(moduleName, now); }
-
-  /** @internal Compatibility-adapter telemetry used to prove retry caches stay bounded. */
-  compatibilityDedupEntryCounts(): Readonly<{ op: number; step: number; write: number }> {
-    return { op: this.#opResults.size, step: this.#stepResults.size, write: this.#writeResults.size };
-  }
-}

package/node_modules/@humwick/kernel/sqlite-module-host.ts

@@ -1,87 +0,0 @@
-import type { Database } from "bun:sqlite";
-import { createRealClock } from "./effects";
-import type { EventSession } from "./event-log";
-import type { MessageAuthoritySession, MessageAuthorityStore } from "./message-authority";
-import { createModuleHost, type ModuleHost, type ModuleHostOptions, type OpCommitFaults } from "./module-host";
-import type { EntitySession } from "./persistence";
-import { SqliteKernelPersistence } from "./sqlite-kernel-persistence";
-
-/**
- * TEST / CHAOS SUPPORT ONLY (#1910 K3). Compose an in-process {@link SqliteKernelPersistence} with a
- * {@link createModuleHost} host against a raw `Database`.
- *
- * Production code builds hosts on the ASYNC gateway persistence (`createGatewayKernelPersistence`, in
- * src/db) — the {@link ModuleHost} itself never holds a `Database`. This helper exists so unit tests
- * and kill-9 chaos harnesses can still drive a host directly against a `:memory:`/file handle, now that
- * the `createModuleHost({ db })` K0 compatibility branch is gone. The raw handle is confined to the
- * `SqliteKernelPersistence` constructed here — the legitimate in-process persistence implementation
- * that the src gateway worker ops also use.
- *
- * The clock is resolved ONCE and shared by both the persistence and the host so their timestamps agree,
- * exactly as the removed `{ db }` path did (which built the compat persistence with the host's own
- * resolved clock). `messageAuthority`/`busyTimeoutMs` are the SqliteKernelPersistence construction
- * params the old branch accepted; every other option is forwarded to the host unchanged (including the
- * in-process `opCommitFaults`/`workflowCommitFaults` fault-injection callbacks).
- */
-export interface SqliteModuleHostOptions extends Omit<ModuleHostOptions, "persistence"> {
-  readonly db: Database;
-  /** Stage-0 MESSAGE authority store for the in-process persistence (timers authority tests). */
-  readonly messageAuthority?: MessageAuthorityStore;
-  /** SQLite busy timeout for the in-process persistence. */
-  readonly busyTimeoutMs?: number;
-}
-
-export function createSqliteModuleHost(options: SqliteModuleHostOptions): ModuleHost {
-  const { db, messageAuthority, busyTimeoutMs, ...hostOptions } = options;
-  const clock = hostOptions.clock ?? createRealClock();
-  const persistence = new SqliteKernelPersistence(db, clock, messageAuthority, busyTimeoutMs);
-  return createModuleHost({ ...hostOptions, clock, persistence });
-}
-
-/**
- * TEST / CHAOS SUPPORT ONLY (#1910 K3). Atomically commit an entity session (K4) and an event
- * session (K5) into ONE synchronous SQLite transaction against a RAW `Database` handle. Both sessions
- * buffer their intent asynchronously and flush synchronously; sealing them and flushing inside a
- * single `db.transaction` means a version conflict (or any throw) in either flush rolls BOTH back
- * together — entities are never written without their events, and events are never written without
- * their entities.
- *
- * `seedWorkflowsInTx` (T-0 #1409 finding 1) executes any ENLISTED workflow-instance seeds INSIDE
- * the same transaction, AFTER both flushes: an op whose entity flush loses its optimistic-version
- * CAS therefore rolls its workflow seeds back with everything else — a fence-losing op leaves no
- * orphaned instance behind, and an op's instance can only exist alongside the entities it
- * committed with.
- *
- * This lives in the test-only module (NOT the public {@link createModuleHost} barrel) and is NOT
- * re-exported from the `@humwick/kernel` root: it takes a raw `Database` and runs a synchronous
- * transaction, so exposing it publicly would reintroduce a main-loop SQLite bypass around the async
- * {@link import("./kernel-persistence").KernelPersistence} gateway (#1910 K3 review). Production code
- * commits through the gateway writer op; only kernel unit tests drive this directly against a
- * `:memory:`/file handle to assert the raw atomic-commit semantics the gateway op is built on.
- */
-export function commitAtomically(
-  db: Database,
-  entitySession: EntitySession<unknown>,
-  eventSession: EventSession<unknown>,
-  seedWorkflowsInTx?: () => void,
-  messageAuthoritySession?: MessageAuthoritySession,
-  faults?: Omit<OpCommitFaults, "beforeCommit" | "afterCommit">,
-): void {
-  entitySession.seal();
-  eventSession.seal();
-  messageAuthoritySession?.seal();
-  db.transaction(() => {
-    // Authority first matches the workflow commit order. A later entity/event/seed failure still
-    // rolls this SQL back because the participant never owns a side transaction.
-    messageAuthoritySession?.flush();
-    faults?.afterParticipantBeforeEntities?.();
-    // Entities first: an optimistic-version conflict here aborts the transaction before any
-    // event row is inserted, so a rejected mutation emits nothing.
-    entitySession.flush();
-    faults?.betweenEntitiesAndEvents?.();
-    eventSession.flush();
-    faults?.afterEventsBeforeWorkflowSeeds?.();
-    seedWorkflowsInTx?.();
-    faults?.afterWorkflowSeedsBeforeCommit?.();
-  })();
-}