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

package/dist/cjs/DurableEngineState.js

@@ -0,0 +1,1536 @@
+"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 DurableEngineState_exports = {};
+__export(DurableEngineState_exports, {
+  AttemptSurvivors: () => AttemptSurvivors,
+  ClockAddress: () => ClockAddress,
+  ClockRow: () => ClockRow,
+  DeferredAddress: () => DeferredAddress,
+  DeferredRow: () => DeferredRow,
+  DurableEngineState: () => DurableEngineState,
+  EngineStateFault: () => EngineStateFault,
+  RunParentCycleError: () => RunParentCycleError,
+  RunParentEdge: () => RunParentEdge,
+  Waiting: () => Waiting,
+  WaitingReason: () => WaitingReason,
+  WaitingRow: () => WaitingRow,
+  layer: () => layer,
+  layerMemory: () => layerMemory,
+  make: () => make,
+  makeMemory: () => makeMemory,
+  waitingTreeMaxDepth: () => waitingTreeMaxDepth
+});
+module.exports = __toCommonJS(DurableEngineState_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var import_JournalEvent = require("@smthrs/journal/JournalEvent");
+var Cause = __toESM(require("effect/Cause"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Result = __toESM(require("effect/Result"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Semaphore = __toESM(require("effect/Semaphore"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var EngineStateSchema = __toESM(require("./internal/EngineStateSchema.js"), 1);
+var import_Ordering = require("./internal/Ordering.js");
+const pendingCancellationLimit = (limit) => Number.isSafeInteger(limit) && limit >= 0 ? Effect.void : Effect.die(new RangeError("Pending cancellation limit must be a non-negative safe integer"));
+const UnknownFromJsonString = Schema.fromJsonString(Schema.Unknown);
+const NonNegativeSafeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const DeferredAddress = Schema.Struct({
+  flowName: Schema.NonEmptyString,
+  executionId: Schema.NonEmptyString,
+  deferredName: Schema.NonEmptyString
+});
+const DeferredRow = Schema.Struct({
+  ...DeferredAddress.fields,
+  exit: Schema.Unknown,
+  metadata: Schema.optionalKey(Schema.Unknown),
+  completedAtMs: NonNegativeSafeInt
+});
+const ClockAddress = Schema.Struct({
+  flowName: Schema.NonEmptyString,
+  executionId: Schema.NonEmptyString,
+  clockName: Schema.NonEmptyString
+});
+const ClockRow = Schema.Struct({
+  ...ClockAddress.fields,
+  deferredName: Schema.NonEmptyString,
+  dueAtMs: NonNegativeSafeInt,
+  completedAtMs: Schema.NullOr(NonNegativeSafeInt)
+});
+const WaitingReason = Schema.NonEmptyString;
+const Waiting = Schema.Struct({
+  reason: WaitingReason,
+  wakeAt: Schema.optional(NonNegativeSafeInt),
+  token: Schema.optional(Schema.NonEmptyString),
+  /**
+   * What the wait declared about itself: for a `HumanTask` park, the kind of
+   * answer it wants, the prompt, and the attempt budget.
+   *
+   * `reason` and `token` say that a person owes the run an answer and which
+   * wait point holds it. Neither says what was asked, and the question lives
+   * in an action payload of an execution that has released its owner, so a
+   * reader had nothing to render but the wait's own name. This is the question
+   * itself, as the JSON TEXT the declaring flow wrote, stored and cleared with
+   * the other waiting columns.
+   */
+  request: Schema.optional(Schema.String)
+});
+const WaitingRow = Schema.Struct({
+  runId: Schema.NonEmptyString,
+  reason: WaitingReason,
+  wakeAt: Schema.NullOr(NonNegativeSafeInt),
+  token: Schema.NullOr(Schema.NonEmptyString),
+  /** The question {@link Waiting} declared, absent on a park that declared none. */
+  request: Schema.optionalKey(Schema.Json)
+});
+const RunParentEdge = Schema.Struct({
+  childId: Schema.NonEmptyString,
+  parentId: Schema.NonEmptyString,
+  seq: NonNegativeSafeInt
+});
+const AttemptSurvivors = Schema.Struct({
+  /**
+   * The lowest surviving attempt number. Anything above 1 means the prune
+   * job removed a leading run of attempts; the engine store applies the
+   * pruned-prefix tolerance to it so both survivor paths agree (issue #96).
+   */
+  earliestAttempt: NonNegativeSafeInt,
+  earliestStartedAtMs: NonNegativeSafeInt,
+  latest: NonNegativeSafeInt
+});
+class RunParentCycleError extends Schema.TaggedError()(
+  "@smthrs/engine-store/RunParentCycleError",
+  {
+    path: Schema.Array(Schema.String)
+  }
+) {
+}
+class EngineStateFault extends Schema.TaggedError()(
+  "@smthrs/engine-store/EngineStateFault",
+  {
+    reason: Schema.Literals([
+      "value_not_serializable",
+      "value_not_decodable",
+      "deferred_completion_missing",
+      "run_parent_edge_missing"
+    ]),
+    field: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect())
+  }
+) {
+  get message() {
+    switch (this.reason) {
+      case "value_not_serializable":
+        return `${this.field} must be JSON-serializable`;
+      case "value_not_decodable":
+        return `could not decode ${this.field}`;
+      case "deferred_completion_missing":
+        return "deferred completion disappeared during first-writer transaction";
+      case "run_parent_edge_missing":
+        return "run parent edge disappeared during first-writer transaction";
+    }
+  }
+}
+class DurableEngineState extends Context.Service()(
+  "@smthrs/engine-store/DurableEngineState"
+) {
+}
+const deferredKey = (address) => JSON.stringify([address.flowName, address.executionId, address.deferredName]);
+const clockKey = (address) => JSON.stringify([address.flowName, address.executionId, address.clockName]);
+const DeferredDatabaseRow = Schema.Struct({
+  ...DeferredAddress.fields,
+  exitJson: Schema.String,
+  metadataJson: Schema.NullOr(Schema.String),
+  completedAtMs: NonNegativeSafeInt
+});
+const ClockDatabaseRow = Schema.Struct({
+  ...ClockAddress.fields,
+  deferredName: Schema.NonEmptyString,
+  dueAtMs: NonNegativeSafeInt,
+  completedAtMs: Schema.NullOr(NonNegativeSafeInt)
+});
+const WaitingDatabaseRow = Schema.Struct({
+  runId: Schema.NonEmptyString,
+  waitingReason: WaitingReason,
+  waitingWakeAtMs: Schema.NullOr(NonNegativeSafeInt),
+  waitingToken: Schema.NullOr(Schema.NonEmptyString),
+  /** Absent rather than null on a database written before `0004_waiting_request`. */
+  waitingRequest: Schema.optional(Schema.NullOr(Schema.String))
+});
+const decodeWaitingRequest = (value) => {
+  if (value === null || value === void 0) return {};
+  try {
+    return { request: JSON.parse(value) };
+  } catch {
+    return {};
+  }
+};
+const decodeWaitingRow = (input) => decodeWaitingRowResult(input).pipe(Effect.orDie);
+const decodeWaitingRowResult = (input) => Schema.decodeUnknownEffect(WaitingDatabaseRow)(input).pipe(
+  Effect.map((row) => ({
+    runId: row.runId,
+    reason: row.waitingReason,
+    wakeAt: row.waitingWakeAtMs,
+    token: row.waitingToken,
+    ...decodeWaitingRequest(row.waitingRequest)
+  }))
+);
+const RunParentDatabaseRow = Schema.Struct({
+  childId: Schema.NonEmptyString,
+  parentId: Schema.NonEmptyString,
+  seq: NonNegativeSafeInt
+});
+const decodeRunParentEdge = (input) => decodeRunParentEdgeResult(input).pipe(Effect.orDie);
+const decodeRunParentEdgeResult = (input) => Schema.decodeUnknownEffect(RunParentDatabaseRow)(input);
+const findCyclePath = (childId, parentId, parentsOf) => Effect.suspend(() => {
+  if (parentId === childId) {
+    return Effect.succeed([childId]);
+  }
+  const seen = /* @__PURE__ */ new Set([parentId]);
+  const walk = (current, chain) => Effect.gen(function* () {
+    const parents = yield* parentsOf(current);
+    for (const parent of parents) {
+      if (parent === childId) return [...chain, parent].reverse();
+      if (seen.has(parent)) continue;
+      seen.add(parent);
+      const found = yield* walk(parent, [...chain, parent]);
+      if (found !== void 0) return found;
+    }
+    return void 0;
+  });
+  return walk(parentId, [parentId]);
+});
+const DeferredAddressDatabaseRow = DeferredAddress;
+const deferredDigest = (row) => ({
+  exit: (0, import_JournalEvent.contentDigest)(row.exitJson),
+  metadata: row.metadataJson === null ? null : (0, import_JournalEvent.contentDigest)(row.metadataJson)
+});
+const memoryDigest = (row) => Effect.gen(function* () {
+  const exitJson = yield* encodeJson(row.exit, "exit");
+  const metadataJson = row.metadata === void 0 ? null : yield* encodeJson(row.metadata, "metadata");
+  return deferredDigest({ exitJson, metadataJson });
+});
+const encodeJson = (value, field) => Schema.encodeEffect(UnknownFromJsonString)(value).pipe(
+  Effect.mapError((cause) => new EngineStateFault({ reason: "value_not_serializable", field, cause })),
+  Effect.orDie
+);
+const decodeJson = (value, field) => Schema.decodeUnknownEffect(UnknownFromJsonString)(value).pipe(
+  Effect.mapError((cause) => new EngineStateFault({ reason: "value_not_decodable", field, cause })),
+  Effect.orDie
+);
+const restoreJsonExit = (value) => {
+  if (typeof value !== "object" || value === null) return value;
+  const record = value;
+  if (record["_id"] !== "Exit") return value;
+  if (record["_tag"] === "Success") return Exit.succeed(record["value"]);
+  if (record["_tag"] !== "Failure") return value;
+  const cause = record["cause"];
+  if (typeof cause !== "object" || cause === null) return value;
+  const failures = cause["failures"];
+  if (!Array.isArray(failures)) return value;
+  const reasons = [];
+  for (const failure of failures) {
+    if (typeof failure !== "object" || failure === null) return value;
+    const reason = failure;
+    switch (reason["_tag"]) {
+      case "Fail":
+        reasons.push(Cause.makeFailReason(reason["error"]));
+        break;
+      case "Die":
+        reasons.push(Cause.makeDieReason(reason["defect"]));
+        break;
+      case "Interrupt":
+        reasons.push(Cause.makeInterruptReason(
+          typeof reason["fiberId"] === "number" ? reason["fiberId"] : void 0
+        ));
+        break;
+      default:
+        return value;
+    }
+  }
+  return Exit.failCause(Cause.fromReasons(reasons));
+};
+const decodeDeferredRow = (input) => Schema.decodeUnknownEffect(DeferredDatabaseRow)(input).pipe(
+  Effect.orDie,
+  Effect.flatMap(
+    (row) => Effect.all({
+      exit: decodeJson(row.exitJson, "exit_json").pipe(Effect.map(restoreJsonExit)),
+      metadata: row.metadataJson === null ? Effect.succeed(void 0) : decodeJson(row.metadataJson, "metadata_json")
+    }).pipe(
+      Effect.map(({ exit, metadata }) => ({
+        flowName: row.flowName,
+        executionId: row.executionId,
+        deferredName: row.deferredName,
+        exit,
+        ...metadata === void 0 ? {} : { metadata },
+        completedAtMs: row.completedAtMs
+      }))
+    )
+  )
+);
+const decodeClockRow = (input) => decodeClockRowResult(input).pipe(Effect.orDie);
+const decodeClockRowResult = (input) => Schema.decodeUnknownEffect(ClockDatabaseRow)(input).pipe(
+  Effect.map((row) => ({
+    flowName: row.flowName,
+    executionId: row.executionId,
+    clockName: row.clockName,
+    deferredName: row.deferredName,
+    dueAtMs: row.dueAtMs,
+    completedAtMs: row.completedAtMs
+  }))
+);
+const clockRowKey = (row) => JSON.stringify([row["flowName"], row["executionId"], row["clockName"]]);
+const deferredAddressRowKey = (row) => JSON.stringify([row["flowName"], row["executionId"], row["deferredName"]]);
+const runParentRowKey = (row) => JSON.stringify([row["childId"], row["parentId"]]);
+const waitingTreeMaxDepth = 64;
+const waitingRowKey = (row) => JSON.stringify([row["runId"]]);
+const decodeSweep = (rows, kind, keyOf, decode) => Effect.gen(function* () {
+  const decoded = [];
+  for (const row of rows) {
+    const result = yield* Effect.result(decode(row));
+    if (Result.isSuccess(result)) {
+      decoded.push(result.success);
+      continue;
+    }
+    yield* Effect.logWarning(
+      `engine-store: skipping a malformed ${kind} row ${keyOf(row)}`,
+      result.failure
+    );
+  }
+  return decoded;
+});
+const dieOnDatabaseError = (cause) => Cause.fromReasons(
+  cause.reasons.map(
+    (reason) => Cause.isFailReason(reason) && reason.error instanceof import_DurableWriter.DatabaseError ? Cause.makeDieReason(reason.error).annotate(Cause.reasonAnnotations(reason)) : reason
+  )
+);
+const make = Effect.gen(function* () {
+  const sql = yield* Effect.service(SqlClient.SqlClient);
+  const writer = yield* import_DurableWriter.DurableWriter;
+  yield* EngineStateSchema.apply(sql, writer);
+  const selectDeferred = (address) => sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        deferred_name AS "deferredName",
+        exit_json AS "exitJson",
+        metadata_json AS "metadataJson",
+        completed_at_ms AS "completedAtMs"
+      FROM flows_deferred_completions
+      WHERE flow_name = ${address.flowName}
+        AND execution_id = ${address.executionId}
+        AND deferred_name = ${address.deferredName}
+    `;
+  const selectClock = (address) => sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        clock_name AS "clockName",
+        deferred_name AS "deferredName",
+        due_at_ms AS "dueAtMs",
+        completed_at_ms AS "completedAtMs"
+      FROM flows_clock_deadlines
+      WHERE flow_name = ${address.flowName}
+        AND execution_id = ${address.executionId}
+        AND clock_name = ${address.clockName}
+    `;
+  const deferred = Effect.fn("DurableEngineState.deferred")(
+    (address) => selectDeferred(address).pipe(
+      Effect.orDie,
+      Effect.flatMap(
+        (rows) => rows[0] === void 0 ? Effect.succeedNone : Effect.map(decodeDeferredRow(rows[0]), Option.some)
+      )
+    )
+  );
+  const consumeDeferred = Effect.fn("DurableEngineState.consumeDeferred")(
+    (address, consumedAtMs) => writer.write(sql`
+      UPDATE flows_deferred_completions
+      SET consumed_at_ms = ${consumedAtMs}
+      WHERE flow_name = ${address.flowName}
+        AND execution_id = ${address.executionId}
+        AND deferred_name = ${address.deferredName}
+        AND consumed_at_ms IS NULL
+      RETURNING flow_name AS "flowName"
+    `).pipe(Effect.orDie, Effect.map((rows) => rows.length > 0))
+  );
+  const completeDeferred = Effect.fn(
+    "DurableEngineState.completeDeferred"
+  )(
+    (row) => Effect.gen(function* () {
+      const exitJson = yield* encodeJson(row.exit, "exit");
+      const metadataJson = row.metadata === void 0 ? null : yield* encodeJson(row.metadata, "metadata");
+      return yield* writer.write(
+        Effect.gen(function* () {
+          const inserted = yield* sql`
+            INSERT INTO flows_deferred_completions (
+              flow_name,
+              execution_id,
+              deferred_name,
+              exit_json,
+              metadata_json,
+              completed_at_ms
+            ) VALUES (
+              ${row.flowName},
+              ${row.executionId},
+              ${row.deferredName},
+              ${exitJson},
+              ${metadataJson},
+              ${row.completedAtMs}
+            )
+            ON CONFLICT (flow_name, execution_id, deferred_name) DO NOTHING
+            RETURNING
+              flow_name AS "flowName",
+              execution_id AS "executionId",
+              deferred_name AS "deferredName",
+              exit_json AS "exitJson",
+              metadata_json AS "metadataJson",
+              completed_at_ms AS "completedAtMs"
+          `;
+          if (inserted[0] !== void 0) {
+            return {
+              _tag: "Completed",
+              row: yield* decodeDeferredRow(inserted[0]),
+              digest: deferredDigest(inserted[0])
+            };
+          }
+          const existing = yield* selectDeferred(row);
+          if (existing[0] === void 0) {
+            return yield* Effect.die(new EngineStateFault({ reason: "deferred_completion_missing" }));
+          }
+          return {
+            _tag: "Existing",
+            row: yield* decodeDeferredRow(existing[0]),
+            digest: deferredDigest(existing[0])
+          };
+        })
+      ).pipe(Effect.orDie);
+    })
+  );
+  const clock = Effect.fn("DurableEngineState.clock")(
+    (address) => selectClock(address).pipe(
+      Effect.orDie,
+      Effect.flatMap(
+        (rows) => rows[0] === void 0 ? Effect.succeedNone : Effect.map(decodeClockRow(rows[0]), Option.some)
+      )
+    )
+  );
+  const scheduleClock = Effect.fn("DurableEngineState.scheduleClock")(
+    (row, owner) => writer.write(
+      Effect.gen(function* () {
+        const inserted = yield* sql`
+          INSERT INTO flows_clock_deadlines (
+            flow_name,
+            execution_id,
+            clock_name,
+            deferred_name,
+            due_at_ms,
+            completed_at_ms
+          )
+          SELECT
+            ${row.flowName},
+            ${row.executionId},
+            ${row.clockName},
+            ${row.deferredName},
+            ${row.dueAtMs},
+            ${row.completedAtMs}
+          WHERE EXISTS (
+            SELECT 1
+            FROM flows_runs
+            WHERE run_id = ${row.executionId}
+              AND status = 'running'
+              AND owner_host_id = ${owner.hostId}
+              AND owner_pid = ${owner.pid}
+              AND owner_nonce = ${owner.nonce}
+          )
+          ON CONFLICT (flow_name, execution_id, clock_name) DO NOTHING
+          RETURNING
+            flow_name AS "flowName",
+            execution_id AS "executionId",
+            clock_name AS "clockName",
+            deferred_name AS "deferredName",
+            due_at_ms AS "dueAtMs",
+            completed_at_ms AS "completedAtMs"
+        `;
+        if (inserted[0] !== void 0) {
+          return {
+            _tag: "Scheduled",
+            row: yield* decodeClockRow(inserted[0])
+          };
+        }
+        const existing = yield* selectClock(row);
+        if (existing[0] !== void 0) {
+          return {
+            _tag: "Existing",
+            row: yield* decodeClockRow(existing[0])
+          };
+        }
+        return yield* Effect.interrupt;
+      })
+    ).pipe(Effect.orDie)
+  );
+  const completeClock = Effect.fn("DurableEngineState.completeClock")(
+    (address, completedAtMs) => writer.write(
+      Effect.gen(function* () {
+        const updated = yield* sql`
+          UPDATE flows_clock_deadlines
+          SET completed_at_ms = ${completedAtMs}
+          WHERE flow_name = ${address.flowName}
+            AND execution_id = ${address.executionId}
+            AND clock_name = ${address.clockName}
+            AND completed_at_ms IS NULL
+          RETURNING
+            flow_name AS "flowName",
+            execution_id AS "executionId",
+            clock_name AS "clockName",
+            deferred_name AS "deferredName",
+            due_at_ms AS "dueAtMs",
+            completed_at_ms AS "completedAtMs"
+        `;
+        if (updated[0] !== void 0) {
+          return {
+            _tag: "Completed",
+            row: yield* decodeClockRow(updated[0])
+          };
+        }
+        const existing = yield* selectClock(address);
+        return existing[0] === void 0 ? { _tag: "NotFound" } : {
+          _tag: "AlreadyCompleted",
+          row: yield* decodeClockRow(existing[0])
+        };
+      })
+    ).pipe(Effect.orDie)
+  );
+  const dueClocks = Effect.fn("DurableEngineState.dueClocks")(
+    (nowMs) => sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        clock_name AS "clockName",
+        deferred_name AS "deferredName",
+        due_at_ms AS "dueAtMs",
+        completed_at_ms AS "completedAtMs"
+      FROM flows_clock_deadlines
+      WHERE completed_at_ms IS NULL
+        AND due_at_ms <= ${nowMs}
+      ORDER BY due_at_ms, execution_id, clock_name
+    `.pipe(
+      Effect.orDie,
+      // This is the whole store's due-timer sweep: dying on one unreadable
+      // deadline stopped every timer in every flow from firing.
+      Effect.flatMap((rows) => decodeSweep(rows, "clock deadline", clockRowKey, decodeClockRowResult))
+    )
+  );
+  const pendingClocks = Effect.fn("DurableEngineState.pendingClocks")(
+    (scope) => (scope.executionId !== void 0 ? sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        clock_name AS "clockName",
+        deferred_name AS "deferredName",
+        due_at_ms AS "dueAtMs",
+        completed_at_ms AS "completedAtMs"
+      FROM flows_clock_deadlines
+      WHERE completed_at_ms IS NULL
+        AND execution_id = ${scope.executionId}
+        AND ${scope.flowName === void 0 ? sql`1 = 1` : sql`flow_name = ${scope.flowName}`}
+        AND EXISTS (
+          SELECT 1 FROM flows_runs
+          WHERE flows_runs.run_id = flows_clock_deadlines.execution_id
+            AND flows_runs.status NOT IN ('completed', 'failed', 'cancelled')
+        )
+      ORDER BY due_at_ms, execution_id, clock_name
+    ` : scope.flowName !== void 0 ? sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        clock_name AS "clockName",
+        deferred_name AS "deferredName",
+        due_at_ms AS "dueAtMs",
+        completed_at_ms AS "completedAtMs"
+      FROM flows_clock_deadlines
+      WHERE completed_at_ms IS NULL
+        AND flow_name = ${scope.flowName}
+        AND EXISTS (
+          SELECT 1 FROM flows_runs
+          WHERE flows_runs.run_id = flows_clock_deadlines.execution_id
+            AND flows_runs.status NOT IN ('completed', 'failed', 'cancelled')
+        )
+      ORDER BY due_at_ms, execution_id, clock_name
+    ` : sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        clock_name AS "clockName",
+        deferred_name AS "deferredName",
+        due_at_ms AS "dueAtMs",
+        completed_at_ms AS "completedAtMs"
+      FROM flows_clock_deadlines
+      WHERE completed_at_ms IS NULL
+        AND EXISTS (
+          SELECT 1 FROM flows_runs
+          WHERE flows_runs.run_id = flows_clock_deadlines.execution_id
+            AND flows_runs.status NOT IN ('completed', 'failed', 'cancelled')
+        )
+      ORDER BY due_at_ms, execution_id, clock_name
+    `).pipe(
+      Effect.orDie,
+      // A row that will not decode is a storage-integrity event about that
+      // row. Dying here made one of them fatal for the whole sweep, and so
+      // for `register` itself (issue B-08).
+      Effect.flatMap((rows) => decodeSweep(rows, "clock deadline", clockRowKey, decodeClockRowResult))
+    )
+  );
+  const completedDeferreds = Effect.fn(
+    "DurableEngineState.completedDeferreds"
+  )(
+    (flowName) => sql`
+      SELECT
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        deferred_name AS "deferredName"
+      FROM flows_deferred_completions
+      WHERE flow_name = ${flowName}
+        AND consumed_at_ms IS NULL
+        AND EXISTS (
+          SELECT 1 FROM flows_runs
+          WHERE flows_runs.run_id = flows_deferred_completions.execution_id
+            AND flows_runs.status NOT IN ('completed', 'failed', 'cancelled')
+        )
+      ORDER BY execution_id, deferred_name
+    `.pipe(
+      Effect.orDie,
+      Effect.flatMap(
+        (rows) => decodeSweep(
+          rows,
+          "deferred completion",
+          deferredAddressRowKey,
+          (row) => Schema.decodeUnknownEffect(DeferredAddressDatabaseRow)(row)
+        )
+      )
+    )
+  );
+  const completeRunClocks = Effect.fn(
+    "DurableEngineState.completeRunClocks"
+  )(
+    (executionId, completedAtMs) => writer.write(sql`
+      UPDATE flows_clock_deadlines
+      SET completed_at_ms = ${completedAtMs}
+      WHERE execution_id = ${executionId}
+        AND completed_at_ms IS NULL
+      RETURNING
+        flow_name AS "flowName",
+        execution_id AS "executionId",
+        clock_name AS "clockName",
+        deferred_name AS "deferredName",
+        due_at_ms AS "dueAtMs",
+        completed_at_ms AS "completedAtMs"
+    `).pipe(
+      Effect.orDie,
+      Effect.flatMap((rows) => Effect.forEach(rows, decodeClockRow)),
+      Effect.map(
+        (rows) => [...rows].sort(
+          (left, right) => (0, import_Ordering.compareText)(left.flowName, right.flowName) || (0, import_Ordering.compareText)(left.clockName, right.clockName)
+        )
+      )
+    )
+  );
+  const selectWaiting = (runId) => sql`
+      SELECT
+        run_id AS "runId",
+        waiting_reason AS "waitingReason",
+        waiting_wake_at_ms AS "waitingWakeAtMs",
+        waiting_token AS "waitingToken",
+        waiting_request AS "waitingRequest"
+      FROM flows_runs
+      WHERE run_id = ${runId}
+        AND waiting_reason IS NOT NULL
+    `;
+  const park = Effect.fn("DurableEngineState.park")(
+    (runId, waiting2, owner) => writer.write(
+      Effect.gen(function* () {
+        const updated = yield* sql`
+          UPDATE flows_runs
+          SET
+            waiting_reason = ${waiting2.reason},
+            waiting_wake_at_ms = ${waiting2.wakeAt ?? null},
+            waiting_token = ${waiting2.token ?? null},
+            waiting_request = ${waiting2.request ?? null}
+          WHERE run_id = ${runId}
+            AND owner_host_id = ${owner.hostId}
+            AND owner_pid = ${owner.pid}
+            AND owner_nonce = ${owner.nonce}
+          RETURNING
+            run_id AS "runId",
+            waiting_reason AS "waitingReason",
+            waiting_wake_at_ms AS "waitingWakeAtMs",
+            waiting_token AS "waitingToken",
+            waiting_request AS "waitingRequest"
+        `;
+        if (updated[0] === void 0) {
+          return { _tag: "NotFound" };
+        }
+        return { _tag: "Parked", row: yield* decodeWaitingRow(updated[0]) };
+      })
+    ).pipe(Effect.orDie)
+  );
+  const wake = Effect.fn("DurableEngineState.wake")(
+    (runId) => writer.write(
+      Effect.gen(function* () {
+        const before = yield* selectWaiting(runId);
+        if (before[0] === void 0) {
+          const existing = yield* sql`
+            SELECT run_id AS "runId" FROM flows_runs WHERE run_id = ${runId}
+          `;
+          return existing[0] === void 0 ? { _tag: "NotFound" } : { _tag: "NotWaiting" };
+        }
+        const row = yield* decodeWaitingRow(before[0]);
+        yield* sql`
+          UPDATE flows_runs
+          SET
+            waiting_reason = NULL,
+            waiting_wake_at_ms = NULL,
+            waiting_token = NULL,
+            waiting_request = NULL
+          WHERE run_id = ${runId}
+            AND waiting_reason IS NOT NULL
+        `;
+        return { _tag: "Woken", row };
+      })
+    ).pipe(Effect.orDie)
+  );
+  const waiting = Effect.fn("DurableEngineState.waiting")(
+    (runId) => selectWaiting(runId).pipe(
+      Effect.orDie,
+      Effect.flatMap(
+        (rows) => rows[0] === void 0 ? Effect.succeedNone : Effect.map(decodeWaitingRow(rows[0]), Option.some)
+      )
+    )
+  );
+  const waitingTree = Effect.fn("DurableEngineState.waitingTree")(
+    (runId, options) => sql`
+      WITH RECURSIVE tree(run_id, depth) AS (
+        SELECT run_id, 0 FROM flows_runs WHERE run_id = ${runId}
+        UNION
+        SELECT child.run_id, tree.depth + 1
+        FROM tree
+        JOIN flows_runs child ON child.run_id IN (
+          SELECT child_id FROM flows_run_parents WHERE parent_id = tree.run_id
+          UNION ALL
+          SELECT run_id FROM flows_runs WHERE parent_run_id = tree.run_id
+        )
+        WHERE tree.depth < ${waitingTreeMaxDepth}
+          AND (${options?.detached === "include" ? 1 : 0} = 1
+            OR child.parent_run_id = tree.run_id
+            OR COALESCE(${Dialect.jsonText(sql, sql`child.state_json`, "$.onParentExit")}, 'cancel') <> 'detach')
+      ), reachable(run_id, depth) AS (
+        SELECT run_id, MIN(depth) FROM tree GROUP BY run_id
+      )
+      SELECT
+        parked.run_id AS "runId",
+        parked.waiting_reason AS "waitingReason",
+        parked.waiting_wake_at_ms AS "waitingWakeAtMs",
+        parked.waiting_token AS "waitingToken",
+        parked.waiting_request AS "waitingRequest"
+      FROM reachable
+      JOIN flows_runs parked ON parked.run_id = reachable.run_id
+      WHERE parked.waiting_reason IS NOT NULL
+        AND parked.status NOT IN ('completed', 'failed', 'cancelled')
+      ORDER BY reachable.depth, parked.created_at_ms, parked.run_id
+    `.pipe(
+      Effect.orDie,
+      Effect.flatMap((rows) => decodeSweep(rows, "waiting run", waitingRowKey, decodeWaitingRowResult))
+    )
+  );
+  const waitingRuns = Effect.fn("DurableEngineState.waitingRuns")((filter) => {
+    const cancelRequestedOnly = filter?.cancelRequested === true ? 1 : 0;
+    return (filter?.reason !== void 0 && filter.dueBeforeMs !== void 0 ? sql`
+        SELECT
+          run_id AS "runId",
+          waiting_reason AS "waitingReason",
+          waiting_wake_at_ms AS "waitingWakeAtMs",
+          waiting_token AS "waitingToken",
+          waiting_request AS "waitingRequest"
+        FROM flows_runs
+        WHERE waiting_reason = ${filter.reason}
+          AND waiting_wake_at_ms IS NOT NULL
+          AND waiting_wake_at_ms <= ${filter.dueBeforeMs}
+          AND (${cancelRequestedOnly} = 0 OR cancel_requested_at_ms IS NOT NULL)
+          AND status NOT IN ('completed', 'failed', 'cancelled')
+        ORDER BY waiting_wake_at_ms, run_id
+      ` : filter?.reason !== void 0 ? sql`
+        SELECT
+          run_id AS "runId",
+          waiting_reason AS "waitingReason",
+          waiting_wake_at_ms AS "waitingWakeAtMs",
+          waiting_token AS "waitingToken",
+          waiting_request AS "waitingRequest"
+        FROM flows_runs
+        WHERE waiting_reason = ${filter.reason}
+          AND (${cancelRequestedOnly} = 0 OR cancel_requested_at_ms IS NOT NULL)
+          AND status NOT IN ('completed', 'failed', 'cancelled')
+        ORDER BY waiting_wake_at_ms IS NULL, waiting_wake_at_ms, run_id
+      ` : filter?.dueBeforeMs !== void 0 ? sql`
+        SELECT
+          run_id AS "runId",
+          waiting_reason AS "waitingReason",
+          waiting_wake_at_ms AS "waitingWakeAtMs",
+          waiting_token AS "waitingToken",
+          waiting_request AS "waitingRequest"
+        FROM flows_runs
+        WHERE waiting_reason IS NOT NULL
+          AND waiting_wake_at_ms IS NOT NULL
+          AND waiting_wake_at_ms <= ${filter.dueBeforeMs}
+          AND (${cancelRequestedOnly} = 0 OR cancel_requested_at_ms IS NOT NULL)
+          AND status NOT IN ('completed', 'failed', 'cancelled')
+        ORDER BY waiting_wake_at_ms, run_id
+      ` : sql`
+        SELECT
+          run_id AS "runId",
+          waiting_reason AS "waitingReason",
+          waiting_wake_at_ms AS "waitingWakeAtMs",
+          waiting_token AS "waitingToken",
+          waiting_request AS "waitingRequest"
+        FROM flows_runs
+        WHERE waiting_reason IS NOT NULL
+          AND (${cancelRequestedOnly} = 0 OR cancel_requested_at_ms IS NOT NULL)
+          AND status NOT IN ('completed', 'failed', 'cancelled')
+        ORDER BY waiting_wake_at_ms IS NULL, waiting_wake_at_ms, run_id
+      `).pipe(
+      Effect.orDie,
+      // The parked-run sweeper's only enumeration: one unreadable waiting
+      // payload stranded every parked run, including the ones whose
+      // cancellation had already been requested.
+      Effect.flatMap((rows) => decodeSweep(rows, "waiting run", waitingRowKey, decodeWaitingRowResult))
+    );
+  });
+  const pendingRows = (flowName, limit, after, through, descending = false, eligibleBeforeMs) => sql`
+      SELECT run_id AS "runId", created_at_ms AS "createdAtMs" FROM flows_runs
+        ${Dialect.isPostgres(sql) ? sql`` : sql`INDEXED BY flows_runs_listing_3`}
+      WHERE status = 'pending'
+        AND ${eligibleBeforeMs === void 0 ? sql`TRUE` : sql`created_at_ms < ${eligibleBeforeMs}`}
+        AND execution_flow = ${flowName}
+        AND ${after === void 0 ? sql`TRUE` : sql`(
+          created_at_ms > ${after.createdAtMs}
+          OR (created_at_ms = ${after.createdAtMs} AND run_id > ${after.runId})
+        )`}
+        AND ${through === void 0 ? sql`TRUE` : sql`(
+          created_at_ms < ${through.createdAtMs}
+          OR (created_at_ms = ${through.createdAtMs} AND run_id <= ${through.runId})
+        )`}
+      ORDER BY ${descending ? sql`created_at_ms DESC, run_id DESC` : sql`created_at_ms, run_id`}
+      LIMIT ${limit ?? (Dialect.isPostgres(sql) ? null : -1)}
+    `.pipe(
+    Effect.orDie,
+    Effect.map((rows) => rows.map((row) => ({ runId: row.runId, createdAtMs: Number(row.createdAtMs) })))
+  );
+  const pendingRuns = Effect.fn("DurableEngineState.pendingRuns")((flowName, limit, after, through, eligibleBeforeMs) => pendingRows(flowName, limit, after, through, false, eligibleBeforeMs));
+  const pendingRunTail = Effect.fn("DurableEngineState.pendingRunTail")(
+    (flowName, eligibleBeforeMs) => pendingRows(flowName, 1, void 0, void 0, true, eligibleBeforeMs).pipe(
+      Effect.map((rows) => Option.fromNullishOr(rows[0]))
+    )
+  );
+  const pendingCancellationRows = (limit, after, through, descending = false) => pendingCancellationLimit(limit).pipe(
+    Effect.andThen(sql`
+      SELECT run_id AS "runId", created_at_ms AS "createdAtMs" FROM flows_runs
+        ${Dialect.isPostgres(sql) ? sql`` : sql`INDEXED BY flows_runs_pending_cancel_idx`}
+      WHERE status = 'pending' AND cancel_requested_at_ms IS NOT NULL
+        AND ${after === void 0 ? sql`TRUE` : sql`(created_at_ms, run_id) > (${after.createdAtMs}, ${after.runId})`}
+        AND ${through === void 0 ? sql`TRUE` : sql`(created_at_ms, run_id) <= (${through.createdAtMs}, ${through.runId})`}
+      ORDER BY ${descending ? sql`created_at_ms DESC, run_id DESC` : sql`created_at_ms, run_id`}
+      LIMIT ${limit}
+    `.pipe(
+      Effect.orDie,
+      Effect.map((rows) => rows.map((row) => ({ runId: row.runId, createdAtMs: Number(row.createdAtMs) })))
+    ))
+  );
+  const pendingCancellationRuns = Effect.fn(
+    "DurableEngineState.pendingCancellationRuns"
+  )((limit, after, through) => pendingCancellationRows(limit, after, through));
+  const pendingCancellationTail = Effect.fn(
+    "DurableEngineState.pendingCancellationTail"
+  )(
+    () => pendingCancellationRows(1, void 0, void 0, true).pipe(
+      Effect.map((rows) => Option.fromNullishOr(rows[0]))
+    )
+  );
+  const staleRunningRuns = Effect.fn(
+    "DurableEngineState.staleRunningRuns"
+  )(
+    (staleBeforeMs, limit) => (
+      // `LIMIT -1` is SQLite's explicit "no limit"; the partial index created
+      // in `make` serves the predicate, so the per-tick sweep is an index
+      // range read instead of a full table scan (issue #79).
+      sql`
+      SELECT run_id AS "runId", heartbeat_at_ms AS "heartbeatAtMs"
+      FROM flows_runs
+      WHERE status = 'running'
+        AND heartbeat_at_ms IS NOT NULL
+        AND heartbeat_at_ms < ${staleBeforeMs}
+      ORDER BY heartbeat_at_ms, run_id
+      LIMIT ${limit ?? (Dialect.isPostgres(sql) ? null : -1)}
+    `.pipe(
+        Effect.orDie,
+        Effect.map((rows) => rows.map((row) => ({ runId: String(row.runId), heartbeatAtMs: Number(row.heartbeatAtMs) })))
+      )
+    )
+  );
+  const attemptSurvivors = Effect.fn(
+    "DurableEngineState.attemptSurvivors"
+  )(
+    (runId, stepKeyDigest) => sql`
+      SELECT attempt AS "attempt", started_at_ms AS "startedAtMs"
+      FROM flows_attempts
+      WHERE run_id = ${runId}
+        AND step_key_digest = ${stepKeyDigest}
+      ORDER BY attempt
+    `.pipe(
+      Effect.orDie,
+      Effect.map((rows) => {
+        const first = rows[0];
+        if (first === void 0) return Option.none();
+        let latest = Number(first.attempt);
+        for (let index = 1; index < rows.length; index++) {
+          const next = Number(rows[index].attempt);
+          if (next !== latest + 1) break;
+          latest = next;
+        }
+        return Option.some({
+          earliestAttempt: Number(first.attempt),
+          earliestStartedAtMs: Number(first.startedAtMs),
+          latest
+        });
+      })
+    )
+  );
+  const selectRunParent = (childId, parentId) => sql`
+      SELECT
+        child_id AS "childId",
+        parent_id AS "parentId",
+        seq AS "seq"
+      FROM flows_run_parents
+      WHERE child_id = ${childId}
+        AND parent_id = ${parentId}
+    `;
+  const parentIdsOf = (id) => sql`
+      SELECT
+        child_id AS "childId",
+        parent_id AS "parentId",
+        seq AS "seq"
+      FROM flows_run_parents
+      WHERE child_id = ${id}
+      ORDER BY seq
+    `.pipe(
+    Effect.orDie,
+    Effect.map((rows) => rows.map((row) => String(row.parentId)))
+  );
+  const recordRunParent = Effect.fn(
+    "DurableEngineState.recordRunParent"
+  )(
+    (childId, parentId) => writer.write(
+      Effect.gen(function* () {
+        const inserted = yield* sql`
+          INSERT INTO flows_run_parents (child_id, parent_id, seq)
+          SELECT ${childId}, ${parentId}, COALESCE(MAX(seq), 0) + 1
+          FROM flows_run_parents
+          WHERE TRUE
+          ON CONFLICT (child_id, parent_id) DO NOTHING
+          RETURNING
+            child_id AS "childId",
+            parent_id AS "parentId",
+            seq AS "seq"
+        `;
+        if (inserted[0] !== void 0) {
+          const cycle = yield* findCyclePath(childId, parentId, parentIdsOf);
+          if (cycle !== void 0) {
+            return yield* Effect.fail(new RunParentCycleError({ path: cycle }));
+          }
+          return {
+            _tag: "Recorded",
+            edge: yield* decodeRunParentEdge(inserted[0])
+          };
+        }
+        const existing = yield* selectRunParent(childId, parentId);
+        if (existing[0] === void 0) {
+          return yield* Effect.die(new EngineStateFault({ reason: "run_parent_edge_missing" }));
+        }
+        return {
+          _tag: "Existing",
+          edge: yield* decodeRunParentEdge(existing[0])
+        };
+      })
+    ).pipe(
+      Effect.catch((error) => error instanceof RunParentCycleError ? Effect.fail(error) : Effect.die(error))
+    )
+  );
+  const removeRunParentsForRun = Effect.fn(
+    "DurableEngineState.removeRunParentsForRun"
+  )(
+    (runId) => writer.write(sql`
+      DELETE FROM flows_run_parents
+      WHERE child_id = ${runId}
+        OR parent_id = ${runId}
+    `).pipe(Effect.orDie, Effect.asVoid)
+  );
+  const transactionGate = Semaphore.makeUnsafe(1);
+  const transaction = (effect) => Effect.flatMap(Effect.serviceOption(sql.transactionService), (enclosing) => {
+    const write = (body) => writer.write(body).pipe(
+      Effect.catchCause((cause) => {
+        if (cause.reasons.length === 1) {
+          const reason = cause.reasons[0];
+          if (Cause.isFailReason(reason) && reason.error instanceof import_DurableWriter.DatabaseError) {
+            return Effect.die(reason.error);
+          }
+        }
+        return Effect.failCause(dieOnDatabaseError(cause));
+      })
+    );
+    if (Option.isSome(enclosing)) return write(effect);
+    return Effect.uninterruptibleMask(
+      (restore) => Effect.gen(function* () {
+        yield* restore(transactionGate.take(1));
+        let released = false;
+        const release = Effect.suspend(() => {
+          if (released) return Effect.void;
+          released = true;
+          return transactionGate.release(1).pipe(Effect.asVoid);
+        });
+        return yield* restore(write(Effect.gen(function* () {
+          yield* (0, import_DurableWriter.afterCommit)(release, sql);
+          return yield* effect;
+        }))).pipe(Effect.ensuring(release));
+      })
+    );
+  });
+  const runParents = Effect.fn("DurableEngineState.runParents")(
+    (childId) => sql`
+      SELECT
+        child_id AS "childId",
+        parent_id AS "parentId",
+        seq AS "seq"
+      FROM flows_run_parents
+      WHERE child_id = ${childId}
+      ORDER BY seq
+    `.pipe(
+      Effect.orDie,
+      // One unreadable edge made a run's whole ancestry unreadable, so no
+      // subflow under it could be linked at all.
+      Effect.flatMap((rows) => decodeSweep(rows, "run parent", runParentRowKey, decodeRunParentEdgeResult))
+    )
+  );
+  const runChildren = Effect.fn("DurableEngineState.runChildren")(
+    (parentId) => sql`
+      SELECT
+        child_id AS "childId",
+        parent_id AS "parentId",
+        seq AS "seq"
+      FROM flows_run_parents
+      WHERE parent_id = ${parentId}
+      ORDER BY seq
+    `.pipe(
+      Effect.orDie,
+      // The cancellation cascade's only cross-process way to find a run's
+      // children: one unreadable sibling edge left every child running after
+      // its parent was cancelled.
+      Effect.flatMap((rows) => decodeSweep(rows, "run parent", runParentRowKey, decodeRunParentEdgeResult))
+    )
+  );
+  return DurableEngineState.of({
+    deferred,
+    consumeDeferred,
+    completeDeferred,
+    clock,
+    scheduleClock,
+    completeClock,
+    completeRunClocks,
+    dueClocks,
+    pendingClocks,
+    completedDeferreds,
+    park,
+    wake,
+    waiting,
+    waitingTree,
+    waitingRuns,
+    pendingRuns,
+    pendingRunTail,
+    pendingCancellationRuns,
+    pendingCancellationTail,
+    staleRunningRuns,
+    attemptSurvivors,
+    recordRunParent,
+    removeRunParentsForRun,
+    runParents,
+    runChildren,
+    transaction
+  });
+});
+const layer = Layer.effect(
+  DurableEngineState,
+  make
+);
+const makeMemory = (options = {}) => {
+  const deferreds = /* @__PURE__ */ new Map();
+  const consumedDeferreds = /* @__PURE__ */ new Map();
+  const clocks = /* @__PURE__ */ new Map();
+  const waitingRows = /* @__PURE__ */ new Map();
+  const parentEdges = /* @__PURE__ */ new Map();
+  let parentSeq = 0;
+  const snapshotDeferred = (row) => Schema.decodeUnknownEffect(DeferredRow)(row).pipe(
+    Effect.orDie,
+    Effect.flatMap(
+      (decoded) => Effect.all({
+        exitJson: encodeJson(decoded.exit, "exit"),
+        metadataJson: decoded.metadata === void 0 ? Effect.succeed(null) : encodeJson(decoded.metadata, "metadata")
+      }).pipe(
+        Effect.flatMap(
+          ({ exitJson, metadataJson }) => decodeDeferredRow({
+            flowName: decoded.flowName,
+            executionId: decoded.executionId,
+            deferredName: decoded.deferredName,
+            exitJson,
+            metadataJson,
+            completedAtMs: decoded.completedAtMs
+          })
+        )
+      )
+    )
+  );
+  const snapshotClock = (row) => Schema.decodeUnknownEffect(ClockRow)(row).pipe(
+    Effect.orDie,
+    Effect.map((decoded) => ({ ...decoded }))
+  );
+  const snapshotWaiting = (row) => ({ ...row });
+  const findCyclePathSync = (childId, parentId) => {
+    if (parentId === childId) return [childId];
+    const seen = /* @__PURE__ */ new Set([parentId]);
+    const walk = (current, chain) => {
+      for (const parent of parentEdges.get(current)?.keys() ?? []) {
+        if (parent === childId) return [...chain, parent].reverse();
+        if (seen.has(parent)) continue;
+        seen.add(parent);
+        const found = walk(parent, [...chain, parent]);
+        if (found !== void 0) return found;
+      }
+      return void 0;
+    };
+    return walk(parentId, [parentId]);
+  };
+  const sameOwner = (left, right) => left.hostId === right.hostId && left.pid === right.pid && left.nonce === right.nonce;
+  const runView = (runId, presented) => {
+    if (options.runs === void 0) {
+      return { exists: true, running: true, owned: true };
+    }
+    const view = options.runs(runId);
+    if (Option.isNone(view)) {
+      return { exists: false, running: false, owned: false };
+    }
+    const owned = presented !== void 0 && view.value.owner !== null && sameOwner(view.value.owner, presented);
+    return { exists: true, running: view.value.status === "running", owned };
+  };
+  const isLive = (runId) => {
+    if (options.runs === void 0) return true;
+    const view = options.runs(runId);
+    return Option.isSome(view) && (view.value.status === "pending" || view.value.status === "running" || view.value.status === "suspended");
+  };
+  const pendingMemoryRows = (flowName, after, through, eligibleBeforeMs, cancellationOnly = false) => Array.from(options.listRuns?.() ?? []).filter(
+    ([runId, view]) => view.status === "pending" && (flowName === void 0 || view.flowName === flowName) && (!cancellationOnly || view.cancelRequestedAtMs != null) && (eligibleBeforeMs === void 0 || (view.createdAtMs ?? 0) < eligibleBeforeMs) && (after === void 0 || (view.createdAtMs ?? 0) > after.createdAtMs || (view.createdAtMs ?? 0) === after.createdAtMs && (0, import_Ordering.compareText)(runId, after.runId) > 0) && (through === void 0 || (view.createdAtMs ?? 0) < through.createdAtMs || (view.createdAtMs ?? 0) === through.createdAtMs && (0, import_Ordering.compareText)(runId, through.runId) <= 0)
+  ).sort(
+    ([leftId, left], [rightId, right]) => (left.createdAtMs ?? 0) - (right.createdAtMs ?? 0) || (0, import_Ordering.compareText)(leftId, rightId)
+  ).map(([runId, view]) => ({ runId, createdAtMs: view.createdAtMs ?? 0 }));
+  const unguarded = {
+    deferred: Effect.fn("DurableEngineState.deferred")(
+      (address) => Effect.gen(function* () {
+        const row = deferreds.get(deferredKey(address));
+        return row === void 0 ? Option.none() : Option.some(yield* snapshotDeferred(row));
+      })
+    ),
+    consumeDeferred: Effect.fn("DurableEngineState.consumeDeferred")(
+      (address, consumedAtMs) => Effect.sync(() => {
+        const key = deferredKey(address);
+        if (!deferreds.has(key) || consumedDeferreds.has(key)) return false;
+        consumedDeferreds.set(key, consumedAtMs);
+        return true;
+      })
+    ),
+    completeDeferred: Effect.fn("DurableEngineState.completeDeferred")(
+      (row) => Effect.gen(function* () {
+        const stored = yield* snapshotDeferred(row);
+        const key = deferredKey(stored);
+        const existing = deferreds.get(key);
+        if (existing !== void 0) {
+          return {
+            _tag: "Existing",
+            row: yield* snapshotDeferred(existing),
+            digest: yield* memoryDigest(existing)
+          };
+        }
+        deferreds.set(key, stored);
+        return {
+          _tag: "Completed",
+          row: yield* snapshotDeferred(stored),
+          digest: yield* memoryDigest(stored)
+        };
+      })
+    ),
+    clock: Effect.fn("DurableEngineState.clock")(
+      (address) => Effect.gen(function* () {
+        const row = clocks.get(clockKey(address));
+        return row === void 0 ? Option.none() : Option.some(yield* snapshotClock(row));
+      })
+    ),
+    scheduleClock: Effect.fn("DurableEngineState.scheduleClock")(
+      (row, owner) => Effect.gen(function* () {
+        const stored = yield* snapshotClock(row);
+        const key = clockKey(stored);
+        const existing = clocks.get(key);
+        if (existing !== void 0) {
+          return { _tag: "Existing", row: yield* snapshotClock(existing) };
+        }
+        const view = runView(stored.executionId, owner);
+        if (!view.exists || !view.running || !view.owned) {
+          return yield* Effect.interrupt;
+        }
+        clocks.set(key, stored);
+        return { _tag: "Scheduled", row: yield* snapshotClock(stored) };
+      })
+    ),
+    completeClock: Effect.fn("DurableEngineState.completeClock")(
+      (address, completedAtMs) => Effect.sync(() => {
+        const key = clockKey(address);
+        const existing = clocks.get(key);
+        if (existing === void 0) {
+          return { _tag: "NotFound" };
+        }
+        if (existing.completedAtMs !== null) {
+          return { _tag: "AlreadyCompleted", row: { ...existing } };
+        }
+        const row = { ...existing, completedAtMs };
+        clocks.set(key, row);
+        return { _tag: "Completed", row: { ...row } };
+      })
+    ),
+    dueClocks: Effect.fn("DurableEngineState.dueClocks")(
+      (nowMs) => Effect.forEach(
+        Array.from(clocks.values()).filter((row) => row.completedAtMs === null && row.dueAtMs <= nowMs).sort(
+          (left, right) => left.dueAtMs - right.dueAtMs || (0, import_Ordering.compareText)(left.executionId, right.executionId) || (0, import_Ordering.compareText)(left.clockName, right.clockName)
+        ),
+        snapshotClock
+      )
+    ),
+    completeRunClocks: Effect.fn("DurableEngineState.completeRunClocks")(
+      (executionId, completedAtMs) => Effect.sync(() => {
+        const completed = [];
+        for (const [key, row] of clocks) {
+          if (row.executionId !== executionId || row.completedAtMs !== null) continue;
+          const next = { ...row, completedAtMs };
+          clocks.set(key, next);
+          completed.push({ ...next });
+        }
+        return completed.sort(
+          (left, right) => (0, import_Ordering.compareText)(left.flowName, right.flowName) || (0, import_Ordering.compareText)(left.clockName, right.clockName)
+        );
+      })
+    ),
+    pendingClocks: Effect.fn("DurableEngineState.pendingClocks")(
+      (scope) => Effect.flatMap(
+        Effect.sync(
+          () => Array.from(clocks.values()).filter(
+            (row) => row.completedAtMs === null && isLive(row.executionId) && (scope.executionId === void 0 || row.executionId === scope.executionId) && (scope.flowName === void 0 || row.flowName === scope.flowName)
+          ).sort(
+            (left, right) => left.dueAtMs - right.dueAtMs || (0, import_Ordering.compareText)(left.executionId, right.executionId) || (0, import_Ordering.compareText)(left.clockName, right.clockName)
+          )
+        ),
+        (rows) => Effect.forEach(rows, snapshotClock)
+      )
+    ),
+    completedDeferreds: Effect.fn("DurableEngineState.completedDeferreds")(
+      (flowName) => Effect.sync(
+        () => Array.from(deferreds.values()).filter(
+          (row) => row.flowName === flowName && isLive(row.executionId) && !consumedDeferreds.has(deferredKey(row))
+        ).map(({ flowName: flowName2, executionId, deferredName }) => ({
+          flowName: flowName2,
+          executionId,
+          deferredName
+        })).sort(
+          (left, right) => (0, import_Ordering.compareText)(left.executionId, right.executionId) || (0, import_Ordering.compareText)(left.deferredName, right.deferredName)
+        )
+      )
+    ),
+    park: Effect.fn("DurableEngineState.park")(
+      (runId, waitingPayload, owner) => Effect.sync(() => {
+        const view = runView(runId, owner);
+        if (!view.exists || !view.owned) {
+          return { _tag: "NotFound" };
+        }
+        const row = {
+          runId,
+          reason: waitingPayload.reason,
+          wakeAt: waitingPayload.wakeAt ?? null,
+          token: waitingPayload.token ?? null,
+          ...decodeWaitingRequest(waitingPayload.request)
+        };
+        waitingRows.set(runId, row);
+        return { _tag: "Parked", row: snapshotWaiting(row) };
+      })
+    ),
+    wake: Effect.fn("DurableEngineState.wake")(
+      (runId) => Effect.sync(() => {
+        const row = waitingRows.get(runId);
+        if (row === void 0) {
+          return runView(runId, void 0).exists ? { _tag: "NotWaiting" } : { _tag: "NotFound" };
+        }
+        waitingRows.delete(runId);
+        return { _tag: "Woken", row: snapshotWaiting(row) };
+      })
+    ),
+    waiting: Effect.fn("DurableEngineState.waiting")(
+      (runId) => Effect.sync(() => {
+        const row = waitingRows.get(runId);
+        return row === void 0 ? Option.none() : Option.some(snapshotWaiting(row));
+      })
+    ),
+    waitingTree: Effect.fn("DurableEngineState.waitingTree")(
+      (runId, walk) => Effect.sync(() => {
+        const found = [];
+        const seen = /* @__PURE__ */ new Set([runId]);
+        let frontier = [runId];
+        for (let depth = 0; depth <= waitingTreeMaxDepth && frontier.length > 0; depth++) {
+          const next = [];
+          for (const current of frontier) {
+            const row = waitingRows.get(current);
+            if (row !== void 0 && isLive(current)) found.push(snapshotWaiting(row));
+            for (const [childId, parents] of parentEdges) {
+              if (!parents.has(current) || seen.has(childId)) continue;
+              const view = options.runs?.(childId);
+              if (walk?.detached !== "include" && view !== void 0 && Option.isSome(view) && view.value.onParentExit === "detach") continue;
+              seen.add(childId);
+              next.push(childId);
+            }
+          }
+          frontier = next;
+        }
+        return found;
+      })
+    ),
+    waitingRuns: Effect.fn("DurableEngineState.waitingRuns")(
+      (filter) => Effect.sync(
+        () => Array.from(waitingRows.values()).filter((row) => isLive(row.runId)).filter((row) => filter?.reason === void 0 || row.reason === filter.reason).filter(
+          (row) => filter?.dueBeforeMs === void 0 || row.wakeAt !== null && row.wakeAt <= filter.dueBeforeMs
+        ).filter((row) => {
+          if (filter?.cancelRequested !== true) return true;
+          if (options.runs === void 0) return true;
+          const view = options.runs(row.runId);
+          return Option.isSome(view) && view.value.cancelRequestedAtMs != null;
+        }).sort(
+          (left, right) => Number(left.wakeAt === null) - Number(right.wakeAt === null) || (left.wakeAt ?? 0) - (right.wakeAt ?? 0) || (0, import_Ordering.compareText)(left.runId, right.runId)
+        ).map(snapshotWaiting)
+      )
+    ),
+    pendingRuns: Effect.fn("DurableEngineState.pendingRuns")(
+      (flowName, limit, after, through, eligibleBeforeMs) => Effect.sync(() => {
+        const ordered = pendingMemoryRows(flowName, after, through, eligibleBeforeMs);
+        return limit === void 0 ? ordered : ordered.slice(0, limit);
+      })
+    ),
+    pendingRunTail: Effect.fn("DurableEngineState.pendingRunTail")(
+      (flowName, eligibleBeforeMs) => Effect.sync(
+        () => Option.fromNullishOr(pendingMemoryRows(flowName, void 0, void 0, eligibleBeforeMs).at(-1))
+      )
+    ),
+    pendingCancellationRuns: Effect.fn("DurableEngineState.pendingCancellationRuns")(
+      (limit, after, through) => pendingCancellationLimit(limit).pipe(Effect.andThen(
+        Effect.sync(() => pendingMemoryRows(void 0, after, through, void 0, true).slice(0, limit))
+      ))
+    ),
+    pendingCancellationTail: Effect.fn("DurableEngineState.pendingCancellationTail")(
+      () => Effect.sync(
+        () => Option.fromNullishOr(
+          pendingMemoryRows(void 0, void 0, void 0, void 0, true).at(-1)
+        )
+      )
+    ),
+    staleRunningRuns: Effect.fn("DurableEngineState.staleRunningRuns")(
+      (staleBeforeMs, limit) => Effect.sync(() => {
+        if (options.listRuns === void 0) return [];
+        const stale = [];
+        for (const [runId, view] of options.listRuns()) {
+          const heartbeatAtMs = view.heartbeatAtMs;
+          if (view.status === "running" && typeof heartbeatAtMs === "number" && heartbeatAtMs < staleBeforeMs) {
+            stale.push({ runId, heartbeatAtMs });
+          }
+        }
+        const ordered = stale.sort(
+          (left, right) => left.heartbeatAtMs - right.heartbeatAtMs || (0, import_Ordering.compareText)(left.runId, right.runId)
+        );
+        return limit === void 0 ? ordered : ordered.slice(0, limit);
+      })
+    ),
+    recordRunParent: Effect.fn("DurableEngineState.recordRunParent")(
+      (childId, parentId) => (
+        // A single synchronous step mirrors the SQL transaction: the cycle
+        // check and the insert are atomic — no fiber can interleave between
+        // them, and a rejected edge is never observable (issues #54/#55/#56).
+        Effect.suspend(() => {
+          const parents = parentEdges.get(childId) ?? /* @__PURE__ */ new Map();
+          const existing = parents.get(parentId);
+          if (existing !== void 0) {
+            return Effect.succeed({
+              _tag: "Existing",
+              edge: { childId, parentId, seq: existing }
+            });
+          }
+          const cycle = findCyclePathSync(childId, parentId);
+          if (cycle !== void 0) {
+            return Effect.fail(new RunParentCycleError({ path: cycle }));
+          }
+          parentSeq += 1;
+          parents.set(parentId, parentSeq);
+          parentEdges.set(childId, parents);
+          return Effect.succeed({
+            _tag: "Recorded",
+            edge: { childId, parentId, seq: parentSeq }
+          });
+        })
+      )
+    ),
+    removeRunParentsForRun: Effect.fn("DurableEngineState.removeRunParentsForRun")(
+      (runId) => Effect.sync(() => {
+        parentEdges.delete(runId);
+        for (const [childId, parents] of parentEdges) {
+          parents.delete(runId);
+          if (parents.size === 0) parentEdges.delete(childId);
+        }
+      })
+    ),
+    runParents: Effect.fn("DurableEngineState.runParents")(
+      (childId) => Effect.sync(
+        () => Array.from(parentEdges.get(childId) ?? []).map(([parentId, seq]) => ({ childId, parentId, seq })).sort((left, right) => left.seq - right.seq)
+      )
+    ),
+    runChildren: Effect.fn("DurableEngineState.runChildren")(
+      (parentId) => Effect.sync(() => {
+        const edges = [];
+        for (const [childId, parents] of parentEdges) {
+          const seq = parents.get(parentId);
+          if (seq !== void 0) edges.push({ childId, parentId, seq });
+        }
+        return edges.sort((left, right) => left.seq - right.seq);
+      })
+    )
+  };
+  const gate = Semaphore.makeUnsafe(1);
+  const transactionDepth = /* @__PURE__ */ new Map();
+  const guard = (effect) => Effect.flatMap(
+    Effect.fiberId,
+    (fiberId) => (transactionDepth.get(fiberId) ?? 0) > 0 ? effect : gate.withPermit(effect)
+  );
+  const restoreMap = (target, source) => {
+    target.clear();
+    for (const [key, value] of source) target.set(key, value);
+  };
+  const transaction = (effect, options2) => Effect.flatMap(Effect.fiberId, (fiberId) => Effect.uninterruptibleMask(
+    (restore) => Effect.gen(function* () {
+      const nested = (transactionDepth.get(fiberId) ?? 0) > 0;
+      if (!nested) yield* restore(gate.take(1));
+      const before = {
+        deferreds: new Map(deferreds),
+        consumedDeferreds: new Map(consumedDeferreds),
+        clocks: new Map(clocks),
+        waitingRows: new Map(waitingRows),
+        parentEdges: new Map([...parentEdges].map(([child, parents]) => [child, new Map(parents)])),
+        parentSeq
+      };
+      transactionDepth.set(fiberId, (transactionDepth.get(fiberId) ?? 0) + 1);
+      let committed = false;
+      let closed = false;
+      const close = Effect.suspend(() => {
+        if (closed) return Effect.void;
+        closed = true;
+        const depth = transactionDepth.get(fiberId) - 1;
+        if (depth === 0) transactionDepth.delete(fiberId);
+        else transactionDepth.set(fiberId, depth);
+        return nested ? Effect.void : gate.release(1).pipe(Effect.asVoid);
+      });
+      const commit = Effect.sync(() => {
+        committed = true;
+      }).pipe(Effect.andThen(close));
+      return yield* Effect.sync(() => options2?.onCommit(commit)).pipe(
+        Effect.andThen(restore(effect)),
+        Effect.catchCause(
+          (cause) => Effect.sync(() => {
+            if (committed) return;
+            restoreMap(deferreds, before.deferreds);
+            restoreMap(consumedDeferreds, before.consumedDeferreds);
+            restoreMap(clocks, before.clocks);
+            restoreMap(waitingRows, before.waitingRows);
+            restoreMap(parentEdges, before.parentEdges);
+            parentSeq = before.parentSeq;
+          }).pipe(Effect.andThen(Effect.failCause(cause)))
+        ),
+        Effect.ensuring(close)
+      );
+    })
+  ));
+  return DurableEngineState.of({
+    deferred: (address) => guard(unguarded.deferred(address)),
+    consumeDeferred: (address, consumedAtMs) => guard(unguarded.consumeDeferred(address, consumedAtMs)),
+    completeDeferred: (row) => guard(unguarded.completeDeferred(row)),
+    clock: (address) => guard(unguarded.clock(address)),
+    scheduleClock: (row, owner) => guard(unguarded.scheduleClock(row, owner)),
+    completeClock: (address, completedAtMs) => guard(unguarded.completeClock(address, completedAtMs)),
+    dueClocks: (nowMs) => guard(unguarded.dueClocks(nowMs)),
+    completeRunClocks: (executionId, completedAtMs) => guard(unguarded.completeRunClocks(executionId, completedAtMs)),
+    pendingClocks: (scope) => guard(unguarded.pendingClocks(scope)),
+    completedDeferreds: (flowName) => guard(unguarded.completedDeferreds(flowName)),
+    park: (runId, waiting, owner) => guard(unguarded.park(runId, waiting, owner)),
+    wake: (runId) => guard(unguarded.wake(runId)),
+    waiting: (runId) => guard(unguarded.waiting(runId)),
+    waitingTree: (runId, options2) => guard(unguarded.waitingTree(runId, options2)),
+    waitingRuns: (filter) => guard(unguarded.waitingRuns(filter)),
+    pendingRuns: (flowName, limit, after, through, eligibleBeforeMs) => guard(unguarded.pendingRuns(flowName, limit, after, through, eligibleBeforeMs)),
+    pendingRunTail: (flowName, eligibleBeforeMs) => guard(unguarded.pendingRunTail(flowName, eligibleBeforeMs)),
+    pendingCancellationRuns: (limit, after, through) => guard(unguarded.pendingCancellationRuns(limit, after, through)),
+    pendingCancellationTail: () => guard(unguarded.pendingCancellationTail()),
+    staleRunningRuns: (staleBeforeMs, limit) => guard(unguarded.staleRunningRuns(staleBeforeMs, limit)),
+    attemptSurvivors: void 0,
+    recordRunParent: (childId, parentId) => guard(unguarded.recordRunParent(childId, parentId)),
+    removeRunParentsForRun: (runId) => guard(unguarded.removeRunParentsForRun(runId)),
+    runParents: (childId) => guard(unguarded.runParents(childId)),
+    runChildren: (parentId) => guard(unguarded.runChildren(parentId)),
+    transaction
+  });
+};
+const layerMemory = Layer.sync(
+  DurableEngineState,
+  makeMemory
+);
+//# sourceMappingURL=DurableEngineState.js.map