@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/migrations/0008_deferred_consumption.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Registration recovery only needs completions the run has not observed.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * Retains completion values for replay while removing consumed rows from sweeps.
+ * Existing completions stay eligible until first read by the upgraded engine.
+ *
+ * @category migrations
+ * @since 1.0.0
+ */
+export declare const deferredConsumption: Effect.Effect<void, unknown, SqlClient.SqlClient>;
+//# sourceMappingURL=0008_deferred_consumption.d.ts.map

package/dist/cjs/migrations/0008_deferred_consumption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0008_deferred_consumption.d.ts","sourceRoot":"","sources":["../../../src/migrations/0008_deferred_consumption.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,SAAS,CAShF,CAAA"}

package/dist/cjs/migrations/0008_deferred_consumption.js

@@ -0,0 +1,45 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deferred_consumption_exports = {};
+__export(deferred_consumption_exports, {
+  deferredConsumption: () => deferredConsumption
+});
+module.exports = __toCommonJS(deferred_consumption_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const deferredConsumption = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`ALTER TABLE flows_deferred_completions ADD COLUMN consumed_at_ms ${Dialect.integer(sql)}
+    CHECK (consumed_at_ms IS NULL OR (${Dialect.isInteger(sql, sql`consumed_at_ms`)} AND consumed_at_ms >= 0 AND consumed_at_ms <= 9007199254740991))`;
+  yield* sql`CREATE INDEX flows_deferred_completions_unconsumed_idx
+    ON flows_deferred_completions (flow_name, execution_id, deferred_name)
+    WHERE consumed_at_ms IS NULL`;
+});
+//# sourceMappingURL=0008_deferred_consumption.js.map

package/dist/cjs/migrations/0008_deferred_consumption.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/migrations/0008_deferred_consumption.ts"],
+  "sourcesContent": ["/**\n * Registration recovery only needs completions the run has not observed.\n *\n * @since 1.0.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * Retains completion values for replay while removing consumed rows from sweeps.\n * Existing completions stay eligible until first read by the upgraded engine.\n *\n * @category migrations\n * @since 1.0.0\n */\nexport const deferredConsumption: Effect.Effect<void, unknown, SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n  yield* sql`ALTER TABLE flows_deferred_completions ADD COLUMN consumed_at_ms ${Dialect.integer(sql)}\n    CHECK (consumed_at_ms IS NULL OR (${\n    Dialect.isInteger(sql, sql`consumed_at_ms`)\n  } AND consumed_at_ms >= 0 AND consumed_at_ms <= 9007199254740991))`\n  yield* sql`CREATE INDEX flows_deferred_completions_unconsumed_idx\n    ON flows_deferred_completions (flow_name, execution_id, deferred_name)\n    WHERE consumed_at_ms IS NULL`\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAyB;AACzB,aAAwB;AACxB,gBAA2B;AASpB,MAAM,sBAAyE,OAAO,IAAI,aAAY;AAC3G,QAAM,MAAM,OAAO,UAAU;AAC7B,SAAO,uEAAuE,QAAQ,QAAQ,GAAG,CAAC;AAAA,wCAEhG,QAAQ,UAAU,KAAK,mBAAmB,CAC5C;AACA,SAAO;AAAA;AAAA;AAGT,CAAC;",
+  "names": []
+}

