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

package/dist/cjs/internal/EngineJj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineJj.d.ts","sourceRoot":"","sources":["../../../src/internal/EngineJj.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AACnC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAEzC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;;AAErC;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,aAA4E;CAAG;AAE7G;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,CAA0D,CAAA"}

package/dist/cjs/internal/EngineJj.js

@@ -0,0 +1,42 @@
+"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 EngineJj_exports = {};
+__export(EngineJj_exports, {
+  EngineJj: () => EngineJj,
+  layerFromJj: () => layerFromJj
+});
+module.exports = __toCommonJS(EngineJj_exports);
+var import_kernel = require("@smthrs/kernel");
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+class EngineJj extends Context.Service()("@smthrs/engine-store/internal/EngineJj") {
+}
+const layerFromJj = Layer.effect(EngineJj, Effect.map(import_kernel.Jj.Jj, EngineJj.of));
+//# sourceMappingURL=EngineJj.js.map

package/dist/cjs/internal/EngineJj.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/EngineJj.ts"],
+  "sourcesContent": ["/**\n * Engine-private Jujutsu authority.\n *\n * Action bodies resolve the public `Jj` tag from their guarded host context.\n * Snapshot, restore, and diff bookkeeping resolve this distinct tag instead,\n * so an engine operation never grants the same authority to user code.\n *\n * @since 1.0.0\n */\n\nimport { Jj } from \"@smthrs/kernel\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\n\n/**\n * Engine-owned repository operations, absent from public action context.\n *\n * @since 1.0.0\n * @category services\n */\nexport class EngineJj extends Context.Service<EngineJj, Jj.Jj>()(\"@smthrs/engine-store/internal/EngineJj\") {}\n\n/**\n * Captures the current public Jj implementation under the private engine tag.\n *\n * @since 1.0.0\n * @category layers\n */\nexport const layerFromJj: Layer.Layer<EngineJj, never, Jj.Jj> = Layer.effect(EngineJj, Effect.map(Jj.Jj, EngineJj.of))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,oBAAmB;AACnB,cAAyB;AACzB,aAAwB;AACxB,YAAuB;AAQhB,MAAM,iBAAiB,QAAQ,QAAyB,EAAE,wCAAwC,EAAE;AAAC;AAQrG,MAAM,cAAmD,MAAM,OAAO,UAAU,OAAO,IAAI,iBAAG,IAAI,SAAS,EAAE,CAAC;",
+  "names": []
+}

