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

package/dist/cjs/RunStore.js

@@ -0,0 +1,1079 @@
+"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 RunStore_exports = {};
+__export(RunStore_exports, {
+  OwnershipTransition: () => OwnershipTransition,
+  RunStatus: () => RunStatus,
+  RunStore: () => RunStore,
+  RunStoreError: () => RunStoreError,
+  RunStoreErrorCode: () => RunStoreErrorCode,
+  TerminalRunStatus: () => TerminalRunStatus,
+  TransitionGuard: () => TransitionGuard,
+  companionStream: () => companionStream,
+  isTerminalRunStatus: () => isTerminalRunStatus,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  layerWith: () => layerWith,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  maximumRunJsonDepth: () => maximumRunJsonDepth,
+  maximumRunJsonNodes: () => maximumRunJsonNodes,
+  ownershipEventType: () => ownershipEventType
+});
+module.exports = __toCommonJS(RunStore_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var import_Consensus = require("@smthrs/journal/Consensus");
+var import_JournalEvent = require("@smthrs/journal/JournalEvent");
+var import_OwnerId = require("@smthrs/journal/OwnerId");
+var SqlConsensus = __toESM(require("@smthrs/journal/SqlConsensus"), 1);
+var ObservabilityMetric = __toESM(require("@smthrs/observability/Metric"), 1);
+var import_effect = require("effect");
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var import_Heartbeat = require("./Heartbeat.js");
+var Boundary = __toESM(require("./internal/Boundary.js"), 1);
+var Companion = __toESM(require("./internal/Companion.js"), 1);
+var import_SpanOutcome = require("./internal/SpanOutcome.js");
+var RunStoreMetrics = __toESM(require("./RunStoreMetrics.js"), 1);
+const UnknownFromJsonString = import_effect.Schema.fromJsonString(import_effect.Schema.Unknown);
+const loneSurrogate = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+const wellFormedIdentifier = (value) => value.length > 0 && !loneSurrogate.test(value);
+const NonNegativeSafeInt = import_effect.Schema.Int.check(
+  import_effect.Schema.isGreaterThanOrEqualTo(0),
+  import_effect.Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+);
+const durableIdentifier = import_effect.Schema.NonEmptyString.check(
+  import_effect.Schema.isMaxLength(Boundary.maximumIdentifierLength),
+  import_effect.Schema.makeFilter(
+    (value) => wellFormedIdentifier(value) && Boundary.isDurableText(value),
+    { title: "durableIdentifier" }
+  )
+);
+const maximumRunJsonDepth = 128;
+const maximumRunJsonNodes = 1e5;
+const runJsonLimits = {
+  maxDepth: maximumRunJsonDepth,
+  maxMembers: maximumRunJsonNodes,
+  maxNodes: maximumRunJsonNodes
+};
+const RunStatus = import_effect.Schema.Literals([
+  "pending",
+  "running",
+  "suspended",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+const TerminalRunStatus = import_effect.Schema.Literals(["completed", "failed", "cancelled"]);
+const isTerminalRunStatus = (status) => status === "completed" || status === "failed" || status === "cancelled";
+const RunStoreErrorCode = import_effect.Schema.Literals([
+  "invalid_run",
+  "not_found_row",
+  "constraint",
+  "decode_failed",
+  "persistence_failed"
+]);
+class RunStoreError extends import_effect.Schema.TaggedError()("@smthrs/run-store/RunStoreError", {
+  code: RunStoreErrorCode,
+  method: import_effect.Schema.String,
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.Unknown
+}) {
+}
+const TransitionGuard = import_effect.Schema.Struct({
+  cancelRequested: import_effect.Schema.optional(import_effect.Schema.Literals(["absent", "present"]))
+});
+const OwnershipTransition = import_effect.Schema.Literals(["claimed", "activated", "released", "stolen", "expired"]);
+const companionStream = Companion.stream;
+const ownershipEventType = (transition) => `flows.consensus.${transition}`;
+class RunStore extends import_effect.Context.Service()("@smthrs/run-store/RunStore") {
+}
+const claimed = (claimedAtMs) => ({ _tag: "Claimed", claimedAtMs });
+const notFound = { _tag: "NotFound" };
+const alreadyClaimed = { _tag: "AlreadyClaimed" };
+const heartbeatFresh = { _tag: "HeartbeatFresh" };
+const snapshotChanged = { _tag: "SnapshotChanged" };
+const evidenceRequired = { _tag: "EvidenceRequired" };
+const activated = { _tag: "Activated" };
+const claimLost = { _tag: "ClaimLost" };
+const abandoned = { _tag: "Abandoned" };
+const recovered = { _tag: "Recovered" };
+const claimFresh = { _tag: "ClaimFresh" };
+const claimChanged = { _tag: "ClaimChanged" };
+const livenessUnconfirmed = { _tag: "LivenessUnconfirmed" };
+const updated = { _tag: "Updated" };
+const fenceLost = { _tag: "FenceLost" };
+const transitioned = { _tag: "Transitioned" };
+const guardFailed = { _tag: "GuardFailed" };
+const heartbeatStaleAfterMs = import_effect.Duration.toMillis(import_Heartbeat.heartbeatStaleAfter);
+const heartbeatSkewAllowanceMs = import_effect.Duration.toMillis(import_Heartbeat.heartbeatSkewAllowance);
+const terminalStatuses = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+const DatabaseRunRow = import_effect.Schema.Struct({
+  runId: durableIdentifier,
+  status: RunStatus,
+  createdAtMs: NonNegativeSafeInt,
+  startedAtMs: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  finishedAtMs: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  ownerHostId: import_effect.Schema.NullOr(durableIdentifier),
+  ownerPid: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  ownerNonce: import_effect.Schema.NullOr(durableIdentifier),
+  heartbeatAtMs: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  claimHostId: import_effect.Schema.NullOr(durableIdentifier),
+  claimPid: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  claimNonce: import_effect.Schema.NullOr(durableIdentifier),
+  claimedAtMs: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  parentRunId: import_effect.Schema.NullOr(durableIdentifier),
+  cancelRequestedAtMs: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  lineageId: import_effect.Schema.NullOr(durableIdentifier),
+  roundOrdinal: import_effect.Schema.NullOr(NonNegativeSafeInt),
+  stateJson: import_effect.Schema.String
+});
+const runStoreError = (method, code, message, cause) => new RunStoreError({
+  code,
+  method,
+  message: `${code}: RunStore.${method}: ${message}`,
+  cause
+});
+const databaseFailure = (cause) => {
+  let current = cause;
+  for (let depth = 0; depth < 8 && typeof current === "object" && current !== null; depth++) {
+    if (current instanceof import_DurableWriter.DatabaseError) return current;
+    current = current.cause;
+  }
+  return void 0;
+};
+const persistenceError = (method, cause) => {
+  if (import_effect.Schema.is(RunStoreError)(cause)) return cause;
+  const database = cause instanceof import_DurableWriter.DatabaseError ? cause : databaseFailure(cause.cause);
+  const code = database?.code === "constraint" ? "constraint" : "persistence_failed";
+  return runStoreError(method, code, "database operation failed", {
+    category: code,
+    // Keep the classification for outer transaction retries, never driver
+    // causes that may contain executable state or bound SQL values.
+    cause: new import_DurableWriter.DatabaseError({ code: database?.code ?? "unknown" })
+  });
+};
+const invalidRunError = (method, causeOrField, detail = "violates the durable contract") => runStoreError(
+  method,
+  "invalid_run",
+  "run input is invalid",
+  typeof causeOrField === "string" ? { field: causeOrField, detail } : causeOrField
+);
+const stateAdmission = (value) => Boundary.admitJsonText(value, runJsonLimits);
+const isJsonString = (value) => import_effect.Schema.decodeUnknownResult(UnknownFromJsonString)(value)._tag === "Success";
+const validOwner = (value) => import_effect.Schema.is(import_OwnerId.OwnerId)(value) && Boundary.isDurableText(value.hostId) && Boundary.isDurableText(value.nonce) && Number.isSafeInteger(value.pid) && value.pid >= 0;
+const validTimestamp = (value) => Number.isSafeInteger(value) && value >= 0;
+const inertRecord = (input, allowed) => {
+  if (typeof input !== "object" || input === null) return void 0;
+  try {
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) return void 0;
+    const fields = /* @__PURE__ */ Object.create(null);
+    for (const key of Reflect.ownKeys(input)) {
+      const descriptor = Object.getOwnPropertyDescriptor(input, key);
+      if (descriptor === void 0 || !descriptor.enumerable) continue;
+      if (!("value" in descriptor) || allowed !== void 0 && (typeof key !== "string" || !allowed.has(key))) {
+        return void 0;
+      }
+      if (typeof key === "string") fields[key] = descriptor.value;
+    }
+    return fields;
+  } catch {
+    return void 0;
+  }
+};
+const snapshotOwner = (method, field, input) => import_effect.Effect.suspend(() => {
+  const fields = inertRecord(input, /* @__PURE__ */ new Set(["hostId", "pid", "nonce"]));
+  if (fields === void 0) {
+    return import_effect.Effect.fail(invalidRunError(method, field, "must be an inert owner record"));
+  }
+  const owner = Object.freeze({
+    hostId: fields.hostId,
+    pid: fields.pid,
+    nonce: fields.nonce
+  });
+  return validOwner(owner) ? import_effect.Effect.succeed(owner) : import_effect.Effect.fail(invalidRunError(method, field, "must be a valid owner identity"));
+});
+const snapshotRunId = (method, input) => typeof input === "string" && wellFormedIdentifier(input) && Boundary.isDurableText(input) ? import_effect.Effect.succeed(input) : import_effect.Effect.fail(invalidRunError(method, "runId", "must be well-formed durable text"));
+const snapshotTimestamp = (method, field, input) => typeof input === "number" && validTimestamp(input) ? import_effect.Effect.succeed(input) : import_effect.Effect.fail(
+  invalidRunError(method, field, "must be a non-negative safe integer")
+);
+const snapshotLeaseReading = (method, field, input, cause) => import_effect.Effect.gen(function* () {
+  const nowMs = yield* snapshotTimestamp(method, field, input);
+  const clockMs = yield* import_effect.Clock.currentTimeMillis.pipe(import_effect.Effect.map(Math.floor));
+  if (nowMs > clockMs + heartbeatSkewAllowanceMs) {
+    return yield* import_effect.Effect.fail(
+      invalidRunError(method, {
+        ...cause,
+        field,
+        nowMs,
+        clockMs,
+        detail: "runs ahead of the store clock by more than the heartbeat skew allowance"
+      })
+    );
+  }
+  return nowMs;
+});
+const snapshotState = (method, input, cause) => {
+  const admitted = stateAdmission(input);
+  return admitted.ok ? import_effect.Effect.succeed(admitted.value) : import_effect.Effect.fail(
+    invalidRunError(
+      method,
+      cause,
+      admitted.complaint
+    )
+  );
+};
+const snapshotCreateOptions = (input) => import_effect.Effect.suspend(() => {
+  const value = input ?? {};
+  const fields = inertRecord(value, /* @__PURE__ */ new Set(["parentRunId", "lineageId", "roundOrdinal"]));
+  if (fields === void 0) {
+    return import_effect.Effect.fail(invalidRunError("create", "options", "must be an inert data record"));
+  }
+  const rawParent = fields.parentRunId;
+  const rawLineage = fields.lineageId;
+  const rawRound = fields.roundOrdinal;
+  const parentRunId = rawParent === void 0 ? null : rawParent;
+  const lineageId = rawLineage === void 0 ? null : rawLineage;
+  const roundOrdinal = rawRound === void 0 ? null : rawRound;
+  if (parentRunId !== null && (typeof parentRunId !== "string" || !wellFormedIdentifier(parentRunId) || !Boundary.isDurableText(parentRunId)) || lineageId !== null && (typeof lineageId !== "string" || !wellFormedIdentifier(lineageId) || !Boundary.isDurableText(lineageId)) || roundOrdinal !== null && (typeof roundOrdinal !== "number" || !validTimestamp(roundOrdinal)) || lineageId === null !== (roundOrdinal === null)) return import_effect.Effect.fail(invalidRunError("create", "options", "contains invalid ancestry or lineage"));
+  return import_effect.Effect.succeed(Object.freeze({ parentRunId, lineageId, roundOrdinal }));
+});
+const inertFields = (input, required) => {
+  const fields = inertRecord(input);
+  return fields !== void 0 && required.every((key) => Object.hasOwn(fields, key)) ? fields : void 0;
+};
+const snapshotExpected = (method, input) => import_effect.Effect.gen(function* () {
+  const fields = inertFields(input, ["status", "owner", "heartbeatAtMs"]);
+  if (fields === void 0) {
+    return yield* import_effect.Effect.fail(invalidRunError(method, "expected", "must be an inert snapshot record"));
+  }
+  const status = fields.status;
+  const rawOwner = fields.owner;
+  const heartbeatAtMs = fields.heartbeatAtMs;
+  if (!import_effect.Schema.is(RunStatus)(status) || heartbeatAtMs !== null && (typeof heartbeatAtMs !== "number" || !validTimestamp(heartbeatAtMs))) {
+    return yield* import_effect.Effect.fail(invalidRunError(method, "expected", "contains an invalid status or heartbeat"));
+  }
+  const owner = rawOwner === null ? null : yield* snapshotOwner(method, "expected.owner", rawOwner);
+  if (status === "running") {
+    if (owner === null || heartbeatAtMs === null) {
+      return yield* import_effect.Effect.fail(invalidRunError(method, "expected", "violates ownership invariants"));
+    }
+    return Object.freeze({ status, owner, heartbeatAtMs });
+  } else {
+    if (owner !== null || heartbeatAtMs !== null) {
+      return yield* import_effect.Effect.fail(invalidRunError(method, "expected", "violates ownership invariants"));
+    }
+    return Object.freeze({ status, owner, heartbeatAtMs });
+  }
+});
+const snapshotEvidence = (method, input) => import_effect.Effect.gen(function* () {
+  const fields = inertRecord(input, /* @__PURE__ */ new Set(["expectedOwner", "checkedAtMs", "kind"]));
+  if (fields === void 0) {
+    return yield* import_effect.Effect.fail(invalidRunError(method, "evidence", "must be an inert evidence record"));
+  }
+  const expectedOwner = yield* snapshotOwner(method, "evidence.expectedOwner", fields.expectedOwner);
+  const checkedAtMs = yield* snapshotTimestamp(method, "evidence.checkedAtMs", fields.checkedAtMs);
+  const kind = fields.kind;
+  if (kind !== "same-host-pid-dead" && kind !== "cross-host-unreachable-stale" && kind !== "lease-expired") return yield* import_effect.Effect.fail(invalidRunError(method, "evidence.kind"));
+  return Object.freeze({ expectedOwner, checkedAtMs, kind });
+});
+const snapshotGuard = (input) => import_effect.Effect.suspend(() => {
+  if (input === void 0) return import_effect.Effect.succeed(void 0);
+  const fields = inertRecord(input, /* @__PURE__ */ new Set(["cancelRequested"]));
+  if (fields === void 0) {
+    return import_effect.Effect.fail(invalidRunError("transitionOwned", "guard", "must be an inert exact guard"));
+  }
+  const cancelRequested = fields.cancelRequested;
+  if (cancelRequested !== void 0 && cancelRequested !== "absent" && cancelRequested !== "present") {
+    return import_effect.Effect.fail(invalidRunError("transitionOwned", "guard.cancelRequested"));
+  }
+  return import_effect.Effect.succeed(Object.freeze(cancelRequested === void 0 ? {} : { cancelRequested }));
+});
+const ownerFromColumns = (hostId, pid, nonce) => {
+  if (hostId === null && pid === null && nonce === null) return null;
+  if (hostId !== null && pid !== null && nonce !== null) {
+    return Object.freeze({ hostId, pid, nonce });
+  }
+  return void 0;
+};
+const rowMatchesClaim = (row, claimant, claimedAtMs) => row.claimHostId === claimant.hostId && row.claimPid === claimant.pid && row.claimNonce === claimant.nonce && row.claimedAtMs === claimedAtMs;
+const rowMatchesSnapshot = (row, expected) => row.status === expected.status && row.ownerHostId === (expected.owner?.hostId ?? null) && row.ownerPid === (expected.owner?.pid ?? null) && row.ownerNonce === (expected.owner?.nonce ?? null) && row.heartbeatAtMs === expected.heartbeatAtMs;
+const rowOwnedBy = (row, owner) => row.status === "running" && row.ownerHostId === owner.hostId && row.ownerPid === owner.pid && row.ownerNonce === owner.nonce;
+const claimColumnsFree = (row) => row.claimHostId === null && row.claimPid === null && row.claimNonce === null && row.claimedAtMs === null;
+const decodeRunRow = (method, runId, input) => import_effect.Schema.decodeUnknownEffect(DatabaseRunRow)(input).pipe(
+  import_effect.Effect.mapError(
+    () => runStoreError(method, "decode_failed", "could not decode flows_runs row", { runId, stage: "row-schema" })
+  ),
+  import_effect.Effect.flatMap((row) => {
+    const owner = ownerFromColumns(row.ownerHostId, row.ownerPid, row.ownerNonce);
+    const claim = ownerFromColumns(row.claimHostId, row.claimPid, row.claimNonce);
+    const admittedState = stateAdmission(row.stateJson);
+    const stateJsonValid = isJsonString(row.stateJson);
+    const invalidOwner = owner === void 0 || owner === null && row.heartbeatAtMs !== null || owner !== null && row.heartbeatAtMs === null || (row.status === "running" ? owner === null : owner !== null);
+    const invalidClaim = claim === void 0 || claim === null && row.claimedAtMs !== null || claim !== null && row.claimedAtMs === null;
+    if (invalidOwner || invalidClaim || !admittedState.ok) {
+      return import_effect.Effect.fail(
+        runStoreError(method, "decode_failed", "flows_runs row violates durable invariants", {
+          runId,
+          status: row.status,
+          heartbeatAtMs: row.heartbeatAtMs,
+          claimedAtMs: row.claimedAtMs,
+          hasClaimColumns: row.claimHostId !== null || row.claimPid !== null || row.claimNonce !== null,
+          hasOwnerColumns: row.ownerHostId !== null || row.ownerPid !== null || row.ownerNonce !== null,
+          stateJsonValid
+        })
+      );
+    }
+    return import_effect.Effect.succeed(Object.freeze({
+      runId: row.runId,
+      status: row.status,
+      createdAtMs: row.createdAtMs,
+      startedAtMs: row.startedAtMs,
+      finishedAtMs: row.finishedAtMs,
+      owner,
+      heartbeatAtMs: row.heartbeatAtMs,
+      claim,
+      claimedAtMs: row.claimedAtMs,
+      parentRunId: row.parentRunId,
+      cancelRequestedAtMs: row.cancelRequestedAtMs,
+      lineageId: row.lineageId,
+      roundOrdinal: row.roundOrdinal,
+      stateJson: row.stateJson
+    }));
+  })
+);
+const lineageMembership = (sql, runId) => sql`(
+    lineage_id = (SELECT COALESCE(lineage_id, run_id) FROM flows_runs WHERE run_id = ${runId})
+    OR (
+      run_id = (SELECT COALESCE(lineage_id, run_id) FROM flows_runs WHERE run_id = ${runId})
+      AND (
+        lineage_id IS NULL
+        OR lineage_id = (SELECT COALESCE(lineage_id, run_id) FROM flows_runs WHERE run_id = ${runId})
+      )
+    )
+  )`;
+const classifyCancellationMiss = (method, runId, rows) => import_effect.Effect.gen(function* () {
+  let outcome = notFound;
+  for (const row of rows) {
+    const status = yield* import_effect.Schema.decodeUnknownEffect(RunStatus)(row.status).pipe(
+      import_effect.Effect.mapError((cause) => runStoreError(method, "decode_failed", "could not decode flows_runs status", cause))
+    );
+    if (isTerminalRunStatus(status)) {
+      if (outcome._tag !== "AlreadyRequested") outcome = { _tag: "Terminal", status };
+      continue;
+    }
+    if (row.requestedAtMs === null) {
+      return yield* import_effect.Effect.fail(
+        runStoreError(method, "persistence_failed", "guarded cancellation update missed a live unrequested row", {
+          runId,
+          stage: "write-invariant"
+        })
+      );
+    }
+    outcome = { _tag: "AlreadyRequested", requestedAtMs: Number(row.requestedAtMs) };
+  }
+  return outcome;
+});
+const selectRun = (sql, runId, mode = "single") => sql`
+    SELECT
+      run_id AS "runId",
+      status AS "status",
+      created_at_ms AS "createdAtMs",
+      started_at_ms AS "startedAtMs",
+      finished_at_ms AS "finishedAtMs",
+      owner_host_id AS "ownerHostId",
+      owner_pid AS "ownerPid",
+      owner_nonce AS "ownerNonce",
+      heartbeat_at_ms AS "heartbeatAtMs",
+      claim_host_id AS "claimHostId",
+      claim_pid AS "claimPid",
+      claim_nonce AS "claimNonce",
+      claimed_at_ms AS "claimedAtMs",
+      parent_run_id AS "parentRunId",
+      cancel_requested_at_ms AS "cancelRequestedAtMs",
+      lineage_id AS "lineageId",
+      round_ordinal AS "roundOrdinal",
+      state_json AS "stateJson"
+    FROM flows_runs
+    WHERE ${mode === "latest" ? sql`run_id = COALESCE(
+        (SELECT run_id FROM flows_runs
+         WHERE lineage_id = (SELECT COALESCE(lineage_id, run_id) FROM flows_runs WHERE run_id = ${runId})
+         ORDER BY round_ordinal DESC LIMIT 1),
+        (SELECT run_id FROM flows_runs WHERE run_id = ${runId})
+      )` : mode === "lineage" ? lineageMembership(sql, runId) : sql`run_id = ${runId}`}
+    ORDER BY COALESCE(round_ordinal, 0), run_id
+  `;
+const classifyClaimLoss = (row, nowMs) => {
+  if (row === void 0) return notFound;
+  if (row.claimHostId !== null) return alreadyClaimed;
+  if (row.status === "running" && row.heartbeatAtMs !== null && row.heartbeatAtMs >= nowMs - heartbeatStaleAfterMs) {
+    return heartbeatFresh;
+  }
+  return snapshotChanged;
+};
+const evidenceMatches = (expected, claimant, checkedAtMs, evidence) => expected.status === "running" && expected.owner !== null && (0, import_Consensus.matchesEvidence)(expected.owner, claimant, checkedAtMs, evidence);
+const make = import_effect.Effect.gen(
+  function* () {
+    const sql = yield* import_effect.Effect.service(SqlClient.SqlClient);
+    const writer = yield* import_DurableWriter.DurableWriter;
+    const consensus = yield* import_Consensus.Consensus;
+    const write = (method, effect) => writer.write(effect).pipe(import_effect.Effect.mapError((cause) => persistenceError(method, cause)));
+    const recordTransition = (runId, transition, owner, grantedAtMs) => Companion.append(runId, ownershipEventType(transition), {
+      owner: { hostId: owner.hostId, pid: owner.pid, nonce: owner.nonce },
+      grantedAtMs
+    });
+    const read = (method, effect) => effect.pipe(import_effect.Effect.mapError((cause) => persistenceError(method, (0, import_DurableWriter.fromSqlError)(cause))));
+    const create = import_effect.Effect.fn("RunStore.create")(
+      (runIdInput, stateInput, optionsInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("create", runIdInput);
+        if ((0, import_JournalEvent.isCompanionRunId)(runId)) {
+          return yield* import_effect.Effect.fail(invalidRunError("create", "runId", "names a reserved journal companion stream"));
+        }
+        const { lineageId, parentRunId, roundOrdinal } = yield* snapshotCreateOptions(optionsInput);
+        const stateJson = yield* snapshotState("create", stateInput, {
+          runId,
+          parentRunId,
+          lineageId,
+          roundOrdinal,
+          stateJsonLength: typeof stateInput === "string" ? stateInput.length : null,
+          stateJsonValid: isJsonString(stateInput)
+        });
+        yield* import_effect.Effect.annotateCurrentSpan({ runId });
+        const createdAtMs = yield* import_effect.Clock.currentTimeMillis.pipe(import_effect.Effect.map(Math.floor));
+        yield* write(
+          "create",
+          sql`
+            INSERT INTO flows_runs (
+              run_id,
+              status,
+              created_at_ms,
+              started_at_ms,
+              finished_at_ms,
+              owner_host_id,
+              owner_pid,
+              owner_nonce,
+              heartbeat_at_ms,
+              claim_host_id,
+              claim_pid,
+              claim_nonce,
+              claimed_at_ms,
+              parent_run_id,
+              lineage_id,
+              round_ordinal,
+              state_json
+            ) VALUES (
+              ${runId},
+              'pending',
+              ${createdAtMs},
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              NULL,
+              ${parentRunId},
+              ${lineageId},
+              ${roundOrdinal},
+              ${stateJson}
+            )
+          `.pipe(import_effect.Effect.asVoid)
+        );
+      }).pipe(import_SpanOutcome.observeExit)
+    );
+    const get = import_effect.Effect.fn("RunStore.get")(
+      (runIdInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("get", runIdInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId });
+        const rows = yield* read("get", selectRun(sql, runId));
+        return rows[0] === void 0 ? yield* import_effect.Effect.fail(
+          runStoreError("get", "not_found_row", `run ${runId} was not found`, { runId })
+        ) : yield* decodeRunRow("get", runId, rows[0]);
+      }).pipe(import_SpanOutcome.observeExit)
+    );
+    const lineage = import_effect.Effect.fn("RunStore.lineage")(
+      (runIdInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("lineage", runIdInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId });
+        const rows = yield* read("lineage", selectRun(sql, runId, "lineage"));
+        return yield* import_effect.Effect.forEach(rows, (row) => decodeRunRow("lineage", row.runId, row));
+      }).pipe(import_SpanOutcome.observeExit)
+    );
+    const latestRound = import_effect.Effect.fn("RunStore.latestRound")(
+      (runIdInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("latestRound", runIdInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId });
+        const rows = yield* read("latestRound", selectRun(sql, runId, "latest"));
+        return rows[0] === void 0 ? yield* import_effect.Effect.fail(runStoreError("latestRound", "not_found_row", `run ${runId} was not found`, { runId })) : yield* decodeRunRow("latestRound", rows[0].runId, rows[0]);
+      }).pipe(import_SpanOutcome.observeExit)
+    );
+    const requestCancel = import_effect.Effect.fn("RunStore.requestCancel")(
+      (runIdInput, nowMsInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("requestCancel", runIdInput);
+        const nowMs = yield* snapshotTimestamp("requestCancel", "nowMs", nowMsInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId });
+        return yield* write(
+          "requestCancel",
+          import_effect.Effect.gen(function* () {
+            const rows = yield* sql`
+          UPDATE flows_runs
+          SET cancel_requested_at_ms = ${nowMs}
+          WHERE run_id = ${runId}
+            AND cancel_requested_at_ms IS NULL
+            AND status NOT IN ('completed', 'failed', 'cancelled')
+          RETURNING cancel_requested_at_ms AS "requestedAtMs"
+        `;
+            if (rows[0] !== void 0) {
+              return { _tag: "CancelRequested", requestedAtMs: Number(rows[0].requestedAtMs) };
+            }
+            const current = yield* sql`
+          SELECT cancel_requested_at_ms AS "requestedAtMs", status AS "status"
+          FROM flows_runs WHERE run_id = ${runId}
+        `;
+            return yield* classifyCancellationMiss("requestCancel", runId, current);
+          })
+        );
+      }).pipe((0, import_SpanOutcome.observeOutcome)())
+    );
+    const requestCancelLineage = import_effect.Effect.fn("RunStore.requestCancelLineage")(
+      (runIdInput, nowMsInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("requestCancelLineage", runIdInput);
+        const nowMs = yield* snapshotTimestamp("requestCancelLineage", "nowMs", nowMsInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId });
+        return yield* write(
+          "requestCancelLineage",
+          import_effect.Effect.gen(function* () {
+            const rows = yield* sql`
+          UPDATE flows_runs
+          SET cancel_requested_at_ms = ${nowMs}
+          WHERE ${lineageMembership(sql, runId)}
+            AND cancel_requested_at_ms IS NULL
+            AND status NOT IN ('completed', 'failed', 'cancelled')
+          RETURNING cancel_requested_at_ms AS "requestedAtMs"
+        `;
+            if (rows[0] !== void 0) {
+              return { _tag: "CancelRequested", requestedAtMs: Number(rows[0].requestedAtMs) };
+            }
+            const members = yield* sql`
+          SELECT cancel_requested_at_ms AS "requestedAtMs", status AS "status"
+          FROM flows_runs
+          WHERE ${lineageMembership(sql, runId)}
+          ORDER BY COALESCE(round_ordinal, 0), run_id
+        `;
+            return yield* classifyCancellationMiss("requestCancelLineage", runId, members);
+          })
+        );
+      }).pipe((0, import_SpanOutcome.observeOutcome)())
+    );
+    const claim = import_effect.Effect.fn("RunStore.claim")(
+      (runIdInput, expectedInput, claimantInput, nowMsInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("claim", runIdInput);
+        const expected = yield* snapshotExpected("claim", expectedInput);
+        const claimant = yield* snapshotOwner("claim", "claimant", claimantInput);
+        const nowMs = yield* snapshotLeaseReading(
+          "claim",
+          "nowMs",
+          nowMsInput,
+          { runId }
+        );
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, claimantHostId: claimant.hostId });
+        return yield* write(
+          "claim",
+          import_effect.Effect.gen(function* () {
+            const row = (yield* selectRun(sql, runId))[0];
+            const admissible = row !== void 0 && (row.status === "pending" || row.status === "suspended") && rowMatchesSnapshot(row, expected) && claimColumnsFree(row);
+            if (!admissible) return classifyClaimLoss(row, nowMs);
+            const grant = yield* consensus.claim(runId, claimant, nowMs);
+            if (grant._tag === "Rejected") {
+              return classifyClaimLoss(row, nowMs);
+            }
+            yield* sql`
+          UPDATE flows_runs
+          SET
+            claim_host_id = ${claimant.hostId},
+            claim_pid = ${claimant.pid},
+            claim_nonce = ${claimant.nonce},
+            claimed_at_ms = ${grant.grantedAtMs}
+          WHERE run_id = ${runId}
+        `;
+            yield* recordTransition(runId, "claimed", claimant, grant.grantedAtMs);
+            return claimed(grant.grantedAtMs);
+          })
+        );
+      }).pipe((0, import_SpanOutcome.observeOutcome)(
+        (outcome) => RunStoreMetrics.claim[outcome._tag],
+        import_effect.Metric.withAttributes(RunStoreMetrics.claims, { op: "claim" })
+      ))
+    );
+    const claimAndOwn = import_effect.Effect.fn("RunStore.claimAndOwn")(
+      (runIdInput, expectedInput, ownerInput, nowMsInput, evidenceInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("claimAndOwn", runIdInput);
+        const expected = yield* snapshotExpected("claimAndOwn", expectedInput);
+        const owner = yield* snapshotOwner("claimAndOwn", "owner", ownerInput);
+        const nowMs = yield* snapshotLeaseReading(
+          "claimAndOwn",
+          "nowMs",
+          nowMsInput,
+          { runId }
+        );
+        const evidence = evidenceInput === void 0 ? void 0 : yield* snapshotEvidence("claimAndOwn", evidenceInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, ownerHostId: owner.hostId });
+        return yield* import_effect.Effect.suspend(() => {
+          if (expected.status === "running" && !(0, import_Consensus.sameOwner)(expected.owner, owner) && !(evidence !== void 0 && evidenceMatches(expected, owner, nowMs, evidence))) {
+            return read("claimAndOwn", selectRun(sql, runId)).pipe(
+              import_effect.Effect.map((current) => {
+                const row = current[0];
+                const loss = classifyClaimLoss(row, nowMs);
+                return loss === snapshotChanged && row !== void 0 && rowMatchesSnapshot(row, expected) ? evidenceRequired : loss;
+              })
+            );
+          }
+          return write(
+            "claimAndOwn",
+            import_effect.Effect.gen(function* () {
+              const row = (yield* selectRun(sql, runId))[0];
+              const admissible = row !== void 0 && (row.status === "pending" || row.status === "suspended" || row.status === "running") && rowMatchesSnapshot(row, expected) && claimColumnsFree(row) && (row.status !== "running" || row.heartbeatAtMs === null || row.heartbeatAtMs < nowMs - heartbeatStaleAfterMs);
+              if (!admissible) return classifyClaimLoss(row, nowMs);
+              const expectedOwner = expected.owner;
+              let grant;
+              let transition = "claimed";
+              if (expectedOwner === null) {
+                grant = yield* consensus.claim(runId, owner, nowMs);
+              } else if ((0, import_Consensus.sameOwner)(expectedOwner, owner)) {
+                yield* consensus.release(runId, owner);
+                yield* recordTransition(runId, "released", owner, null);
+                grant = yield* consensus.claim(runId, owner, nowMs);
+              } else {
+                grant = yield* consensus.steal(runId, owner, nowMs, evidence);
+                transition = "stolen";
+              }
+              if (grant._tag === "Rejected") return classifyClaimLoss(row, nowMs);
+              const activation = yield* consensus.activate(runId, owner, grant.grantedAtMs, nowMs);
+              if (activation._tag === "Lost") {
+                yield* consensus.release(runId, owner);
+                return classifyClaimLoss(row, nowMs);
+              }
+              yield* recordTransition(runId, transition, owner, grant.grantedAtMs);
+              yield* recordTransition(runId, "activated", owner, grant.grantedAtMs);
+              yield* sql`
+          UPDATE flows_runs
+          SET
+            status = 'running',
+            started_at_ms = COALESCE(started_at_ms, ${nowMs}),
+            finished_at_ms = NULL,
+            owner_host_id = ${owner.hostId},
+            owner_pid = ${owner.pid},
+            owner_nonce = ${owner.nonce},
+            heartbeat_at_ms = ${nowMs}
+          WHERE run_id = ${runId}
+        `;
+              return activated;
+            })
+          );
+        });
+      }).pipe((0, import_SpanOutcome.observeOutcome)(
+        (outcome) => RunStoreMetrics.claimAndOwn[outcome._tag],
+        import_effect.Metric.withAttributes(RunStoreMetrics.claims, { op: "claim_and_own" })
+      ))
+    );
+    const activate = import_effect.Effect.fn("RunStore.activate")(
+      (runIdInput, claimantInput, claimedAtMsInput, expectedInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("activate", runIdInput);
+        const claimant = yield* snapshotOwner("activate", "claimant", claimantInput);
+        const claimedAtMs = yield* snapshotTimestamp(
+          "activate",
+          "claimedAtMs",
+          claimedAtMsInput
+        );
+        const expected = yield* snapshotExpected("activate", expectedInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, claimantHostId: claimant.hostId });
+        const activatedAtMs = yield* import_effect.Clock.currentTimeMillis.pipe(import_effect.Effect.map(Math.floor));
+        return yield* write(
+          "activate",
+          import_effect.Effect.gen(function* () {
+            const row = (yield* selectRun(sql, runId))[0];
+            if (row === void 0 || !rowMatchesClaim(row, claimant, claimedAtMs)) return claimLost;
+            const clearClaim = sql`
+              UPDATE flows_runs
+              SET
+                claim_host_id = NULL,
+                claim_pid = NULL,
+                claim_nonce = NULL,
+                claimed_at_ms = NULL
+              WHERE run_id = ${runId}
+                AND claim_host_id = ${claimant.hostId}
+                AND claim_pid = ${claimant.pid}
+                AND claim_nonce = ${claimant.nonce}
+                AND claimed_at_ms = ${claimedAtMs}
+            `;
+            if (!rowMatchesSnapshot(row, expected)) {
+              yield* consensus.release(runId, claimant);
+              yield* recordTransition(runId, "released", claimant, claimedAtMs);
+              yield* clearClaim;
+              return snapshotChanged;
+            }
+            const activation = yield* consensus.activate(runId, claimant, claimedAtMs, activatedAtMs);
+            if (activation._tag === "Lost") {
+              yield* clearClaim;
+              return claimLost;
+            }
+            yield* sql`
+              UPDATE flows_runs
+              SET
+                status = 'running',
+                started_at_ms = COALESCE(started_at_ms, ${activatedAtMs}),
+                finished_at_ms = NULL,
+                owner_host_id = ${claimant.hostId},
+                owner_pid = ${claimant.pid},
+                owner_nonce = ${claimant.nonce},
+                heartbeat_at_ms = ${activatedAtMs},
+                claim_host_id = NULL,
+                claim_pid = NULL,
+                claim_nonce = NULL,
+                claimed_at_ms = NULL
+              WHERE run_id = ${runId}
+            `;
+            yield* recordTransition(runId, "activated", claimant, claimedAtMs);
+            return activated;
+          })
+        );
+      }).pipe((0, import_SpanOutcome.observeOutcome)(
+        (outcome) => RunStoreMetrics.activate[outcome._tag],
+        import_effect.Metric.withAttributes(RunStoreMetrics.claims, { op: "activate" })
+      ))
+    );
+    const abandonClaim = import_effect.Effect.fn("RunStore.abandonClaim")(
+      (runIdInput, claimantInput, claimedAtMsInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("abandonClaim", runIdInput);
+        const claimant = yield* snapshotOwner("abandonClaim", "claimant", claimantInput);
+        const claimedAtMs = yield* snapshotTimestamp("abandonClaim", "claimedAtMs", claimedAtMsInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, claimantHostId: claimant.hostId });
+        return yield* write(
+          "abandonClaim",
+          import_effect.Effect.gen(function* () {
+            const rows = yield* sql`
+          UPDATE flows_runs
+          SET
+            claim_host_id = NULL,
+            claim_pid = NULL,
+            claim_nonce = NULL,
+            claimed_at_ms = NULL
+          WHERE run_id = ${runId}
+            AND claim_host_id = ${claimant.hostId}
+            AND claim_pid = ${claimant.pid}
+            AND claim_nonce = ${claimant.nonce}
+            AND claimed_at_ms = ${claimedAtMs}
+          RETURNING run_id AS "runId"
+        `;
+            if (rows.length === 0) return claimLost;
+            yield* consensus.release(runId, claimant);
+            yield* recordTransition(runId, "released", claimant, claimedAtMs);
+            return abandoned;
+          })
+        );
+      }).pipe((0, import_SpanOutcome.observeOutcome)(
+        (outcome) => RunStoreMetrics.abandonClaim[outcome._tag],
+        import_effect.Metric.withAttributes(RunStoreMetrics.claims, { op: "abandon_claim" })
+      ))
+    );
+    const recoverClaim = import_effect.Effect.fn("RunStore.recoverClaim")(
+      (runIdInput, staleClaimantInput, claimedAtMsInput, observerInput, nowMsInput, evidenceInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("recoverClaim", runIdInput);
+        const staleClaimant = yield* snapshotOwner("recoverClaim", "staleClaimant", staleClaimantInput);
+        const claimedAtMs = yield* snapshotTimestamp(
+          "recoverClaim",
+          "claimedAtMs",
+          claimedAtMsInput
+        );
+        const observer = yield* snapshotOwner("recoverClaim", "observer", observerInput);
+        const nowMs = yield* snapshotLeaseReading("recoverClaim", "nowMs", nowMsInput, { runId, claimedAtMs });
+        const evidence = yield* snapshotEvidence("recoverClaim", evidenceInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, observerHostId: observer.hostId });
+        return yield* import_effect.Effect.suspend(() => {
+          if (!(0, import_Consensus.matchesEvidence)(staleClaimant, observer, nowMs, evidence)) {
+            return import_effect.Effect.succeed(livenessUnconfirmed);
+          }
+          return write(
+            "recoverClaim",
+            import_effect.Effect.gen(function* () {
+              const row = (yield* selectRun(sql, runId))[0];
+              if (row === void 0) return notFound;
+              if (!rowMatchesClaim(row, staleClaimant, claimedAtMs)) return claimChanged;
+              if (claimedAtMs >= nowMs - heartbeatStaleAfterMs) return claimFresh;
+              const outcome = yield* consensus.recover(runId, staleClaimant, claimedAtMs, observer, nowMs, evidence);
+              if (outcome._tag === "Rejected") {
+                return claimChanged;
+              }
+              yield* sql`
+          UPDATE flows_runs
+          SET
+            claim_host_id = NULL,
+            claim_pid = NULL,
+            claim_nonce = NULL,
+            claimed_at_ms = NULL
+          WHERE run_id = ${runId}
+        `;
+              yield* recordTransition(runId, "expired", staleClaimant, claimedAtMs);
+              return recovered;
+            })
+          );
+        });
+      }).pipe((0, import_SpanOutcome.observeOutcome)(
+        (outcome) => RunStoreMetrics.recoverClaim[outcome._tag],
+        import_effect.Metric.withAttributes(RunStoreMetrics.claims, { op: "recover_claim" })
+      ))
+    );
+    const renewLease = (method) => import_effect.Effect.fn(`RunStore.${method}`)(
+      (runIdInput, ownerInput, nowMsInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId(method, runIdInput);
+        const owner = yield* snapshotOwner(method, "owner", ownerInput);
+        const nowMs = yield* snapshotLeaseReading(
+          method,
+          "nowMs",
+          nowMsInput,
+          { runId }
+        );
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, ownerHostId: owner.hostId });
+        return yield* write(
+          method,
+          import_effect.Effect.gen(function* () {
+            const outcome = yield* consensus[method](runId, owner, nowMs);
+            if (outcome._tag === "Lost") {
+              const current2 = yield* selectRun(sql, runId);
+              return current2.length === 0 ? notFound : fenceLost;
+            }
+            const rows = yield* sql`
+          UPDATE flows_runs
+          SET heartbeat_at_ms = ${Dialect.greatest(sql)}(heartbeat_at_ms, ${outcome.heartbeatAtMs})
+          WHERE run_id = ${runId}
+            AND status = 'running'
+            AND owner_host_id = ${owner.hostId}
+            AND owner_pid = ${owner.pid}
+            AND owner_nonce = ${owner.nonce}
+          RETURNING run_id AS "runId"
+        `;
+            if (rows.length > 0) return updated;
+            const current = yield* selectRun(sql, runId);
+            return current.length === 0 ? notFound : fenceLost;
+          })
+        );
+      }).pipe((0, import_SpanOutcome.observeOutcome)((outcome) => RunStoreMetrics.heartbeat[outcome._tag], RunStoreMetrics.heartbeats))
+    );
+    const heartbeat = renewLease("heartbeat");
+    const reconfirm = renewLease("reconfirm");
+    const transitionOwned = import_effect.Effect.fn("RunStore.transitionOwned")(
+      (runIdInput, ownerInput, toStatusInput, stateInput, guardInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("transitionOwned", runIdInput);
+        const owner = yield* snapshotOwner("transitionOwned", "owner", ownerInput);
+        if (!import_effect.Schema.is(RunStatus)(toStatusInput) || toStatusInput === "pending") {
+          return yield* import_effect.Effect.fail(invalidRunError("transitionOwned", "toStatus"));
+        }
+        const toStatus = toStatusInput;
+        const state = stateInput === void 0 ? null : yield* snapshotState("transitionOwned", stateInput, {
+          runId,
+          stateJsonLength: typeof stateInput === "string" ? stateInput.length : null,
+          stateJsonValid: isJsonString(stateInput)
+        });
+        const guard = yield* snapshotGuard(guardInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, ownerHostId: owner.hostId, to: toStatus });
+        const transitionedAtMs = yield* import_effect.Clock.currentTimeMillis.pipe(import_effect.Effect.map(Math.floor));
+        const outcome = yield* write(
+          "transitionOwned",
+          import_effect.Effect.gen(function* () {
+            const held = yield* consensus.guard(runId, owner).pipe(
+              import_effect.Effect.as(true),
+              import_effect.Effect.catch((cause) => cause.code === "fence_lost" ? import_effect.Effect.succeed(false) : import_effect.Effect.fail(cause))
+            );
+            const row = (yield* selectRun(sql, runId))[0];
+            if (row === void 0) return notFound;
+            if (!held || !rowOwnedBy(row, owner)) return fenceLost;
+            const guardBlocked = guard?.cancelRequested === "absent" && row.cancelRequestedAtMs !== null || guard?.cancelRequested === "present" && row.cancelRequestedAtMs === null;
+            if (guardBlocked) return guardFailed;
+            if (toStatus === "running") {
+              yield* sql`
+                UPDATE flows_runs
+                SET
+                  status = 'running',
+                  finished_at_ms = NULL,
+                  state_json = COALESCE(${state}, state_json)
+                WHERE run_id = ${runId}
+              `;
+              return transitioned;
+            }
+            yield* sql`
+                UPDATE flows_runs
+                SET
+                  status = ${toStatus},
+                  finished_at_ms = ${terminalStatuses.has(toStatus) ? transitionedAtMs : null},
+                  owner_host_id = NULL,
+                  owner_pid = NULL,
+                  owner_nonce = NULL,
+                  heartbeat_at_ms = NULL,
+                  claim_host_id = NULL,
+                  claim_pid = NULL,
+                  claim_nonce = NULL,
+                  claimed_at_ms = NULL,
+                  state_json = COALESCE(${state}, state_json)
+                WHERE run_id = ${runId}
+              `;
+            yield* consensus.release(runId, owner);
+            yield* recordTransition(runId, "released", owner, null);
+            if (terminalStatuses.has(toStatus)) {
+              yield* (0, import_DurableWriter.afterCommit)(import_effect.Metric.update(ObservabilityMetric.runThroughput, 1), sql);
+            }
+            return transitioned;
+          })
+        );
+        return outcome;
+      }).pipe(
+        (0, import_SpanOutcome.observeOutcome)((outcome) => import_effect.Metric.withAttributes(RunStoreMetrics.transition[outcome._tag], {
+          to: toStatusInput
+        }), import_effect.Metric.withAttributes(RunStoreMetrics.transitions, { to: toStatusInput }))
+      )
+    );
+    const steal = import_effect.Effect.fn("RunStore.steal")(
+      (runIdInput, expectedInput, claimantInput, nowMsInput, evidenceInput) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("steal", runIdInput);
+        const expected = yield* snapshotExpected("steal", expectedInput);
+        const claimant = yield* snapshotOwner("steal", "claimant", claimantInput);
+        const nowMs = yield* snapshotLeaseReading(
+          "steal",
+          "nowMs",
+          nowMsInput,
+          { runId }
+        );
+        const evidence = yield* snapshotEvidence("steal", evidenceInput);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, claimantHostId: claimant.hostId });
+        return yield* import_effect.Effect.suspend(() => {
+          if (!evidenceMatches(expected, claimant, nowMs, evidence)) {
+            return import_effect.Effect.succeed(livenessUnconfirmed);
+          }
+          return write(
+            "steal",
+            import_effect.Effect.gen(function* () {
+              const row = (yield* selectRun(sql, runId))[0];
+              const admissible = row !== void 0 && rowMatchesSnapshot(row, expected) && claimColumnsFree(row) && row.heartbeatAtMs !== null && row.heartbeatAtMs < nowMs - heartbeatStaleAfterMs;
+              if (!admissible) return classifyClaimLoss(row, nowMs);
+              const grant = yield* consensus.steal(runId, claimant, nowMs, evidence);
+              if (grant._tag === "Rejected") {
+                return classifyClaimLoss(row, nowMs);
+              }
+              yield* sql`
+          UPDATE flows_runs
+          SET
+            claim_host_id = ${claimant.hostId},
+            claim_pid = ${claimant.pid},
+            claim_nonce = ${claimant.nonce},
+            claimed_at_ms = ${grant.grantedAtMs}
+          WHERE run_id = ${runId}
+        `;
+              yield* recordTransition(runId, "stolen", claimant, grant.grantedAtMs);
+              return claimed(grant.grantedAtMs);
+            })
+          );
+        });
+      }).pipe((0, import_SpanOutcome.observeOutcome)(
+        (outcome) => RunStoreMetrics.steal[outcome._tag],
+        import_effect.Metric.withAttributes(RunStoreMetrics.claims, { op: "steal" })
+      ))
+    );
+    const acknowledgeCancel = import_effect.Effect.fn("RunStore.acknowledgeCancel")(
+      (id, ownerInput, time) => import_effect.Effect.gen(function* () {
+        const runId = yield* snapshotRunId("acknowledgeCancel", id);
+        const owner = yield* snapshotOwner("acknowledgeCancel", "owner", ownerInput);
+        const observedAtMs = yield* snapshotTimestamp("acknowledgeCancel", "nowMs", time);
+        yield* import_effect.Effect.annotateCurrentSpan({ runId, ownerHostId: owner.hostId });
+        const acknowledgement = JSON.stringify({ observedAtMs, owner });
+        return yield* write(
+          "acknowledgeCancel",
+          sql`
+        UPDATE flows_runs
+        SET cancel_acknowledgement_json = COALESCE(cancel_acknowledgement_json, ${acknowledgement})
+        WHERE run_id = ${runId} AND status = 'running' AND cancel_requested_at_ms IS NOT NULL
+          AND owner_host_id = ${owner.hostId} AND owner_pid = ${owner.pid} AND owner_nonce = ${owner.nonce}
+        RETURNING run_id
+      `.pipe(import_effect.Effect.map((rows) => rows.length > 0))
+        );
+      }).pipe(import_SpanOutcome.observeExit)
+    );
+    return RunStore.of({
+      create,
+      get,
+      lineage,
+      latestRound,
+      requestCancel,
+      acknowledgeCancel,
+      requestCancelLineage,
+      claim,
+      claimAndOwn,
+      activate,
+      abandonClaim,
+      recoverClaim,
+      heartbeat,
+      reconfirm,
+      transitionOwned,
+      steal
+    });
+  }
+);
+const makeNoop = (overrides = {}) => {
+  const unavailable = (method) => import_effect.Effect.fail(runStoreError(method, "persistence_failed", "no run store in this environment", method));
+  return RunStore.of({
+    create: import_effect.Effect.fn("RunStore.create")(() => unavailable("create")),
+    get: import_effect.Effect.fn("RunStore.get")(() => unavailable("get")),
+    lineage: import_effect.Effect.fn("RunStore.lineage")(() => unavailable("lineage")),
+    latestRound: import_effect.Effect.fn("RunStore.latestRound")(() => unavailable("latestRound")),
+    requestCancel: import_effect.Effect.fn("RunStore.requestCancel")(() => import_effect.Effect.succeed(notFound)),
+    acknowledgeCancel: import_effect.Effect.fn("RunStore.acknowledgeCancel")(() => import_effect.Effect.succeed(false)),
+    requestCancelLineage: import_effect.Effect.fn("RunStore.requestCancelLineage")(() => unavailable("requestCancelLineage")),
+    claim: import_effect.Effect.fn("RunStore.claim")(() => import_effect.Effect.succeed(notFound)),
+    claimAndOwn: import_effect.Effect.fn("RunStore.claimAndOwn")(() => import_effect.Effect.succeed(notFound)),
+    activate: import_effect.Effect.fn("RunStore.activate")(() => import_effect.Effect.succeed(claimLost)),
+    abandonClaim: import_effect.Effect.fn("RunStore.abandonClaim")(() => import_effect.Effect.succeed(claimLost)),
+    recoverClaim: import_effect.Effect.fn("RunStore.recoverClaim")(() => import_effect.Effect.succeed(notFound)),
+    heartbeat: import_effect.Effect.fn("RunStore.heartbeat")(() => import_effect.Effect.succeed(notFound)),
+    reconfirm: import_effect.Effect.fn("RunStore.reconfirm")(() => import_effect.Effect.succeed(notFound)),
+    transitionOwned: import_effect.Effect.fn("RunStore.transitionOwned")(() => import_effect.Effect.succeed(notFound)),
+    steal: import_effect.Effect.fn("RunStore.steal")(() => import_effect.Effect.succeed(notFound)),
+    ...overrides
+  });
+};
+const layerNoop = (overrides = {}) => import_effect.Layer.succeed(RunStore)(makeNoop(overrides));
+const layerWith = import_effect.Layer.effect(
+  RunStore,
+  make
+);
+const layer = layerWith.pipe(
+  import_effect.Layer.provide(SqlConsensus.layer)
+);
+//# sourceMappingURL=RunStore.js.map