package/dist/cjs/migrations/0009_deferred_clock_facts.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Backfills the journal records the deferred/clock fold reads.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * Journals every deferred/clock change written before the fold's records
+ * existed: a clock row with no `clock-scheduled` record, a completed clock
+ * with no `clock-completed` record, a completion with no `deferred-completed`
+ * record, and a consumed completion with no `deferred-consumed` record. Without
+ * them a rebuild would drop the clock, or re-arm a completed one and wake a run
+ * for a result it already observed (issue #2037).
+ *
+ * Each backfilled record is appended at the run's next sequence under a
+ * `flows.engine.backfill:` producer whose identity names the row, with the
+ * lineage meta every engine record carries.
+ *
+ * @category migrations
+ * @since 1.0.0
+ */
+export declare const deferredClockFacts: Effect.Effect<void, unknown, SqlClient.SqlClient>;
+//# sourceMappingURL=0009_deferred_clock_facts.d.ts.map

package/dist/cjs/migrations/0009_deferred_clock_facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0009_deferred_clock_facts.d.ts","sourceRoot":"","sources":["../../../src/migrations/0009_deferred_clock_facts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAwB1D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,SAAS,CAkH/E,CAAA"}

package/dist/cjs/migrations/0009_deferred_clock_facts.js

@@ -0,0 +1,141 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deferred_clock_facts_exports = {};
+__export(deferred_clock_facts_exports, {
+  deferredClockFacts: () => deferredClockFacts
+});
+module.exports = __toCommonJS(deferred_clock_facts_exports);
+var import_engine = require("@smthrs/engine");
+var JournalEvent = __toESM(require("@smthrs/journal/JournalEvent"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var import_EventTypes = require("../EventTypes.js");
+const optionalTime = (value) => value === null ? null : Number(value);
+const deferredClockFacts = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const recorded = /* @__PURE__ */ new Set();
+  const events = yield* sql`
+    SELECT run_id, event_type, payload_json FROM flows_journal_events
+    WHERE ${sql.in("event_type", [
+    import_EventTypes.EventTypes.clockScheduled,
+    import_EventTypes.EventTypes.clockCompleted,
+    import_EventTypes.EventTypes.deferredCompleted,
+    import_EventTypes.EventTypes.deferredConsumed
+  ])}
+  `;
+  for (const event of events) {
+    const payload = JSON.parse(event.payload_json);
+    const name = event.event_type === import_EventTypes.EventTypes.clockScheduled || event.event_type === import_EventTypes.EventTypes.clockCompleted ? payload.clockName : payload.deferredName;
+    recorded.add(JSON.stringify([event.event_type, payload.flowName, payload.executionId, name]));
+  }
+  const next = /* @__PURE__ */ new Map();
+  const append = (eventType, executionId, name, emittedAtMs, payload) => Effect.gen(function* () {
+    const identity = JSON.stringify([eventType, payload.flowName, executionId, name]);
+    if (recorded.has(identity)) return;
+    recorded.add(identity);
+    let seq = next.get(executionId);
+    if (seq === void 0) {
+      const rows = yield* sql`
+          SELECT MAX(seq) + 1 AS next FROM flows_journal_events WHERE run_id = ${executionId}
+        `;
+      seq = Number(rows[0]?.next ?? 0);
+    }
+    next.set(executionId, seq + 1);
+    const sourceId = `flows.engine.backfill:${JournalEvent.contentDigest(identity)}`;
+    yield* sql`
+        INSERT INTO flows_journal_events (
+          run_id, seq, event_id, source_id, source_seq, emitted_at_ms, event_type, payload_json, meta_json
+        ) VALUES (
+          ${executionId},
+          ${seq},
+          ${JournalEvent.makeEventId(
+      executionId,
+      sourceId,
+      0
+    )},
+          ${sourceId},
+          ${0},
+          ${emittedAtMs},
+          ${eventType},
+          ${JSON.stringify(payload)},
+          ${JSON.stringify({ lineageId: import_engine.FlowEngine.Lineage.root(executionId) })}
+        )
+      `;
+  });
+  const clocks = yield* sql`
+    SELECT flow_name, execution_id, clock_name, deferred_name, due_at_ms, completed_at_ms
+    FROM flows_clock_deadlines
+    ORDER BY execution_id, flow_name, clock_name
+  `;
+  for (const clock of clocks) {
+    const dueAtMs = Number(clock.due_at_ms);
+    const completedAtMs = optionalTime(clock.completed_at_ms);
+    yield* append(import_EventTypes.EventTypes.clockScheduled, clock.execution_id, clock.clock_name, completedAtMs ?? dueAtMs, {
+      flowName: clock.flow_name,
+      executionId: clock.execution_id,
+      clockName: clock.clock_name,
+      deferredName: clock.deferred_name,
+      dueAtMs
+    });
+    if (completedAtMs !== null) {
+      yield* append(import_EventTypes.EventTypes.clockCompleted, clock.execution_id, clock.clock_name, completedAtMs, {
+        flowName: clock.flow_name,
+        executionId: clock.execution_id,
+        clockName: clock.clock_name,
+        completedAtMs
+      });
+    }
+  }
+  const deferreds = yield* sql`
+    SELECT flow_name, execution_id, deferred_name, exit_json, metadata_json, completed_at_ms, consumed_at_ms
+    FROM flows_deferred_completions
+    ORDER BY execution_id, flow_name, deferred_name
+  `;
+  for (const deferred of deferreds) {
+    const completedAtMs = Number(deferred.completed_at_ms);
+    const consumedAtMs = optionalTime(deferred.consumed_at_ms);
+    yield* append(import_EventTypes.EventTypes.deferredCompleted, deferred.execution_id, deferred.deferred_name, completedAtMs, {
+      flowName: deferred.flow_name,
+      executionId: deferred.execution_id,
+      deferredName: deferred.deferred_name,
+      completedAtMs,
+      exitDigest: JournalEvent.contentDigest(deferred.exit_json),
+      metadataDigest: deferred.metadata_json === null ? null : JournalEvent.contentDigest(deferred.metadata_json)
+    });
+    if (consumedAtMs !== null) {
+      yield* append(import_EventTypes.EventTypes.deferredConsumed, deferred.execution_id, deferred.deferred_name, consumedAtMs, {
+        flowName: deferred.flow_name,
+        executionId: deferred.execution_id,
+        deferredName: deferred.deferred_name,
+        consumedAtMs
+      });
+    }
+  }
+});
+//# sourceMappingURL=0009_deferred_clock_facts.js.map

package/dist/cjs/migrations/0009_deferred_clock_facts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/migrations/0009_deferred_clock_facts.ts"],
+  "sourcesContent": ["/**\n * Backfills the journal records the deferred/clock fold reads.\n *\n * @since 1.0.0\n */\n\nimport { FlowEngine } from \"@smthrs/engine\"\nimport * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport { EventTypes } from \"../EventTypes.ts\"\n\ninterface ClockRow {\n  readonly flow_name: string\n  readonly execution_id: string\n  readonly clock_name: string\n  readonly deferred_name: string\n  readonly due_at_ms: number | string\n  readonly completed_at_ms: number | string | null\n}\n\ninterface DeferredRow {\n  readonly flow_name: string\n  readonly execution_id: string\n  readonly deferred_name: string\n  readonly exit_json: string\n  readonly metadata_json: string | null\n  readonly completed_at_ms: number | string\n  readonly consumed_at_ms: number | string | null\n}\n\nconst optionalTime = (value: number | string | null): number | null => value === null ? null : Number(value)\n\n/**\n * Journals every deferred/clock change written before the fold's records\n * existed: a clock row with no `clock-scheduled` record, a completed clock\n * with no `clock-completed` record, a completion with no `deferred-completed`\n * record, and a consumed completion with no `deferred-consumed` record. Without\n * them a rebuild would drop the clock, or re-arm a completed one and wake a run\n * for a result it already observed (issue #2037).\n *\n * Each backfilled record is appended at the run's next sequence under a\n * `flows.engine.backfill:` producer whose identity names the row, with the\n * lineage meta every engine record carries.\n *\n * @category migrations\n * @since 1.0.0\n */\nexport const deferredClockFacts: Effect.Effect<void, unknown, SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n  const recorded = new Set<string>()\n  const events = yield* sql<{ readonly run_id: string; readonly event_type: string; readonly payload_json: string }>`\n    SELECT run_id, event_type, payload_json FROM flows_journal_events\n    WHERE ${\n    sql.in(\"event_type\", [\n      EventTypes.clockScheduled,\n      EventTypes.clockCompleted,\n      EventTypes.deferredCompleted,\n      EventTypes.deferredConsumed\n    ])\n  }\n  `\n  for (const event of events) {\n    const payload = JSON.parse(event.payload_json) as Record<string, unknown>\n    const name = event.event_type === EventTypes.clockScheduled || event.event_type === EventTypes.clockCompleted\n      ? payload.clockName\n      : payload.deferredName\n    recorded.add(JSON.stringify([event.event_type, payload.flowName, payload.executionId, name]))\n  }\n  const next = new Map<string, number>()\n  const append = (\n    eventType: string,\n    executionId: string,\n    name: string,\n    emittedAtMs: number,\n    payload: Readonly<Record<string, unknown>>\n  ) =>\n    Effect.gen(function*() {\n      const identity = JSON.stringify([eventType, payload.flowName, executionId, name])\n      if (recorded.has(identity)) return\n      recorded.add(identity)\n      let seq = next.get(executionId)\n      if (seq === undefined) {\n        const rows = yield* sql<{ readonly next: number | string | null }>`\n          SELECT MAX(seq) + 1 AS next FROM flows_journal_events WHERE run_id = ${executionId}\n        `\n        seq = Number(rows[0]?.next ?? 0)\n      }\n      next.set(executionId, seq + 1)\n      const sourceId = `flows.engine.backfill:${JournalEvent.contentDigest(identity)}`\n      yield* sql`\n        INSERT INTO flows_journal_events (\n          run_id, seq, event_id, source_id, source_seq, emitted_at_ms, event_type, payload_json, meta_json\n        ) VALUES (\n          ${executionId},\n          ${seq},\n          ${\n        JournalEvent.makeEventId(\n          executionId as JournalEvent.RunId,\n          sourceId as JournalEvent.SourceId,\n          0 as JournalEvent.SourceSeq\n        )\n      },\n          ${sourceId},\n          ${0},\n          ${emittedAtMs},\n          ${eventType},\n          ${JSON.stringify(payload)},\n          ${JSON.stringify({ lineageId: FlowEngine.Lineage.root(executionId) })}\n        )\n      `\n    })\n\n  const clocks = yield* sql<ClockRow>`\n    SELECT flow_name, execution_id, clock_name, deferred_name, due_at_ms, completed_at_ms\n    FROM flows_clock_deadlines\n    ORDER BY execution_id, flow_name, clock_name\n  `\n  for (const clock of clocks) {\n    const dueAtMs = Number(clock.due_at_ms)\n    const completedAtMs = optionalTime(clock.completed_at_ms)\n    yield* append(EventTypes.clockScheduled, clock.execution_id, clock.clock_name, completedAtMs ?? dueAtMs, {\n      flowName: clock.flow_name,\n      executionId: clock.execution_id,\n      clockName: clock.clock_name,\n      deferredName: clock.deferred_name,\n      dueAtMs\n    })\n    if (completedAtMs !== null) {\n      yield* append(EventTypes.clockCompleted, clock.execution_id, clock.clock_name, completedAtMs, {\n        flowName: clock.flow_name,\n        executionId: clock.execution_id,\n        clockName: clock.clock_name,\n        completedAtMs\n      })\n    }\n  }\n  const deferreds = yield* sql<DeferredRow>`\n    SELECT flow_name, execution_id, deferred_name, exit_json, metadata_json, completed_at_ms, consumed_at_ms\n    FROM flows_deferred_completions\n    ORDER BY execution_id, flow_name, deferred_name\n  `\n  for (const deferred of deferreds) {\n    const completedAtMs = Number(deferred.completed_at_ms)\n    const consumedAtMs = optionalTime(deferred.consumed_at_ms)\n    yield* append(EventTypes.deferredCompleted, deferred.execution_id, deferred.deferred_name, completedAtMs, {\n      flowName: deferred.flow_name,\n      executionId: deferred.execution_id,\n      deferredName: deferred.deferred_name,\n      completedAtMs,\n      exitDigest: JournalEvent.contentDigest(deferred.exit_json),\n      metadataDigest: deferred.metadata_json === null ? null : JournalEvent.contentDigest(deferred.metadata_json)\n    })\n    if (consumedAtMs !== null) {\n      yield* append(EventTypes.deferredConsumed, deferred.execution_id, deferred.deferred_name, consumedAtMs, {\n        flowName: deferred.flow_name,\n        executionId: deferred.execution_id,\n        deferredName: deferred.deferred_name,\n        consumedAtMs\n      })\n    }\n  }\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/migrations/0010_pending_cancellation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Indexed cancellation cleanup for admissions whose handler is unavailable.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * Bounds cleanup reads to requested pending rows.
+ *
+ * @category migrations
+ * @since 1.0.0
+ */
+export declare const pendingCancellation: Effect.Effect<void, unknown, SqlClient.SqlClient>;
+//# sourceMappingURL=0010_pending_cancellation.d.ts.map

package/dist/cjs/migrations/0010_pending_cancellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0010_pending_cancellation.d.ts","sourceRoot":"","sources":["../../../src/migrations/0010_pending_cancellation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,SAAS,CAIhF,CAAA"}

package/dist/cjs/migrations/0010_pending_cancellation.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pending_cancellation_exports = {};
+__export(pending_cancellation_exports, {
+  pendingCancellation: () => pendingCancellation
+});
+module.exports = __toCommonJS(pending_cancellation_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const pendingCancellation = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`CREATE INDEX flows_runs_pending_cancel_idx ON flows_runs (created_at_ms, run_id)
+    WHERE status = 'pending' AND cancel_requested_at_ms IS NOT NULL`;
+});
+//# sourceMappingURL=0010_pending_cancellation.js.map

package/dist/cjs/migrations/0010_pending_cancellation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/migrations/0010_pending_cancellation.ts"],
+  "sourcesContent": ["/**\n * Indexed cancellation cleanup for admissions whose handler is unavailable.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * Bounds cleanup reads to requested pending rows.\n *\n * @category migrations\n * @since 1.0.0\n */\nexport const pendingCancellation: Effect.Effect<void, unknown, SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n  yield* sql`CREATE INDEX flows_runs_pending_cancel_idx ON flows_runs (created_at_ms, run_id)\n    WHERE status = 'pending' AND cancel_requested_at_ms IS NOT NULL`\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AACxB,gBAA2B;AAQpB,MAAM,sBAAyE,OAAO,IAAI,aAAY;AAC3G,QAAM,MAAM,OAAO,UAAU;AAC7B,SAAO;AAAA;AAET,CAAC;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/test/TestStores.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Deterministic bundle of every durable store a flow engine composes.
+ *
+ * The stores split into `@smthrs/journal`, `@smthrs/run-store`, and
+ * `@smthrs/step-cache`, each with its own in-memory test layer. An engine
+ * needs all of them over ONE database, which is what this layer builds:
+ * the composed migration sets from `../Migrations.ts` run first, then the four
+ * services bind to the same in-memory SQLite connection.
+ *
+ * Governing design: `packages/smithers/flows/journal/docs/README.md`.
+ *
+ * @since 0.1.0
+ */
+import * as DurableWriter from "@smthrs/database/DurableWriter";
+import * as PlanStore from "@smthrs/plan-store/PlanStore";
+import * as AttemptStore from "@smthrs/run-store/AttemptStore";
+import * as RunStore from "@smthrs/run-store/RunStore";
+import * as CacheStore from "@smthrs/step-cache/CacheStore";
+import * as Layer from "effect/Layer";
+import * as DurableEngineState from "../DurableEngineState.ts";
+import * as OwnerIdentity from "../OwnerIdentity.ts";
+import * as PlanInputStore from "../PlanInputStore.ts";
+import * as PlanMergeStore from "../PlanMergeStore.ts";
+/**
+ * Options for the deterministic store bundle.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface TestStoresOptions {
+    readonly capacity?: number;
+    readonly overflow?: "reject" | "drop-newest" | "drop-oldest";
+    readonly batchSize?: number;
+}
+/**
+ * An in-memory SQLite database with the complete durable engine schema
+ * installed, exposed as `SqlClient` and `DurableWriter`.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const database: Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | DurableWriter.DurableWriter, import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError, never>;
+/**
+ * Provides the production SQLite journal, run, attempt, and cache services
+ * over one in-memory database. Migrations run before any durable service is
+ * exposed. The shared writer remains exposed for the engine cancellation
+ * boundary, which must inspect its complete Exit before error normalization.
+ *
+ * `OwnerIdentity.layer` rides along: it is not a store, but it is the other
+ * service `EngineStore.make` requires and has no in-memory variant to choose
+ * between. The default is used rather than a pinned one so a test observes
+ * the same fresh-per-incarnation owner the production composition mints.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: (options?: TestStoresOptions) => Layer.Layer<DurableWriter.DurableWriter | CacheStore.CacheStore | import("@smthrs/journal/Journal").Journal | RunStore.RunStore | AttemptStore.AttemptStore | OwnerIdentity.OwnerIdentity | PlanInputStore.PlanInputStore | PlanMergeStore.PlanMergeStore | PlanStore.PlanStore, import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError | import("@smthrs/journal/Journal").JournalError, import("effect/Crypto").Crypto>;
+/**
+ * The same schema over a named SQLite database or PostgreSQL URL, with the connection exposed.
+ *
+ * {@link database} hides `SqlClient` behind the stores it provisions, which is
+ * right for a case that only needs an engine. Two other shapes need the
+ * connection itself: a composition that adds another SQL-backed service over
+ * the same database (a control runtime, for one), and a case that has to prove
+ * cross-process durability, which needs a persistent identity rather than the private
+ * in-memory database each `:memory:` connection gets to itself.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const databaseAt: (filename: string) => Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | DurableWriter.DurableWriter, import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError, never>;
+/**
+ * Every durable engine service over one named database, connection included.
+ *
+ * `layer` builds the same stores over a private in-memory database and keeps
+ * `SqlClient` to itself. This one takes the database by name and re-exports
+ * the connection, so a case can point two independently constructed bundles at
+ * one file — two connections, two engines, no shared object graph — which is
+ * what a second process actually looks like. `DurableEngineState` rides along
+ * for the same reason: its in-memory variant is a map that a second bundle
+ * would not see.
+ *
+ * Pass `:memory:` for the cheap variant when the connection is still needed.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerAt: (filename: string, options?: TestStoresOptions) => Layer.Layer<import("effect/unstable/sql/SqlClient").SqlClient | DurableWriter.DurableWriter | CacheStore.CacheStore | import("@smthrs/journal/Journal").Journal | RunStore.RunStore | DurableEngineState.DurableEngineState | AttemptStore.AttemptStore | OwnerIdentity.OwnerIdentity | PlanInputStore.PlanInputStore | PlanMergeStore.PlanMergeStore | PlanStore.PlanStore, import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError | import("@smthrs/journal/Journal").JournalError, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=TestStores.d.ts.map

package/dist/cjs/test/TestStores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestStores.d.ts","sourceRoot":"","sources":["../../../src/test/TestStores.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,aAAa,MAAM,gCAAgC,CAAA;AAI/D,OAAO,KAAK,SAAS,MAAM,8BAA8B,CAAA;AACzD,OAAO,KAAK,YAAY,MAAM,gCAAgC,CAAA;AAC9D,OAAO,KAAK,QAAQ,MAAM,4BAA4B,CAAA;AACtD,OAAO,KAAK,UAAU,MAAM,+BAA+B,CAAA;AAE3D,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,kBAAkB,MAAM,0BAA0B,CAAA;AAE9D,OAAO,KAAK,aAAa,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AACtD,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,aAAa,GAAG,aAAa,CAAA;IAC5D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,8MAA2D,CAAA;AAEhF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,GAAI,UAAU,iBAAiB,+cAckB,CAAA;AAEnE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,UAAU,MAAM,iNAkB1C,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,OAAO,GAAI,UAAU,MAAM,EAAE,UAAU,iBAAiB,2iBAce,CAAA"}

package/dist/cjs/test/TestStores.js

@@ -0,0 +1,98 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TestStores_exports = {};
+__export(TestStores_exports, {
+  database: () => database,
+  databaseAt: () => databaseAt,
+  layer: () => layer,
+  layerAt: () => layerAt
+});
+module.exports = __toCommonJS(TestStores_exports);
+var DurableWriter = __toESM(require("@smthrs/database/DurableWriter"), 1);
+var NodeDatabase = __toESM(require("@smthrs/database/node/NodeDatabase"), 1);
+var TestDatabase = __toESM(require("@smthrs/database/test/TestDatabase"), 1);
+var SqlJournal = __toESM(require("@smthrs/journal/SqlJournal"), 1);
+var PlanStore = __toESM(require("@smthrs/plan-store/PlanStore"), 1);
+var AttemptStore = __toESM(require("@smthrs/run-store/AttemptStore"), 1);
+var RunStore = __toESM(require("@smthrs/run-store/RunStore"), 1);
+var CacheStore = __toESM(require("@smthrs/step-cache/CacheStore"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var DurableEngineState = __toESM(require("../DurableEngineState.js"), 1);
+var Migrations = __toESM(require("../Migrations.js"), 1);
+var OwnerIdentity = __toESM(require("../OwnerIdentity.js"), 1);
+var PlanInputStore = __toESM(require("../PlanInputStore.js"), 1);
+var PlanMergeStore = __toESM(require("../PlanMergeStore.js"), 1);
+const database = Layer.provideMerge(Migrations.layer, TestDatabase.layer);
+const layer = (options) => Layer.mergeAll(
+  SqlJournal.layer({
+    capacity: options?.capacity ?? 1024,
+    overflow: options?.overflow ?? "reject",
+    batchSize: options?.batchSize
+  }),
+  RunStore.layer,
+  AttemptStore.layer,
+  CacheStore.layer,
+  PlanStore.layer,
+  PlanInputStore.layer,
+  PlanMergeStore.layer,
+  Layer.effect(DurableWriter.DurableWriter, DurableWriter.DurableWriter)
+).pipe(Layer.provide(database), Layer.merge(OwnerIdentity.layer));
+const databaseAt = (filename) => {
+  const url = /^postgres(?:ql)?:/.test(filename) ? new URL(filename) : void 0;
+  const schema = url?.searchParams.get("schema") ?? void 0;
+  url?.searchParams.delete("schema");
+  const database2 = url === void 0 ? NodeDatabase.layer({ filename }) : Layer.unwrap(
+    Effect.promise(() => import("@smthrs/database/postgres/PostgresDatabase")).pipe(
+      Effect.map(
+        (PostgresDatabase) => PostgresDatabase.layer({
+          url: url.toString(),
+          schema,
+          postgres: { connectTimeout: Infinity, idleTimeout: Infinity, connectionTTL: Infinity }
+        })
+      )
+    )
+  );
+  return Layer.provideMerge(Migrations.layer, Layer.provideMerge(DurableWriter.layer(), database2));
+};
+const layerAt = (filename, options) => Layer.mergeAll(
+  SqlJournal.layer({
+    capacity: options?.capacity ?? 1024,
+    overflow: options?.overflow ?? "reject",
+    batchSize: options?.batchSize
+  }),
+  RunStore.layer,
+  AttemptStore.layer,
+  CacheStore.layer,
+  PlanStore.layer,
+  PlanInputStore.layer,
+  PlanMergeStore.layer,
+  DurableEngineState.layer
+).pipe(Layer.provideMerge(databaseAt(filename)), Layer.merge(OwnerIdentity.layer));
+//# sourceMappingURL=TestStores.js.map

package/dist/cjs/test/TestStores.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/test/TestStores.ts"],
+  "sourcesContent": ["/**\n * Deterministic bundle of every durable store a flow engine composes.\n *\n * The stores split into `@smthrs/journal`, `@smthrs/run-store`, and\n * `@smthrs/step-cache`, each with its own in-memory test layer. An engine\n * needs all of them over ONE database, which is what this layer builds:\n * the composed migration sets from `../Migrations.ts` run first, then the four\n * services bind to the same in-memory SQLite connection.\n *\n * Governing design: `packages/smithers/flows/journal/docs/README.md`.\n *\n * @since 0.1.0\n */\n\nimport * as DurableWriter from \"@smthrs/database/DurableWriter\"\nimport * as NodeDatabase from \"@smthrs/database/node/NodeDatabase\"\nimport * as TestDatabase from \"@smthrs/database/test/TestDatabase\"\nimport * as SqlJournal from \"@smthrs/journal/SqlJournal\"\nimport * as PlanStore from \"@smthrs/plan-store/PlanStore\"\nimport * as AttemptStore from \"@smthrs/run-store/AttemptStore\"\nimport * as RunStore from \"@smthrs/run-store/RunStore\"\nimport * as CacheStore from \"@smthrs/step-cache/CacheStore\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as DurableEngineState from \"../DurableEngineState.ts\"\nimport * as Migrations from \"../Migrations.ts\"\nimport * as OwnerIdentity from \"../OwnerIdentity.ts\"\nimport * as PlanInputStore from \"../PlanInputStore.ts\"\nimport * as PlanMergeStore from \"../PlanMergeStore.ts\"\n\n/**\n * Options for the deterministic store bundle.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface TestStoresOptions {\n  readonly capacity?: number\n  readonly overflow?: \"reject\" | \"drop-newest\" | \"drop-oldest\"\n  readonly batchSize?: number\n}\n\n/**\n * An in-memory SQLite database with the complete durable engine schema\n * installed, exposed as `SqlClient` and `DurableWriter`.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const database = Layer.provideMerge(Migrations.layer, TestDatabase.layer)\n\n/**\n * Provides the production SQLite journal, run, attempt, and cache services\n * over one in-memory database. Migrations run before any durable service is\n * exposed. The shared writer remains exposed for the engine cancellation\n * boundary, which must inspect its complete Exit before error normalization.\n *\n * `OwnerIdentity.layer` rides along: it is not a store, but it is the other\n * service `EngineStore.make` requires and has no in-memory variant to choose\n * between. The default is used rather than a pinned one so a test observes\n * the same fresh-per-incarnation owner the production composition mints.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = (options?: TestStoresOptions) =>\n  Layer.mergeAll(\n    SqlJournal.layer({\n      capacity: options?.capacity ?? 1024,\n      overflow: options?.overflow ?? \"reject\",\n      batchSize: options?.batchSize\n    }),\n    RunStore.layer,\n    AttemptStore.layer,\n    CacheStore.layer,\n    PlanStore.layer,\n    PlanInputStore.layer,\n    PlanMergeStore.layer,\n    Layer.effect(DurableWriter.DurableWriter, DurableWriter.DurableWriter)\n  ).pipe(Layer.provide(database), Layer.merge(OwnerIdentity.layer))\n\n/**\n * The same schema over a named SQLite database or PostgreSQL URL, with the connection exposed.\n *\n * {@link database} hides `SqlClient` behind the stores it provisions, which is\n * right for a case that only needs an engine. Two other shapes need the\n * connection itself: a composition that adds another SQL-backed service over\n * the same database (a control runtime, for one), and a case that has to prove\n * cross-process durability, which needs a persistent identity rather than the private\n * in-memory database each `:memory:` connection gets to itself.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const databaseAt = (filename: string) => {\n  const url = /^postgres(?:ql)?:/.test(filename) ? new URL(filename) : undefined\n  const schema = url?.searchParams.get(\"schema\") ?? undefined\n  url?.searchParams.delete(\"schema\")\n  const database = url === undefined ?\n    NodeDatabase.layer({ filename }) :\n    Layer.unwrap(\n      Effect.promise(() => import(\"@smthrs/database/postgres/PostgresDatabase\")).pipe(\n        Effect.map((PostgresDatabase) =>\n          PostgresDatabase.layer({\n            url: url.toString(),\n            schema,\n            postgres: { connectTimeout: Infinity, idleTimeout: Infinity, connectionTTL: Infinity }\n          })\n        )\n      )\n    )\n  return Layer.provideMerge(Migrations.layer, Layer.provideMerge(DurableWriter.layer(), database))\n}\n\n/**\n * Every durable engine service over one named database, connection included.\n *\n * `layer` builds the same stores over a private in-memory database and keeps\n * `SqlClient` to itself. This one takes the database by name and re-exports\n * the connection, so a case can point two independently constructed bundles at\n * one file \u2014 two connections, two engines, no shared object graph \u2014 which is\n * what a second process actually looks like. `DurableEngineState` rides along\n * for the same reason: its in-memory variant is a map that a second bundle\n * would not see.\n *\n * Pass `:memory:` for the cheap variant when the connection is still needed.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerAt = (filename: string, options?: TestStoresOptions) =>\n  Layer.mergeAll(\n    SqlJournal.layer({\n      capacity: options?.capacity ?? 1024,\n      overflow: options?.overflow ?? \"reject\",\n      batchSize: options?.batchSize\n    }),\n    RunStore.layer,\n    AttemptStore.layer,\n    CacheStore.layer,\n    PlanStore.layer,\n    PlanInputStore.layer,\n    PlanMergeStore.layer,\n    DurableEngineState.layer\n  ).pipe(Layer.provideMerge(databaseAt(filename)), Layer.merge(OwnerIdentity.layer))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA,oBAA+B;AAC/B,mBAA8B;AAC9B,mBAA8B;AAC9B,iBAA4B;AAC5B,gBAA2B;AAC3B,mBAA8B;AAC9B,eAA0B;AAC1B,iBAA4B;AAC5B,aAAwB;AACxB,YAAuB;AACvB,yBAAoC;AACpC,iBAA4B;AAC5B,oBAA+B;AAC/B,qBAAgC;AAChC,qBAAgC;AAqBzB,MAAM,WAAW,MAAM,aAAa,WAAW,OAAO,aAAa,KAAK;AAgBxE,MAAM,QAAQ,CAAC,YACpB,MAAM;AAAA,EACJ,WAAW,MAAM;AAAA,IACf,UAAU,SAAS,YAAY;AAAA,IAC/B,UAAU,SAAS,YAAY;AAAA,IAC/B,WAAW,SAAS;AAAA,EACtB,CAAC;AAAA,EACD,SAAS;AAAA,EACT,aAAa;AAAA,EACb,WAAW;AAAA,EACX,UAAU;AAAA,EACV,eAAe;AAAA,EACf,eAAe;AAAA,EACf,MAAM,OAAO,cAAc,eAAe,cAAc,aAAa;AACvE,EAAE,KAAK,MAAM,QAAQ,QAAQ,GAAG,MAAM,MAAM,cAAc,KAAK,CAAC;AAe3D,MAAM,aAAa,CAAC,aAAqB;AAC9C,QAAM,MAAM,oBAAoB,KAAK,QAAQ,IAAI,IAAI,IAAI,QAAQ,IAAI;AACrE,QAAM,SAAS,KAAK,aAAa,IAAI,QAAQ,KAAK;AAClD,OAAK,aAAa,OAAO,QAAQ;AACjC,QAAMA,YAAW,QAAQ,SACvB,aAAa,MAAM,EAAE,SAAS,CAAC,IAC/B,MAAM;AAAA,IACJ,OAAO,QAAQ,MAAM,OAAO,4CAA4C,CAAC,EAAE;AAAA,MACzE,OAAO;AAAA,QAAI,CAAC,qBACV,iBAAiB,MAAM;AAAA,UACrB,KAAK,IAAI,SAAS;AAAA,UAClB;AAAA,UACA,UAAU,EAAE,gBAAgB,UAAU,aAAa,UAAU,eAAe,SAAS;AAAA,QACvF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AACF,SAAO,MAAM,aAAa,WAAW,OAAO,MAAM,aAAa,cAAc,MAAM,GAAGA,SAAQ,CAAC;AACjG;AAkBO,MAAM,UAAU,CAAC,UAAkB,YACxC,MAAM;AAAA,EACJ,WAAW,MAAM;AAAA,IACf,UAAU,SAAS,YAAY;AAAA,IAC/B,UAAU,SAAS,YAAY;AAAA,IAC/B,WAAW,SAAS;AAAA,EACtB,CAAC;AAAA,EACD,SAAS;AAAA,EACT,aAAa;AAAA,EACb,WAAW;AAAA,EACX,UAAU;AAAA,EACV,eAAe;AAAA,EACf,eAAe;AAAA,EACf,mBAAmB;AACrB,EAAE,KAAK,MAAM,aAAa,WAAW,QAAQ,CAAC,GAAG,MAAM,MAAM,cAAc,KAAK,CAAC;",
+  "names": ["database"]
+}