package/dist/cjs/internal/EngineStateSchema.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The schema objects `DurableEngineState` creates outside the journal
+ * migration, and the inventory of what porting them to another
+ * dialect costs.
+ *
+ * Each durable package owns its migration ladder. Spawn edges and their GC
+ * trigger moved into engine-store migration 0006. The remaining
+ * statements are engine-store-owned storage created idempotently at
+ * construction instead (issues #40/#41/#79/#81). That is a deliberate lane
+ * boundary, not an oversight — but it left the statements invisible to the
+ * pg-porting plan in the database roadmap, which
+ * scoped only the journal migration's SQLite-specific DDL. Declaring them here
+ * makes the inventory machine-readable: a test diffs the database's schema
+ * objects across `make` against this list, so no engine-owned statement can
+ * be added without appearing in the porting inventory (issue #92).
+ *
+ * @since 0.1.0
+ */
+import type { Service as WriterService } from "@smthrs/database/DurableWriter";
+import * as Effect from "effect/Effect";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * SQL dialects a statement is known to be accepted by, verbatim.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Dialect = "sqlite" | "postgres";
+/**
+ * One engine-store-owned schema object.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Statement {
+    /** The schema object's name, as it appears in the catalog. */
+    readonly name: string;
+    /** Why the object exists, by issue. */
+    readonly reason: string;
+    /**
+     * Dialects that accept this statement unchanged. A statement listing only
+     * `"sqlite"` must be rewritten before a Postgres/PGlite `Database` layer
+     * can construct this service — `make` pipes every one of them through
+     * `Effect.orDie`, so an unported statement is a construction-time defect,
+     * not a recoverable error.
+     */
+    readonly dialects: ReadonlyArray<Dialect>;
+    readonly ddl: string;
+}
+/**
+ * The porting inventory: every engine-store-owned statement, in creation order.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const statements: ReadonlyArray<Statement>;
+/**
+ * Creates the engine-store-owned objects, idempotently, in inventory order.
+ *
+ * `flows_runs` must already exist — every query in this service assumes a
+ * migrated database, so `make` composes over one by construction. A read-only
+ * client installs nothing.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const apply: (sql: SqlClient.SqlClient, writer: WriterService) => Effect.Effect<void>;
+//# sourceMappingURL=EngineStateSchema.d.ts.map

package/dist/cjs/internal/EngineStateSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineStateSchema.d.ts","sourceRoot":"","sources":["../../../src/internal/EngineStateSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAC9E,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAA;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,uCAAuC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IACzC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACrB;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,aAAa,CAAC,SAAS,CAa/C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK,SAAS,CAAC,SAAS,EAAE,QAAQ,aAAa,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAMvF,CAAA"}

package/dist/cjs/internal/EngineStateSchema.js

@@ -0,0 +1,58 @@
+"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 EngineStateSchema_exports = {};
+__export(EngineStateSchema_exports, {
+  apply: () => apply,
+  statements: () => statements
+});
+module.exports = __toCommonJS(EngineStateSchema_exports);
+var import_Dialect = require("@smthrs/database/Dialect");
+var Effect = __toESM(require("effect/Effect"), 1);
+const statements = [
+  {
+    name: "flows_runs_stale_running_idx",
+    reason: "Serves the stale-running sweep's per-tick predicate (issue #79): `status = 'running' AND heartbeat_at_ms < cutoff`, ordered by heartbeat. A partial index keeps it tiny \u2014 only live running rows appear.",
+    // Partial indexes are valid Postgres since 9.5, so this one ports as-is.
+    dialects: ["sqlite", "postgres"],
+    ddl: `
+      CREATE INDEX IF NOT EXISTS flows_runs_stale_running_idx
+      ON flows_runs (heartbeat_at_ms)
+      WHERE status = 'running'
+    `
+  }
+];
+const apply = (sql, writer) => (
+  // A read-only observer reads the schema it finds and installs nothing.
+  (0, import_Dialect.isReadOnly)(sql) ? Effect.void : Effect.forEach(
+    statements,
+    (statement) => writer.write(sql.unsafe(statement.ddl)).pipe(Effect.orDie),
+    { discard: true }
+  )
+);
+//# sourceMappingURL=EngineStateSchema.js.map

package/dist/cjs/internal/EngineStateSchema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/EngineStateSchema.ts"],
+  "sourcesContent": ["/**\n * The schema objects `DurableEngineState` creates outside the journal\n * migration, and the inventory of what porting them to another\n * dialect costs.\n *\n * Each durable package owns its migration ladder. Spawn edges and their GC\n * trigger moved into engine-store migration 0006. The remaining\n * statements are engine-store-owned storage created idempotently at\n * construction instead (issues #40/#41/#79/#81). That is a deliberate lane\n * boundary, not an oversight \u2014 but it left the statements invisible to the\n * pg-porting plan in the database roadmap, which\n * scoped only the journal migration's SQLite-specific DDL. Declaring them here\n * makes the inventory machine-readable: a test diffs the database's schema\n * objects across `make` against this list, so no engine-owned statement can\n * be added without appearing in the porting inventory (issue #92).\n *\n * @since 0.1.0\n */\n\nimport { isReadOnly } from \"@smthrs/database/Dialect\"\nimport type { Service as WriterService } from \"@smthrs/database/DurableWriter\"\nimport * as Effect from \"effect/Effect\"\nimport type * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * SQL dialects a statement is known to be accepted by, verbatim.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Dialect = \"sqlite\" | \"postgres\"\n\n/**\n * One engine-store-owned schema object.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Statement {\n  /** The schema object's name, as it appears in the catalog. */\n  readonly name: string\n  /** Why the object exists, by issue. */\n  readonly reason: string\n  /**\n   * Dialects that accept this statement unchanged. A statement listing only\n   * `\"sqlite\"` must be rewritten before a Postgres/PGlite `Database` layer\n   * can construct this service \u2014 `make` pipes every one of them through\n   * `Effect.orDie`, so an unported statement is a construction-time defect,\n   * not a recoverable error.\n   */\n  readonly dialects: ReadonlyArray<Dialect>\n  readonly ddl: string\n}\n\n/**\n * The porting inventory: every engine-store-owned statement, in creation order.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const statements: ReadonlyArray<Statement> = [\n  {\n    name: \"flows_runs_stale_running_idx\",\n    reason:\n      \"Serves the stale-running sweep's per-tick predicate (issue #79): `status = 'running' AND heartbeat_at_ms < cutoff`, ordered by heartbeat. A partial index keeps it tiny \u2014 only live running rows appear.\",\n    // Partial indexes are valid Postgres since 9.5, so this one ports as-is.\n    dialects: [\"sqlite\", \"postgres\"],\n    ddl: `\n      CREATE INDEX IF NOT EXISTS flows_runs_stale_running_idx\n      ON flows_runs (heartbeat_at_ms)\n      WHERE status = 'running'\n    `\n  }\n]\n\n/**\n * Creates the engine-store-owned objects, idempotently, in inventory order.\n *\n * `flows_runs` must already exist \u2014 every query in this service assumes a\n * migrated database, so `make` composes over one by construction. A read-only\n * client installs nothing.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const apply = (sql: SqlClient.SqlClient, writer: WriterService): Effect.Effect<void> =>\n  // A read-only observer reads the schema it finds and installs nothing.\n  isReadOnly(sql) ? Effect.void : Effect.forEach(\n    statements,\n    (statement) => writer.write(sql.unsafe(statement.ddl)).pipe(Effect.orDie),\n    { discard: true }\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBA,qBAA2B;AAE3B,aAAwB;AAuCjB,MAAM,aAAuC;AAAA,EAClD;AAAA,IACE,MAAM;AAAA,IACN,QACE;AAAA;AAAA,IAEF,UAAU,CAAC,UAAU,UAAU;AAAA,IAC/B,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA,EAKP;AACF;AAYO,MAAM,QAAQ,CAAC,KAA0B;AAAA;AAAA,MAE9C,2BAAW,GAAG,IAAI,OAAO,OAAO,OAAO;AAAA,IACrC;AAAA,IACA,CAAC,cAAc,OAAO,MAAM,IAAI,OAAO,UAAU,GAAG,CAAC,EAAE,KAAK,OAAO,KAAK;AAAA,IACxE,EAAE,SAAS,KAAK;AAAA,EAClB;AAAA;",
+  "names": []
+}

package/dist/cjs/internal/ExecutionSnapshotRead.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Shared transactional execution decoding.
+ *
+ * @since 1.0.0
+ */
+import * as Sha256 from "@smthrs/crypto/Sha256";
+import { RunStoreError } from "@smthrs/run-store/RunStore";
+import { Effect, Schema } from "effect";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { Batch } from "../ExecutionSnapshot.ts";
+/**
+ * Non-negative safe integer for timestamps and revisions.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const Natural: Schema.Int;
+/**
+ * Bounded identifier with a durable text encoding.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const Identifier: Schema.NonEmptyString;
+/**
+ * Engine database source identity.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const Source: Schema.String;
+/**
+ * Source identity and observed high-water mark.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const Position: Schema.Struct<{
+    readonly source: Schema.String;
+    readonly revision: Schema.Int;
+}>;
+/**
+ * Source identity and observed high-water mark.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export type Position = typeof Position.Type;
+/**
+ * A deferred read transaction on the reserved engine connection. The normal
+ * writable client's transaction starts IMMEDIATE; a read needs only SQLite's
+ * snapshot and must allow a WAL writer to commit while it reads. PostgreSQL
+ * reads at REPEATABLE READ so every statement shares the snapshot the position
+ * was read from; READ COMMITTED would let a concurrent commit make a row look
+ * newer than its position. Reuse the SQL
+ * client's transaction service to join an existing transaction. No read body
+ * exposes a mutation callback. Connection reservation and interruption release
+ * remain scoped, including when BEGIN or the read fails.
+ * @since 1.0.0
+ * @private
+ */
+export declare const transaction: <A, E, R>(sql: SqlClient.SqlClient, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, import("effect/unstable/sql/SqlError").SqlError | E, R>;
+/**
+ * Preserves failure causes and interruption at the read boundary.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const boundary: <A, E, R>(method: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, RunStoreError, R>;
+/**
+ * Decodes stored SQL values with the original schema error.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const decode: <S extends Schema.Top>(schema: S, input: unknown) => Effect.Effect<S["Type"], RunStoreError, S["DecodingServices"]>;
+/**
+ * Reads the engine database identity and revision.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const position: (sql: SqlClient.SqlClient) => Effect.Effect<{
+    readonly source: string;
+    readonly revision: number;
+}, import("effect/unstable/sql/SqlError").SqlError | RunStoreError, never>;
+/**
+ * Structured waiting condition; nullable fields preserve older unknown values.
+ * The opaque wake token leaves the engine only as its SHA-256 `tokenDigest`,
+ * the same digest `ExecutionFacts` records: a reader may correlate a wait but
+ * never holds the address that resolves it.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export interface Waiting {
+    readonly kind: "timer" | "signal" | "approval" | "quota" | "human" | "other";
+    readonly reason: string;
+    readonly wakeAtMs: number | null;
+    readonly tokenDigest: Sha256.Digest | null;
+    readonly request?: typeof Schema.Json.Type | undefined;
+}
+/**
+ * Page-scoped lifecycle fields and indexed earliest spawn edge.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const selectColumns = "r.*, c.revision, c.deleted,\n  (SELECT parent_id FROM flows_run_parents WHERE child_id = r.run_id ORDER BY seq, parent_id LIMIT 1) AS spawn_parent_id,\n  (SELECT seq FROM flows_run_parents WHERE child_id = r.run_id ORDER BY seq, parent_id LIMIT 1) AS spawn_seq";
+/**
+ * Decodes a run row and validates observation invariants.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const observed: (input: unknown, at: Position) => Effect.Effect<{
+    _tag: "Observed";
+    runId: string;
+    source: string;
+    revision: number;
+    status: "running" | "suspended" | "failed" | "completed" | "pending" | "cancelled";
+    flowName: string;
+    createdAtMs: number;
+    startedAtMs: number | null;
+    finishedAtMs: number | null;
+    parentRunId: string | null;
+    lineageId: string;
+    roundOrdinal: number;
+    cancellation: {
+        requestedAtMs: number | null;
+        acknowledgement: {
+            readonly observedAtMs: number;
+            readonly owner: {
+                readonly hostId: string;
+                readonly pid: number;
+                readonly nonce: string;
+            };
+        } | null;
+    };
+    waiting: {
+        request?: string | number | boolean | Schema.JsonArray | Schema.JsonObject;
+        kind: "approval" | "human" | "timer" | "signal" | "quota" | "other";
+        reason: string;
+        wakeAtMs: number | null;
+        tokenDigest: (string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">) | null;
+    } | null;
+}, RunStoreError, never>;
+/**
+ * The result of a successful execution observation.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export type Observed = Effect.Success<ReturnType<typeof observed>>;
+/**
+ * Validates source, identity, ordering and revision coherence at the batch boundary.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const coherentBatch: (runIds: ReadonlyArray<string>, batch: Batch) => Effect.Effect<Batch, RunStoreError>;
+//# sourceMappingURL=ExecutionSnapshotRead.d.ts.map

package/dist/cjs/internal/ExecutionSnapshotRead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionSnapshotRead.d.ts","sourceRoot":"","sources":["../../../src/internal/ExecutionSnapshotRead.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAE/C,OAAO,EAAa,aAAa,EAAE,MAAM,4BAA4B,CAAA;AACrE,OAAO,EAAS,MAAM,EAAgB,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC5D,OAAO,KAAK,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAGpD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,YAAuF,CAAA;AAC3G;;;;;GAKG;AACH,eAAO,MAAM,UAAU,uBAKtB,CAAA;AACD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,eAA0D,CAAA;AAC7E;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;EAAuD,CAAA;AAC5E;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,SAAS,CAAC,SAAS,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,6EAiB1F,CAAA;AAEH;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAY/G,CAAA;AAEL;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,OAAO,OAAO,mEAQlE,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,SAAS,CAAC,SAAS;;;0EAG9C,CAAA;AAkCH;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAA;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,SAAS,CAAA;CACvD;AAiBD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,yQAEmF,CAAA;AAE7G;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,EAAE,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkDjD,CAAA;AAEJ;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAA;AAElE;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,KAAG,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,CAmB7G,CAAA"}

package/dist/cjs/internal/ExecutionSnapshotRead.js

@@ -0,0 +1,201 @@
+"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 ExecutionSnapshotRead_exports = {};
+__export(ExecutionSnapshotRead_exports, {
+  Identifier: () => Identifier,
+  Natural: () => Natural,
+  Position: () => Position,
+  Source: () => Source,
+  boundary: () => boundary,
+  coherentBatch: () => coherentBatch,
+  decode: () => decode,
+  observed: () => observed,
+  position: () => position,
+  selectColumns: () => selectColumns,
+  transaction: () => transaction
+});
+module.exports = __toCommonJS(ExecutionSnapshotRead_exports);
+var Sha256 = __toESM(require("@smthrs/crypto/Sha256"), 1);
+var import_OwnerId = require("@smthrs/journal/OwnerId");
+var import_RunStore = require("@smthrs/run-store/RunStore");
+var import_effect = require("effect");
+var import_RunState = require("../RunState.js");
+const Natural = import_effect.Schema.Int.check(import_effect.Schema.isBetween({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }));
+const Identifier = import_effect.Schema.NonEmptyString.check(
+  import_effect.Schema.isMaxLength(1024),
+  import_effect.Schema.makeFilter(
+    (value) => !value.includes("\0") && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(value)
+  )
+);
+const Source = import_effect.Schema.String.check(import_effect.Schema.isPattern(/^[0-9a-f]{32}$/));
+const Position = import_effect.Schema.Struct({ source: Source, revision: Natural });
+const transaction = (sql, effect) => import_effect.Effect.flatMap(
+  import_effect.Effect.serviceOption(sql.transactionService),
+  (existing) => import_effect.Option.isSome(existing) ? effect : import_effect.Effect.scoped(import_effect.Effect.gen(function* () {
+    const connection = yield* sql.reserve;
+    return yield* import_effect.Effect.acquireUseRelease(
+      connection.executeUnprepared(
+        sql.onDialectOrElse({ pg: () => "BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY", orElse: () => "BEGIN" }),
+        [],
+        void 0
+      ),
+      () => effect.pipe(import_effect.Effect.provideService(sql.transactionService, [connection, 0])),
+      (_, exit) => connection.executeUnprepared(import_effect.Exit.isSuccess(exit) ? "COMMIT" : "ROLLBACK", [], void 0).pipe(import_effect.Effect.orDie)
+    );
+  }))
+);
+const boundary = (method, effect) => effect.pipe(import_effect.Effect.catchCause((cause) => {
+  if (import_effect.Cause.hasInterruptsOnly(cause)) return import_effect.Effect.failCause(cause);
+  const original = import_effect.Cause.squash(cause);
+  return import_effect.Effect.fail(
+    original instanceof import_RunStore.RunStoreError ? original : new import_RunStore.RunStoreError({
+      method,
+      code: "persistence_failed",
+      message: "engine execution observation failed",
+      cause: original
+    })
+  );
+}));
+const decode = (schema, input) => import_effect.Schema.decodeUnknownEffect(schema)(input).pipe(import_effect.Effect.mapError(
+  (cause) => new import_RunStore.RunStoreError({
+    method: "ExecutionSnapshot.decode",
+    code: "decode_failed",
+    message: "stored execution observation is malformed",
+    cause
+  })
+));
+const position = (sql) => sql`SELECT source, revision FROM flows_run_source WHERE singleton = 1`.pipe(
+  import_effect.Effect.flatMap((rows) => decode(Position, rows[0]))
+);
+const Row = import_effect.Schema.Struct({
+  run_id: Identifier,
+  status: import_RunStore.RunStatus,
+  created_at_ms: Natural,
+  started_at_ms: import_effect.Schema.NullOr(Natural),
+  finished_at_ms: import_effect.Schema.NullOr(Natural),
+  owner_host_id: import_effect.Schema.NullOr(Identifier),
+  owner_pid: import_effect.Schema.NullOr(Natural),
+  owner_nonce: import_effect.Schema.NullOr(Identifier),
+  heartbeat_at_ms: import_effect.Schema.NullOr(Natural),
+  state_json: import_effect.Schema.fromJsonString(import_RunState.RunState),
+  parent_run_id: import_effect.Schema.NullOr(Identifier),
+  spawn_parent_id: import_effect.Schema.NullOr(Identifier),
+  spawn_seq: import_effect.Schema.NullOr(Natural),
+  execution_parent_id: import_effect.Schema.NullOr(Identifier),
+  lineage_id: import_effect.Schema.NullOr(Identifier),
+  round_ordinal: import_effect.Schema.NullOr(Natural),
+  cancel_requested_at_ms: import_effect.Schema.NullOr(Natural),
+  cancel_acknowledgement_json: import_effect.Schema.NullOr(import_effect.Schema.fromJsonString(import_effect.Schema.Struct({
+    observedAtMs: Natural,
+    owner: import_OwnerId.OwnerId
+  }))),
+  // These opaque values use DurableEngineState's existing non-empty-string
+  // contract. They are not run IDs and must not acquire an identifier ceiling.
+  waiting_reason: import_effect.Schema.NullOr(import_effect.Schema.NonEmptyString),
+  waiting_wake_at_ms: import_effect.Schema.NullOr(Natural),
+  waiting_token: import_effect.Schema.NullOr(import_effect.Schema.NonEmptyString),
+  waiting_request: import_effect.Schema.optional(import_effect.Schema.NullOr(import_effect.Schema.fromJsonString(import_effect.Schema.Json))),
+  revision: Natural,
+  deleted: import_effect.Schema.Literal(0)
+});
+const waitingKind = (reason) => {
+  switch (reason) {
+    case "timer":
+    case "approval":
+    case "quota":
+    case "human":
+      return reason;
+    case "event":
+    case "signal":
+      return "signal";
+    default:
+      return "other";
+  }
+};
+const selectColumns = `r.*, c.revision, c.deleted,
+  (SELECT parent_id FROM flows_run_parents WHERE child_id = r.run_id ORDER BY seq, parent_id LIMIT 1) AS spawn_parent_id,
+  (SELECT seq FROM flows_run_parents WHERE child_id = r.run_id ORDER BY seq, parent_id LIMIT 1) AS spawn_seq`;
+const observed = (input, at) => import_effect.Effect.gen(function* () {
+  const row = yield* decode(Row, input);
+  const parentRunId = row.parent_run_id ?? row.spawn_parent_id;
+  const ownerFields = [row.owner_host_id, row.owner_pid, row.owner_nonce, row.heartbeat_at_ms];
+  const validOwner = row.status === "running" ? ownerFields.every((value) => value !== null) : ownerFields.every((value) => value === null);
+  if (!validOwner || row.revision === 0 || row.revision > at.revision || parentRunId !== row.execution_parent_id || parentRunId === row.run_id || row.lineage_id === null !== (row.round_ordinal === null) || row.waiting_reason === null && (row.waiting_wake_at_ms !== null || row.waiting_token !== null || row.waiting_request !== void 0 && row.waiting_request !== null) || row.cancel_acknowledgement_json !== null && row.cancel_requested_at_ms === null) {
+    return yield* import_effect.Effect.fail(
+      new import_RunStore.RunStoreError({
+        method: "ExecutionSnapshot.decode",
+        code: "decode_failed",
+        message: "stored execution observation violates its invariants",
+        cause: new Error("inconsistent execution identity, wait, cancellation or revision")
+      })
+    );
+  }
+  return {
+    _tag: "Observed",
+    runId: row.run_id,
+    source: at.source,
+    revision: row.revision,
+    status: row.status,
+    flowName: row.state_json.flowName,
+    createdAtMs: row.created_at_ms,
+    startedAtMs: row.started_at_ms,
+    finishedAtMs: row.finished_at_ms,
+    parentRunId,
+    lineageId: row.lineage_id ?? row.run_id,
+    roundOrdinal: row.round_ordinal ?? 0,
+    cancellation: {
+      requestedAtMs: row.cancel_requested_at_ms,
+      acknowledgement: row.cancel_acknowledgement_json
+    },
+    waiting: row.waiting_reason === null ? null : {
+      kind: waitingKind(row.waiting_reason),
+      reason: row.waiting_reason,
+      wakeAtMs: row.waiting_wake_at_ms,
+      tokenDigest: row.waiting_token === null ? null : Sha256.digestSync(row.waiting_token),
+      ...row.waiting_request === void 0 || row.waiting_request === null ? {} : { request: row.waiting_request }
+    }
+  };
+});
+const coherentBatch = (runIds, batch) => {
+  const validPosition = import_effect.Schema.is(Position);
+  if (!validPosition(batch) || batch.snapshots.length !== runIds.length || batch.snapshots.some(
+    (row, index) => !validPosition(row) || row.runId !== runIds[index] || row.source !== batch.source || row.revision > batch.revision
+  )) {
+    return import_effect.Effect.fail(
+      new import_RunStore.RunStoreError({
+        method: "ExecutionSnapshot.read",
+        code: "persistence_failed",
+        message: "stored execution batch is incoherent: source, identity, order or revision mismatch",
+        cause: void 0
+      })
+    );
+  }
+  return import_effect.Effect.succeed(batch);
+};
+//# sourceMappingURL=ExecutionSnapshotRead.js.map

package/dist/cjs/internal/ExecutionSnapshotRead.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/ExecutionSnapshotRead.ts"],
+  "sourcesContent": ["/**\n * Shared transactional execution decoding.\n *\n * @since 1.0.0\n */\n\nimport * as Sha256 from \"@smthrs/crypto/Sha256\"\nimport { OwnerId } from \"@smthrs/journal/OwnerId\"\nimport { RunStatus, RunStoreError } from \"@smthrs/run-store/RunStore\"\nimport { Cause, Effect, Exit, Option, Schema } from \"effect\"\nimport type * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport type { Batch } from \"../ExecutionSnapshot.ts\"\nimport { RunState } from \"../RunState.ts\"\n\n/**\n * Non-negative safe integer for timestamps and revisions.\n *\n * @private\n * @since 1.0.0\n */\nexport const Natural = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }))\n/**\n * Bounded identifier with a durable text encoding.\n *\n * @private\n * @since 1.0.0\n */\nexport const Identifier = Schema.NonEmptyString.check(\n  Schema.isMaxLength(1024),\n  Schema.makeFilter((value) =>\n    !value.includes(\"\\0\") && !/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/.test(value)\n  )\n)\n/**\n * Engine database source identity.\n *\n * @private\n * @since 1.0.0\n */\nexport const Source = Schema.String.check(Schema.isPattern(/^[0-9a-f]{32}$/))\n/**\n * Source identity and observed high-water mark.\n *\n * @private\n * @since 1.0.0\n */\nexport const Position = Schema.Struct({ source: Source, revision: Natural })\n/**\n * Source identity and observed high-water mark.\n *\n * @private\n * @since 1.0.0\n */\nexport type Position = typeof Position.Type\n\n/**\n * A deferred read transaction on the reserved engine connection. The normal\n * writable client's transaction starts IMMEDIATE; a read needs only SQLite's\n * snapshot and must allow a WAL writer to commit while it reads. PostgreSQL\n * reads at REPEATABLE READ so every statement shares the snapshot the position\n * was read from; READ COMMITTED would let a concurrent commit make a row look\n * newer than its position. Reuse the SQL\n * client's transaction service to join an existing transaction. No read body\n * exposes a mutation callback. Connection reservation and interruption release\n * remain scoped, including when BEGIN or the read fails.\n * @since 1.0.0\n * @private\n */\nexport const transaction = <A, E, R>(sql: SqlClient.SqlClient, effect: Effect.Effect<A, E, R>) =>\n  Effect.flatMap(\n    Effect.serviceOption(sql.transactionService),\n    (existing) =>\n      Option.isSome(existing) ? effect : Effect.scoped(Effect.gen(function*() {\n        const connection = yield* sql.reserve\n        return yield* Effect.acquireUseRelease(\n          connection.executeUnprepared(\n            sql.onDialectOrElse({ pg: () => \"BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY\", orElse: () => \"BEGIN\" }),\n            [],\n            undefined\n          ),\n          () => effect.pipe(Effect.provideService(sql.transactionService, [connection, 0])),\n          (_, exit) =>\n            connection.executeUnprepared(Exit.isSuccess(exit) ? \"COMMIT\" : \"ROLLBACK\", [], undefined).pipe(Effect.orDie)\n        )\n      }))\n  )\n\n/**\n * Preserves failure causes and interruption at the read boundary.\n *\n * @private\n * @since 1.0.0\n */\nexport const boundary = <A, E, R>(method: string, effect: Effect.Effect<A, E, R>): Effect.Effect<A, RunStoreError, R> =>\n  effect.pipe(Effect.catchCause((cause) => {\n    if (Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause as Cause.Cause<never>)\n    const original = Cause.squash(cause)\n    return Effect.fail(\n      original instanceof RunStoreError ? original : new RunStoreError({\n        method,\n        code: \"persistence_failed\",\n        message: \"engine execution observation failed\",\n        cause: original\n      })\n    )\n  }))\n\n/**\n * Decodes stored SQL values with the original schema error.\n *\n * @private\n * @since 1.0.0\n */\nexport const decode = <S extends Schema.Top>(schema: S, input: unknown) =>\n  Schema.decodeUnknownEffect(schema)(input).pipe(Effect.mapError((cause) =>\n    new RunStoreError({\n      method: \"ExecutionSnapshot.decode\",\n      code: \"decode_failed\",\n      message: \"stored execution observation is malformed\",\n      cause\n    })\n  ))\n\n/**\n * Reads the engine database identity and revision.\n *\n * @private\n * @since 1.0.0\n */\nexport const position = (sql: SqlClient.SqlClient) =>\n  sql`SELECT source, revision FROM flows_run_source WHERE singleton = 1`.pipe(\n    Effect.flatMap((rows) => decode(Position, rows[0]))\n  )\n\nconst Row = Schema.Struct({\n  run_id: Identifier,\n  status: RunStatus,\n  created_at_ms: Natural,\n  started_at_ms: Schema.NullOr(Natural),\n  finished_at_ms: Schema.NullOr(Natural),\n  owner_host_id: Schema.NullOr(Identifier),\n  owner_pid: Schema.NullOr(Natural),\n  owner_nonce: Schema.NullOr(Identifier),\n  heartbeat_at_ms: Schema.NullOr(Natural),\n  state_json: Schema.fromJsonString(RunState),\n  parent_run_id: Schema.NullOr(Identifier),\n  spawn_parent_id: Schema.NullOr(Identifier),\n  spawn_seq: Schema.NullOr(Natural),\n  execution_parent_id: Schema.NullOr(Identifier),\n  lineage_id: Schema.NullOr(Identifier),\n  round_ordinal: Schema.NullOr(Natural),\n  cancel_requested_at_ms: Schema.NullOr(Natural),\n  cancel_acknowledgement_json: Schema.NullOr(Schema.fromJsonString(Schema.Struct({\n    observedAtMs: Natural,\n    owner: OwnerId\n  }))),\n  // These opaque values use DurableEngineState's existing non-empty-string\n  // contract. They are not run IDs and must not acquire an identifier ceiling.\n  waiting_reason: Schema.NullOr(Schema.NonEmptyString),\n  waiting_wake_at_ms: Schema.NullOr(Natural),\n  waiting_token: Schema.NullOr(Schema.NonEmptyString),\n  waiting_request: Schema.optional(Schema.NullOr(Schema.fromJsonString(Schema.Json))),\n  revision: Natural,\n  deleted: Schema.Literal(0)\n})\n\n/**\n * Structured waiting condition; nullable fields preserve older unknown values.\n * The opaque wake token leaves the engine only as its SHA-256 `tokenDigest`,\n * the same digest `ExecutionFacts` records: a reader may correlate a wait but\n * never holds the address that resolves it.\n *\n * @private\n * @since 1.0.0\n */\nexport interface Waiting {\n  readonly kind: \"timer\" | \"signal\" | \"approval\" | \"quota\" | \"human\" | \"other\"\n  readonly reason: string\n  readonly wakeAtMs: number | null\n  readonly tokenDigest: Sha256.Digest | null\n  readonly request?: typeof Schema.Json.Type | undefined\n}\n\nconst waitingKind = (reason: string): Waiting[\"kind\"] => {\n  switch (reason) {\n    case \"timer\":\n    case \"approval\":\n    case \"quota\":\n    case \"human\":\n      return reason\n    case \"event\":\n    case \"signal\":\n      return \"signal\"\n    default:\n      return \"other\"\n  }\n}\n\n/**\n * Page-scoped lifecycle fields and indexed earliest spawn edge.\n *\n * @private\n * @since 1.0.0\n */\nexport const selectColumns = `r.*, c.revision, c.deleted,\n  (SELECT parent_id FROM flows_run_parents WHERE child_id = r.run_id ORDER BY seq, parent_id LIMIT 1) AS spawn_parent_id,\n  (SELECT seq FROM flows_run_parents WHERE child_id = r.run_id ORDER BY seq, parent_id LIMIT 1) AS spawn_seq`\n\n/**\n * Decodes a run row and validates observation invariants.\n *\n * @private\n * @since 1.0.0\n */\nexport const observed = (input: unknown, at: Position) =>\n  Effect.gen(function*() {\n    const row = yield* decode(Row, input)\n    const parentRunId = row.parent_run_id ?? row.spawn_parent_id\n    const ownerFields = [row.owner_host_id, row.owner_pid, row.owner_nonce, row.heartbeat_at_ms]\n    const validOwner = row.status === \"running\"\n      ? ownerFields.every((value) => value !== null)\n      : ownerFields.every((value) => value === null)\n    if (\n      !validOwner || row.revision === 0 || row.revision > at.revision ||\n      parentRunId !== row.execution_parent_id || parentRunId === row.run_id ||\n      (row.lineage_id === null) !== (row.round_ordinal === null) ||\n      (row.waiting_reason === null && (row.waiting_wake_at_ms !== null || row.waiting_token !== null ||\n        row.waiting_request !== undefined && row.waiting_request !== null)) ||\n      (row.cancel_acknowledgement_json !== null && row.cancel_requested_at_ms === null)\n    ) {\n      return yield* Effect.fail(\n        new RunStoreError({\n          method: \"ExecutionSnapshot.decode\",\n          code: \"decode_failed\",\n          message: \"stored execution observation violates its invariants\",\n          cause: new Error(\"inconsistent execution identity, wait, cancellation or revision\")\n        })\n      )\n    }\n    return {\n      _tag: \"Observed\" as const,\n      runId: row.run_id,\n      source: at.source,\n      revision: row.revision,\n      status: row.status,\n      flowName: row.state_json.flowName,\n      createdAtMs: row.created_at_ms,\n      startedAtMs: row.started_at_ms,\n      finishedAtMs: row.finished_at_ms,\n      parentRunId,\n      lineageId: row.lineage_id ?? row.run_id,\n      roundOrdinal: row.round_ordinal ?? 0,\n      cancellation: {\n        requestedAtMs: row.cancel_requested_at_ms,\n        acknowledgement: row.cancel_acknowledgement_json\n      },\n      waiting: row.waiting_reason === null ? null : {\n        kind: waitingKind(row.waiting_reason),\n        reason: row.waiting_reason,\n        wakeAtMs: row.waiting_wake_at_ms,\n        tokenDigest: row.waiting_token === null ? null : Sha256.digestSync(row.waiting_token),\n        ...(row.waiting_request === undefined || row.waiting_request === null ? {} : { request: row.waiting_request })\n      }\n    }\n  })\n\n/**\n * The result of a successful execution observation.\n *\n * @private\n * @since 1.0.0\n */\nexport type Observed = Effect.Success<ReturnType<typeof observed>>\n\n/**\n * Validates source, identity, ordering and revision coherence at the batch boundary.\n *\n * @private\n * @since 1.0.0\n */\nexport const coherentBatch = (runIds: ReadonlyArray<string>, batch: Batch): Effect.Effect<Batch, RunStoreError> => {\n  const validPosition = Schema.is(Position)\n  if (\n    !validPosition(batch) || batch.snapshots.length !== runIds.length ||\n    batch.snapshots.some((row, index) =>\n      !validPosition(row) || row.runId !== runIds[index] || row.source !== batch.source ||\n      row.revision > batch.revision\n    )\n  ) {\n    return Effect.fail(\n      new RunStoreError({\n        method: \"ExecutionSnapshot.read\",\n        code: \"persistence_failed\",\n        message: \"stored execution batch is incoherent: source, identity, order or revision mismatch\",\n        cause: undefined\n      })\n    )\n  }\n  return Effect.succeed(batch)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/ExecutionSnapshotRelations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Page-scoped durable child and round enumeration.
+ *
+ * @since 1.0.0
+ */
+import { RunStoreError } from "@smthrs/run-store/RunStore";
+import { Effect } from "effect";
+import type * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { Batch, Snapshot } from "../ExecutionSnapshot.ts";
+/**
+ * Child edges and trampoline rounds are different relations.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface RelatedOptions {
+    readonly runId: string;
+    readonly kind: "children" | "rounds";
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+/**
+ * A requested anchor and its page, observed in one transaction.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface RelatedPage extends Batch {
+    readonly anchor: Snapshot;
+    readonly cursor: string | null;
+}
+/**
+ * Builds a bounded relation reader over the shared snapshot port.
+ *
+ * @private
+ * @since 1.0.0
+ */
+export declare const make: (sql: SqlClient.SqlClient, read: (ids: ReadonlyArray<string>) => Effect.Effect<Batch, RunStoreError>) => (options: RelatedOptions) => Effect.Effect<RelatedPage, RunStoreError>;
+//# sourceMappingURL=ExecutionSnapshotRelations.d.ts.map

package/dist/cjs/internal/ExecutionSnapshotRelations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionSnapshotRelations.d.ts","sourceRoot":"","sources":["../../../src/internal/ExecutionSnapshotRelations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAG9D;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAA;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AACD;;;;;GAKG;AACH,MAAM,WAAW,WAAY,SAAQ,KAAK;IACxC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAkBD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,SAAS,CAAC,SAAS,EACxB,MAAM,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,MAE1E,SAAS,cAAc,KAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,aAAa,CA0DhE,CAAA"}