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

package/dist/cjs/AttemptStore.js

@@ -0,0 +1,731 @@
+"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 AttemptStore_exports = {};
+__export(AttemptStore_exports, {
+  Attempt: () => Attempt,
+  AttemptId: () => AttemptId,
+  AttemptPatch: () => AttemptPatch,
+  AttemptStore: () => AttemptStore,
+  AttemptStoreError: () => AttemptStoreError,
+  AttemptStoreErrorCode: () => AttemptStoreErrorCode,
+  FinishAttempt: () => FinishAttempt,
+  JsonValue: () => JsonValue,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  layerWith: () => layerWith,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  makeWith: () => makeWith,
+  maximumCheckpointBytes: () => maximumCheckpointBytes,
+  maximumJsonDepth: () => maximumJsonDepth,
+  maximumJsonNodes: () => maximumJsonNodes
+});
+module.exports = __toCommonJS(AttemptStore_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var SqlError = __toESM(require("effect/unstable/sql/SqlError"), 1);
+var Boundary = __toESM(require("./internal/Boundary.js"), 1);
+var import_SpanOutcome = require("./internal/SpanOutcome.js");
+const NonNegativeSafeInt = Schema.Int.check(
+  Schema.isGreaterThanOrEqualTo(0),
+  Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+);
+const durableIdentifier = Schema.NonEmptyString.check(
+  Schema.isMaxLength(Boundary.maximumIdentifierLength),
+  Schema.makeFilter((value) => Boundary.isDurableText(value), { title: "durableIdentifier" })
+);
+const maximumCheckpointBytes = 16 * 1024 * 1024;
+const maximumJsonDepth = 128;
+const maximumJsonNodes = 1e5;
+const jsonLimits = (maxBytes) => ({
+  ...maxBytes === void 0 ? {} : { maxBytes, maxStringBytes: maxBytes },
+  maxDepth: maximumJsonDepth,
+  maxMembers: maximumJsonNodes,
+  maxNodes: maximumJsonNodes
+});
+const JsonValue = Schema.declare(
+  (value) => Boundary.admitJson(value, jsonLimits()).ok,
+  { identifier: "@smthrs/run-store/JsonValue" }
+);
+const AttemptStoreErrorCode = Schema.Literals([
+  "invalid_attempt",
+  "constraint",
+  "decode_failed",
+  "persistence_failed",
+  "unknown"
+]);
+class AttemptStoreError extends Schema.TaggedError()(
+  "@smthrs/run-store/AttemptStoreError",
+  {
+    code: AttemptStoreErrorCode,
+    method: Schema.String,
+    message: Schema.String,
+    cause: Schema.optional(Schema.Unknown)
+  }
+) {
+}
+const AttemptId = Schema.Struct({
+  runId: durableIdentifier,
+  stepKeyDigest: durableIdentifier,
+  attempt: NonNegativeSafeInt
+});
+const Attempt = Schema.Struct({
+  ...AttemptId.fields,
+  state: durableIdentifier,
+  startedAtMs: NonNegativeSafeInt,
+  finishedAtMs: Schema.optionalKey(NonNegativeSafeInt),
+  heartbeatAtMs: Schema.optionalKey(NonNegativeSafeInt),
+  checkpoint: Schema.optionalKey(JsonValue),
+  error: Schema.optionalKey(JsonValue),
+  outcome: Schema.optionalKey(JsonValue),
+  meta: JsonValue
+});
+const FinishAttempt = Schema.Struct({
+  ...AttemptId.fields,
+  state: durableIdentifier,
+  finishedAtMs: NonNegativeSafeInt,
+  error: Schema.optionalKey(JsonValue),
+  outcome: Schema.optionalKey(JsonValue),
+  meta: Schema.optionalKey(JsonValue)
+});
+const AttemptPatch = Schema.Struct({
+  checkpoint: Schema.optionalKey(JsonValue),
+  error: Schema.optionalKey(JsonValue),
+  outcome: Schema.optionalKey(JsonValue),
+  meta: Schema.optionalKey(JsonValue)
+});
+class AttemptStore extends Context.Service()("@smthrs/run-store/AttemptStore") {
+}
+const AttemptRow = Schema.Struct({
+  run_id: durableIdentifier,
+  step_key_digest: durableIdentifier,
+  attempt: NonNegativeSafeInt,
+  state: durableIdentifier,
+  started_at_ms: NonNegativeSafeInt,
+  finished_at_ms: Schema.NullOr(NonNegativeSafeInt),
+  heartbeat_at_ms: Schema.NullOr(NonNegativeSafeInt),
+  checkpoint_json: Schema.NullOr(Schema.String),
+  error_json: Schema.NullOr(Schema.String),
+  outcome_json: Schema.NullOr(Schema.String),
+  meta_json: Schema.String
+});
+const attemptStoreError = (method, code, detail, cause) => new AttemptStoreError({
+  code,
+  method,
+  message: `${code}: AttemptStore.${method}: ${detail}`,
+  cause
+});
+const error = (method, code, detail) => attemptStoreError(method, code, detail);
+const encode = (method, value, field, maxBytes) => Effect.suspend(() => {
+  const admitted = Boundary.admitJson(value, jsonLimits(maxBytes));
+  return admitted.ok ? Effect.succeed(JSON.stringify(admitted.value)) : Effect.fail(error(method, "invalid_attempt", `${field} ${admitted.complaint}`));
+});
+const encodeOptionalWith = (method) => (value, field) => value === void 0 ? Effect.succeed(null) : encode(method, value, field);
+const defaultMaxCheckpointBytes = 1024 * 1024;
+const defaultInProgressStates = ["running"];
+const encodeCheckpointWith = (method, maxBytes) => (value) => value === void 0 ? Effect.succeed(null) : encode(method, value, "checkpoint", maxBytes);
+const decode = (method, value, field, maxBytes) => Effect.suspend(() => {
+  if (value === null) return Effect.succeed(void 0);
+  const admitted = Boundary.admitJsonText(value, jsonLimits(maxBytes));
+  return admitted.ok ? Effect.succeed(admitted.json) : Effect.fail(error(method, "decode_failed", `${field} ${admitted.complaint}`));
+});
+const decodeRequired = (method, value, field, maxBytes) => (
+  // A non-null SQL column cannot take `decode`'s missing-value branch.
+  decode(method, value, field, maxBytes)
+);
+const validateId = (method, id) => Boundary.isDurableText(id.runId) && Boundary.isDurableText(id.stepKeyDigest) && Number.isSafeInteger(id.attempt) && id.attempt >= 0 ? Effect.void : Effect.fail(
+  error(method, "invalid_attempt", "attempt identity violates the durable identifier contract")
+);
+const inspectRecord = (input, required, optional, field) => {
+  if (typeof input !== "object" || input === null) throw new TypeError(field);
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) throw new TypeError(field);
+  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const name of required) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, name);
+    if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) throw new TypeError(field);
+    output[name] = descriptor.value;
+  }
+  for (const name of optional) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, name);
+    if (descriptor === void 0) continue;
+    if (!("value" in descriptor) || !descriptor.enumerable) throw new TypeError(field);
+    if (descriptor.value !== void 0) output[name] = descriptor.value;
+  }
+  for (const key of Reflect.ownKeys(input)) {
+    if (typeof key !== "string" || !allowed.has(key)) {
+      if (Object.getOwnPropertyDescriptor(input, key)?.enumerable) throw new TypeError(field);
+    }
+  }
+  return output;
+};
+const snapshotOwner = (method, input) => Effect.suspend(() => {
+  try {
+    const values = inspectRecord(input, ["hostId", "pid", "nonce"], [], "owner");
+    const owner = Object.freeze({ hostId: values.hostId, pid: values.pid, nonce: values.nonce });
+    if (Boundary.isDurableText(owner.hostId) && Boundary.isDurableText(owner.nonce) && Number.isSafeInteger(owner.pid) && owner.pid >= 0) {
+      return Effect.succeed(owner);
+    }
+  } catch {
+  }
+  return Effect.fail(error(method, "invalid_attempt", "owner must be an inert, valid owner identity"));
+});
+const snapshotJson = (method, value, field, maxBytes) => {
+  const admitted = Boundary.admitJson(value, jsonLimits(maxBytes));
+  return admitted.ok ? { ok: true, value: admitted.value } : { ok: false, error: error(method, "invalid_attempt", `${field} ${admitted.complaint}`) };
+};
+const inspectIdRecord = (input, field) => {
+  if (typeof input !== "object" || input === null) throw new TypeError(field);
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) throw new TypeError(field);
+  for (const key of Reflect.ownKeys(input)) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (descriptor !== void 0 && descriptor.enumerable && !("value" in descriptor)) throw new TypeError(field);
+  }
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const name of ["runId", "stepKeyDigest", "attempt"]) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, name);
+    if (descriptor === void 0 || !("value" in descriptor) || !descriptor.enumerable) throw new TypeError(field);
+    output[name] = descriptor.value;
+  }
+  return output;
+};
+const snapshotId = (method, input) => Effect.suspend(() => {
+  try {
+    const values = inspectIdRecord(input, "attempt id");
+    const id = Object.freeze({
+      runId: values.runId,
+      stepKeyDigest: values.stepKeyDigest,
+      attempt: values.attempt
+    });
+    return Effect.as(validateId(method, id), id);
+  } catch {
+    return Effect.fail(error(method, "invalid_attempt", "attempt id must be an inert data record"));
+  }
+});
+const snapshotAttempt = (method, input) => Effect.suspend(() => {
+  try {
+    const values = inspectRecord(
+      input,
+      ["runId", "stepKeyDigest", "attempt", "state", "startedAtMs", "meta"],
+      ["finishedAtMs", "heartbeatAtMs", "checkpoint", "error", "outcome"],
+      "attempt"
+    );
+    const checkpoint = values.checkpoint === void 0 ? void 0 : snapshotJson(method, values.checkpoint, "checkpoint", maximumCheckpointBytes);
+    const attemptError = values.error === void 0 ? void 0 : snapshotJson(method, values.error, "error");
+    const outcome = values.outcome === void 0 ? void 0 : snapshotJson(method, values.outcome, "outcome");
+    const meta = snapshotJson(method, values.meta, "meta");
+    if (checkpoint !== void 0 && !checkpoint.ok) return Effect.fail(checkpoint.error);
+    if (attemptError !== void 0 && !attemptError.ok) return Effect.fail(attemptError.error);
+    if (outcome !== void 0 && !outcome.ok) return Effect.fail(outcome.error);
+    if (!meta.ok) return Effect.fail(meta.error);
+    const candidate = Object.freeze({
+      runId: values.runId,
+      stepKeyDigest: values.stepKeyDigest,
+      attempt: values.attempt,
+      state: values.state,
+      startedAtMs: values.startedAtMs,
+      ...values.finishedAtMs === void 0 ? {} : { finishedAtMs: values.finishedAtMs },
+      ...values.heartbeatAtMs === void 0 ? {} : { heartbeatAtMs: values.heartbeatAtMs },
+      ...checkpoint === void 0 ? {} : { checkpoint: checkpoint.value },
+      ...attemptError === void 0 ? {} : { error: attemptError.value },
+      ...outcome === void 0 ? {} : { outcome: outcome.value },
+      meta: meta.value
+    });
+    return Schema.decodeUnknownEffect(Attempt)(candidate).pipe(
+      Effect.mapError(() => error(method, "invalid_attempt", "attempt violates the persistence contract"))
+    );
+  } catch {
+    return Effect.fail(error(method, "invalid_attempt", "attempt must be an inert data record"));
+  }
+});
+const snapshotFinish = (method, input) => Effect.suspend(() => {
+  try {
+    const values = inspectRecord(
+      input,
+      ["runId", "stepKeyDigest", "attempt", "state", "finishedAtMs"],
+      ["error", "outcome", "meta"],
+      "finished attempt"
+    );
+    const attemptError = values.error === void 0 ? void 0 : snapshotJson(method, values.error, "error");
+    const outcome = values.outcome === void 0 ? void 0 : snapshotJson(method, values.outcome, "outcome");
+    const meta = values.meta === void 0 ? void 0 : snapshotJson(method, values.meta, "meta");
+    if (attemptError !== void 0 && !attemptError.ok) return Effect.fail(attemptError.error);
+    if (outcome !== void 0 && !outcome.ok) return Effect.fail(outcome.error);
+    if (meta !== void 0 && !meta.ok) return Effect.fail(meta.error);
+    return Schema.decodeUnknownEffect(FinishAttempt)(Object.freeze({
+      runId: values.runId,
+      stepKeyDigest: values.stepKeyDigest,
+      attempt: values.attempt,
+      state: values.state,
+      finishedAtMs: values.finishedAtMs,
+      ...attemptError === void 0 ? {} : { error: attemptError.value },
+      ...outcome === void 0 ? {} : { outcome: outcome.value },
+      ...meta === void 0 ? {} : { meta: meta.value }
+    })).pipe(Effect.mapError(() => error(method, "invalid_attempt", "finished attempt violates the contract")));
+  } catch {
+    return Effect.fail(error(method, "invalid_attempt", "finished attempt must be an inert data record"));
+  }
+});
+const snapshotPatch = (method, input) => Effect.suspend(() => {
+  try {
+    const values = inspectRecord(input, [], ["checkpoint", "error", "outcome", "meta"], "attempt patch");
+    const checkpoint = values.checkpoint === void 0 ? void 0 : snapshotJson(method, values.checkpoint, "checkpoint", maximumCheckpointBytes);
+    const attemptError = values.error === void 0 ? void 0 : snapshotJson(method, values.error, "error");
+    const outcome = values.outcome === void 0 ? void 0 : snapshotJson(method, values.outcome, "outcome");
+    const meta = values.meta === void 0 ? void 0 : snapshotJson(method, values.meta, "meta");
+    if (checkpoint !== void 0 && !checkpoint.ok) return Effect.fail(checkpoint.error);
+    if (attemptError !== void 0 && !attemptError.ok) return Effect.fail(attemptError.error);
+    if (outcome !== void 0 && !outcome.ok) return Effect.fail(outcome.error);
+    if (meta !== void 0 && !meta.ok) return Effect.fail(meta.error);
+    return Effect.succeed(Object.freeze({
+      ...checkpoint === void 0 ? {} : { checkpoint: checkpoint.value },
+      ...attemptError === void 0 ? {} : { error: attemptError.value },
+      ...outcome === void 0 ? {} : { outcome: outcome.value },
+      ...meta === void 0 ? {} : { meta: meta.value }
+    }));
+  } catch {
+    return Effect.fail(error(method, "invalid_attempt", "attempt patch must be an inert data record"));
+  }
+});
+const snapshotOptions = (method, input) => Effect.suspend(() => {
+  try {
+    const values = inspectRecord(
+      input,
+      [],
+      ["inProgressStates", "maxCheckpointBytes", "putMode"],
+      "attempt store options"
+    );
+    const rawStates = values.inProgressStates ?? defaultInProgressStates;
+    const admitted = Boundary.admitJson(rawStates, {
+      ...jsonLimits(64 * 1024),
+      maxDepth: 2,
+      maxMembers: 256,
+      maxNodes: 257
+    });
+    if (!admitted.ok || !Array.isArray(admitted.value)) {
+      return Effect.fail(error(method, "invalid_attempt", "inProgressStates must be an inert string array"));
+    }
+    const states = admitted.value;
+    if (states.length === 0 || states.some((state) => !Boundary.isDurableText(state)) || new Set(states).size !== states.length) {
+      return Effect.fail(
+        error(method, "invalid_attempt", "inProgressStates must contain unique durable state names")
+      );
+    }
+    const maxCheckpointBytes = values.maxCheckpointBytes ?? defaultMaxCheckpointBytes;
+    if (typeof maxCheckpointBytes !== "number" || !Number.isSafeInteger(maxCheckpointBytes) || maxCheckpointBytes <= 0 || maxCheckpointBytes > maximumCheckpointBytes) {
+      return Effect.fail(
+        error(method, "invalid_attempt", `maxCheckpointBytes must be between 1 and ${maximumCheckpointBytes}`)
+      );
+    }
+    const putMode = values.putMode ?? "insert";
+    if (putMode !== "insert" && putMode !== "upsert") {
+      return Effect.fail(error(method, "invalid_attempt", "putMode must be insert or upsert"));
+    }
+    return Effect.succeed(Object.freeze({
+      inProgressStates: Object.freeze([...states]),
+      maxCheckpointBytes,
+      putMode
+    }));
+  } catch {
+    return Effect.fail(error(method, "invalid_attempt", "attempt store options must be an inert data record"));
+  }
+});
+const ownsRunningRun = (row, owner) => row.status === "running" && row.owner_host_id === owner.hostId && row.owner_pid === owner.pid && row.owner_nonce === owner.nonce;
+const sameAttempt = (stored, expected) => stored.state === expected.state && stored.startedAtMs === expected.startedAtMs && stored.finishedAtMs === expected.finishedAtMs && stored.heartbeatAtMs === expected.heartbeatAtMs && Boundary.sameJson(stored.checkpoint, expected.checkpoint) && Boundary.sameJson(stored.error, expected.error) && Boundary.sameJson(stored.outcome, expected.outcome) && Boundary.sameJson(stored.meta, expected.meta);
+const mapPersistenceError = (method) => (cause) => {
+  if (Schema.is(AttemptStoreError)(cause)) {
+    return cause;
+  }
+  const sqlError = SqlError.isSqlError(cause);
+  const databaseError = Schema.is(import_DurableWriter.DatabaseError)(cause);
+  const constraint = sqlError ? cause.reason instanceof SqlError.ConstraintError || cause.reason instanceof SqlError.UniqueViolation : databaseError && cause.code === "constraint";
+  const code = constraint ? "constraint" : "persistence_failed";
+  return attemptStoreError(
+    method,
+    code,
+    "attempt persistence failed",
+    {
+      category: code,
+      reason: sqlError ? cause.reason._tag : databaseError ? cause.code : "unknown",
+      // The outer writer must still recognize a nested savepoint's conflict.
+      ...sqlError || databaseError ? { cause: new import_DurableWriter.DatabaseError({ code: sqlError ? (0, import_DurableWriter.fromSqlError)(cause).code : cause.code }) } : {}
+    }
+  );
+};
+const decodeRow = (method, input) => Schema.decodeUnknownEffect(AttemptRow)(input).pipe(
+  Effect.mapError(() => error(method, "decode_failed", "could not decode flows_attempts row")),
+  Effect.flatMap(
+    (row) => Effect.all({
+      checkpoint: decode(method, row.checkpoint_json, "checkpoint_json", maximumCheckpointBytes),
+      error: decode(method, row.error_json, "error_json"),
+      outcome: decode(method, row.outcome_json, "outcome_json"),
+      meta: decodeRequired(method, row.meta_json, "meta_json")
+    }).pipe(
+      Effect.map(
+        ({ checkpoint, error: attemptError, outcome, meta }) => Object.freeze({
+          runId: row.run_id,
+          stepKeyDigest: row.step_key_digest,
+          attempt: row.attempt,
+          state: row.state,
+          startedAtMs: row.started_at_ms,
+          ...row.finished_at_ms === null ? {} : { finishedAtMs: row.finished_at_ms },
+          ...row.heartbeat_at_ms === null ? {} : { heartbeatAtMs: row.heartbeat_at_ms },
+          ...checkpoint === void 0 ? {} : { checkpoint },
+          ...attemptError === void 0 ? {} : { error: attemptError },
+          ...outcome === void 0 ? {} : { outcome },
+          meta
+        })
+      )
+    )
+  )
+);
+const makeWith = (options = {}) => Effect.gen(function* () {
+  const sql = yield* Effect.service(SqlClient.SqlClient);
+  const writer = yield* import_DurableWriter.DurableWriter;
+  const configured = yield* snapshotOptions("makeWith", options);
+  const inProgressStates = configured.inProgressStates;
+  const maxCheckpointBytes = configured.maxCheckpointBytes;
+  const upsert = configured.putMode === "upsert";
+  const putEncodeOptional = encodeOptionalWith("put");
+  const putEncodeCheckpoint = encodeCheckpointWith("put", maxCheckpointBytes);
+  const heartbeatEncodeCheckpoint = encodeCheckpointWith("heartbeat", maxCheckpointBytes);
+  const finishEncodeOptional = encodeOptionalWith("finish");
+  const patchEncodeOptional = encodeOptionalWith("patch");
+  const patchEncodeCheckpoint = encodeCheckpointWith("patch", maxCheckpointBytes);
+  const inProgress = sql.in("state", [...inProgressStates]);
+  const put = Effect.fn("AttemptStore.put")(
+    (input, ownerInput) => Effect.gen(function* () {
+      const owner = yield* snapshotOwner("put", ownerInput);
+      const attempt = yield* snapshotAttempt("put", input);
+      yield* Effect.annotateCurrentSpan({
+        runId: attempt.runId,
+        stepKeyDigest: attempt.stepKeyDigest,
+        attempt: attempt.attempt,
+        ownerHostId: owner.hostId
+      });
+      const checkpoint = yield* putEncodeCheckpoint(attempt.checkpoint);
+      const attemptError = yield* putEncodeOptional(attempt.error, "error");
+      const outcome = yield* putEncodeOptional(attempt.outcome, "outcome");
+      const meta = yield* encode("put", attempt.meta, "meta");
+      return yield* writer.write(
+        Effect.gen(function* () {
+          const inserted = yield* sql`
+            INSERT INTO flows_attempts (
+              run_id, step_key_digest, attempt, state, started_at_ms, finished_at_ms,
+              heartbeat_at_ms, checkpoint_json, error_json, outcome_json, meta_json
+            )
+            SELECT
+              ${attempt.runId}, ${attempt.stepKeyDigest}, ${attempt.attempt}, ${attempt.state},
+              ${attempt.startedAtMs}, ${attempt.finishedAtMs ?? null}, ${attempt.heartbeatAtMs ?? null},
+              ${checkpoint}, ${attemptError}, ${outcome}, ${meta}
+            WHERE EXISTS (
+              SELECT 1 FROM flows_runs
+              WHERE run_id = ${attempt.runId}
+                AND status = 'running'
+                AND owner_host_id = ${owner.hostId}
+                AND owner_pid = ${owner.pid}
+                AND owner_nonce = ${owner.nonce}
+            )
+            ON CONFLICT (run_id, step_key_digest, attempt) DO NOTHING
+            RETURNING attempt
+          `;
+          if (inserted.length > 0) {
+            return { _tag: "Inserted" };
+          }
+          if (upsert) {
+            const replaced = yield* sql`
+              UPDATE flows_attempts
+              SET
+                state = ${attempt.state},
+                started_at_ms = ${attempt.startedAtMs},
+                finished_at_ms = ${attempt.finishedAtMs ?? null},
+                heartbeat_at_ms = ${attempt.heartbeatAtMs ?? null},
+                checkpoint_json = ${checkpoint},
+                error_json = ${attemptError},
+                outcome_json = ${outcome},
+                meta_json = ${meta}
+              WHERE run_id = ${attempt.runId}
+                AND step_key_digest = ${attempt.stepKeyDigest}
+                AND attempt = ${attempt.attempt}
+                AND ${inProgress}
+                AND EXISTS (
+                  SELECT 1 FROM flows_runs
+                  WHERE run_id = ${attempt.runId}
+                    AND status = 'running'
+                    AND owner_host_id = ${owner.hostId}
+                    AND owner_pid = ${owner.pid}
+                    AND owner_nonce = ${owner.nonce}
+                )
+              RETURNING attempt
+            `;
+            if (replaced.length > 0) {
+              return { _tag: "Upserted" };
+            }
+          }
+          const runRows = yield* sql`
+            SELECT status, owner_host_id, owner_pid, owner_nonce
+            FROM flows_runs WHERE run_id = ${attempt.runId}
+          `;
+          if (runRows.length === 0) {
+            return { _tag: "RunNotFound" };
+          }
+          if (!ownsRunningRun(runRows[0], owner)) {
+            return { _tag: "FenceLost" };
+          }
+          const rows = yield* sql`
+            SELECT run_id, step_key_digest, attempt, state, started_at_ms, finished_at_ms,
+              heartbeat_at_ms, checkpoint_json, error_json, outcome_json, meta_json
+            FROM flows_attempts
+            WHERE run_id = ${attempt.runId}
+              AND step_key_digest = ${attempt.stepKeyDigest}
+              AND attempt = ${attempt.attempt}
+          `;
+          if (rows.length === 0) {
+            return yield* Effect.fail(error("put", "unknown", "attempt disappeared during put"));
+          }
+          const stored = yield* decodeRow("put", rows[0]);
+          return sameAttempt(stored, attempt) ? { _tag: "ExistingSame" } : { _tag: "Conflict" };
+        })
+      ).pipe(Effect.mapError(mapPersistenceError("put")));
+    }).pipe((0, import_SpanOutcome.observeOutcome)())
+  );
+  const get = Effect.fn("AttemptStore.get")(
+    (input) => Effect.gen(function* () {
+      const id = yield* snapshotId("get", input);
+      yield* Effect.annotateCurrentSpan({
+        runId: id.runId,
+        stepKeyDigest: id.stepKeyDigest,
+        attempt: id.attempt
+      });
+      const rows = yield* sql`
+        SELECT run_id, step_key_digest, attempt, state, started_at_ms, finished_at_ms,
+          heartbeat_at_ms, checkpoint_json, error_json, outcome_json, meta_json
+        FROM flows_attempts
+        WHERE run_id = ${id.runId} AND step_key_digest = ${id.stepKeyDigest} AND attempt = ${id.attempt}
+      `.pipe(Effect.mapError(mapPersistenceError("get")));
+      return rows.length === 0 ? Option.none() : yield* Effect.map(decodeRow("get", rows[0]), Option.some);
+    }).pipe(import_SpanOutcome.observeExit)
+  );
+  const heartbeat = Effect.fn("AttemptStore.heartbeat")(
+    (runId, stepKeyDigest, attempt, ownerInput, nowMs, checkpointValue) => Effect.gen(function* () {
+      const owner = yield* snapshotOwner("heartbeat", ownerInput);
+      yield* validateId("heartbeat", { runId, stepKeyDigest, attempt });
+      if (!Number.isSafeInteger(nowMs) || nowMs < 0) {
+        return yield* Effect.fail(
+          error("heartbeat", "invalid_attempt", "nowMs must be a non-negative safe integer")
+        );
+      }
+      yield* Effect.annotateCurrentSpan({ runId, stepKeyDigest, attempt, ownerHostId: owner.hostId });
+      const checkpoint = yield* heartbeatEncodeCheckpoint(checkpointValue);
+      return yield* writer.write(
+        Effect.gen(function* () {
+          const updated = yield* sql`
+            UPDATE flows_attempts
+            SET
+              heartbeat_at_ms = ${Dialect.greatest(sql)}(COALESCE(heartbeat_at_ms, ${nowMs}), ${nowMs}),
+              checkpoint_json = COALESCE(${checkpoint}, checkpoint_json)
+            WHERE run_id = ${runId}
+              AND step_key_digest = ${stepKeyDigest}
+              AND attempt = ${attempt}
+              AND ${inProgress}
+              AND EXISTS (
+                SELECT 1 FROM flows_runs
+                WHERE run_id = ${runId}
+                  AND status = 'running'
+                  AND owner_host_id = ${owner.hostId}
+                  AND owner_pid = ${owner.pid}
+                  AND owner_nonce = ${owner.nonce}
+              )
+            RETURNING attempt
+          `;
+          if (updated.length > 0) {
+            return { _tag: "Updated" };
+          }
+          const found = yield* sql`
+            SELECT state FROM flows_attempts
+            WHERE run_id = ${runId} AND step_key_digest = ${stepKeyDigest} AND attempt = ${attempt}
+          `;
+          if (found.length === 0) {
+            return { _tag: "NotFound" };
+          }
+          const runRows = yield* sql`
+            SELECT status, owner_host_id, owner_pid, owner_nonce
+            FROM flows_runs WHERE run_id = ${runId}
+          `;
+          if (runRows.length === 0 || !ownsRunningRun(runRows[0], owner)) {
+            return { _tag: "FenceLost" };
+          }
+          return { _tag: "StateChanged" };
+        })
+      ).pipe(Effect.mapError(mapPersistenceError("heartbeat")));
+    }).pipe((0, import_SpanOutcome.observeOutcome)())
+  );
+  const finish = Effect.fn("AttemptStore.finish")(
+    (input, ownerInput) => Effect.gen(function* () {
+      const owner = yield* snapshotOwner("finish", ownerInput);
+      const attempt = yield* snapshotFinish("finish", input);
+      yield* Effect.annotateCurrentSpan({
+        runId: attempt.runId,
+        stepKeyDigest: attempt.stepKeyDigest,
+        attempt: attempt.attempt,
+        ownerHostId: owner.hostId
+      });
+      if (inProgressStates.includes(attempt.state) || !Boundary.isDurableText(attempt.state)) {
+        return yield* Effect.fail(
+          error("finish", "invalid_attempt", "finish requires a terminal state and valid timestamp")
+        );
+      }
+      const attemptError = yield* finishEncodeOptional(attempt.error, "error");
+      const outcome = yield* finishEncodeOptional(attempt.outcome, "outcome");
+      const meta = yield* finishEncodeOptional(attempt.meta, "meta");
+      return yield* writer.write(
+        Effect.gen(function* () {
+          const updated = yield* sql`
+            UPDATE flows_attempts
+            SET
+              state = ${attempt.state},
+              finished_at_ms = ${attempt.finishedAtMs},
+              error_json = COALESCE(${attemptError}, error_json),
+              outcome_json = COALESCE(${outcome}, outcome_json),
+              meta_json = COALESCE(${meta}, meta_json)
+            WHERE run_id = ${attempt.runId}
+              AND step_key_digest = ${attempt.stepKeyDigest}
+              AND attempt = ${attempt.attempt}
+              AND ${inProgress}
+              AND EXISTS (
+                SELECT 1 FROM flows_runs
+                WHERE run_id = ${attempt.runId}
+                  AND status = 'running'
+                  AND owner_host_id = ${owner.hostId}
+                  AND owner_pid = ${owner.pid}
+                  AND owner_nonce = ${owner.nonce}
+              )
+            RETURNING attempt
+          `;
+          if (updated.length > 0) {
+            return { _tag: "Finished" };
+          }
+          const found = yield* sql`
+            SELECT state FROM flows_attempts
+            WHERE run_id = ${attempt.runId}
+              AND step_key_digest = ${attempt.stepKeyDigest}
+              AND attempt = ${attempt.attempt}
+          `;
+          if (found.length === 0) {
+            return { _tag: "NotFound" };
+          }
+          const runRows = yield* sql`
+            SELECT status, owner_host_id, owner_pid, owner_nonce
+            FROM flows_runs WHERE run_id = ${attempt.runId}
+          `;
+          if (runRows.length === 0 || !ownsRunningRun(runRows[0], owner)) {
+            return { _tag: "FenceLost" };
+          }
+          return { _tag: "StateChanged" };
+        })
+      ).pipe(Effect.mapError(mapPersistenceError("finish")));
+    }).pipe((0, import_SpanOutcome.observeOutcome)())
+  );
+  const patch = Effect.fn("AttemptStore.patch")(
+    (idInput, patchInput, ownerInput) => Effect.gen(function* () {
+      const owner = yield* snapshotOwner("patch", ownerInput);
+      const id = yield* snapshotId("patch", idInput);
+      const fields = yield* snapshotPatch("patch", patchInput);
+      yield* Effect.annotateCurrentSpan({
+        runId: id.runId,
+        stepKeyDigest: id.stepKeyDigest,
+        attempt: id.attempt,
+        ownerHostId: owner.hostId
+      });
+      const checkpoint = yield* patchEncodeCheckpoint(fields.checkpoint);
+      const attemptError = yield* patchEncodeOptional(fields.error, "error");
+      const outcome = yield* patchEncodeOptional(fields.outcome, "outcome");
+      const meta = yield* patchEncodeOptional(fields.meta, "meta");
+      return yield* writer.write(
+        Effect.gen(function* () {
+          const updated = yield* sql`
+            UPDATE flows_attempts
+            SET
+              checkpoint_json = COALESCE(${checkpoint}, checkpoint_json),
+              error_json = COALESCE(${attemptError}, error_json),
+              outcome_json = COALESCE(${outcome}, outcome_json),
+              meta_json = COALESCE(${meta}, meta_json)
+            WHERE run_id = ${id.runId}
+              AND step_key_digest = ${id.stepKeyDigest}
+              AND attempt = ${id.attempt}
+              AND EXISTS (
+                SELECT 1 FROM flows_runs
+                WHERE run_id = ${id.runId}
+                  AND status = 'running'
+                  AND owner_host_id = ${owner.hostId}
+                  AND owner_pid = ${owner.pid}
+                  AND owner_nonce = ${owner.nonce}
+              )
+            RETURNING attempt
+          `;
+          if (updated.length > 0) {
+            return { _tag: "Patched" };
+          }
+          const found = yield* sql`
+            SELECT state FROM flows_attempts
+            WHERE run_id = ${id.runId} AND step_key_digest = ${id.stepKeyDigest} AND attempt = ${id.attempt}
+          `;
+          return found.length === 0 ? { _tag: "NotFound" } : { _tag: "FenceLost" };
+        })
+      ).pipe(Effect.mapError(mapPersistenceError("patch")));
+    }).pipe((0, import_SpanOutcome.observeOutcome)())
+  );
+  return { put, get, heartbeat, finish, patch };
+});
+const make = Effect.orDie(makeWith());
+const makeNoop = (overrides = {}) => {
+  const unavailable = (method) => Effect.fail(attemptStoreError(method, "unknown", "the store is unavailable in this environment"));
+  return {
+    put: Effect.fn("AttemptStore.put")(() => unavailable("put")),
+    get: Effect.fn("AttemptStore.get")(() => unavailable("get")),
+    heartbeat: Effect.fn("AttemptStore.heartbeat")(() => unavailable("heartbeat")),
+    finish: Effect.fn("AttemptStore.finish")(() => unavailable("finish")),
+    patch: Effect.fn("AttemptStore.patch")(() => unavailable("patch")),
+    ...overrides
+  };
+};
+const layerNoop = (overrides = {}) => Layer.succeed(AttemptStore)(makeNoop(overrides));
+const layer = Layer.effect(AttemptStore)(
+  make
+);
+const layerWith = (options) => Layer.effect(AttemptStore)(makeWith(options));
+//# sourceMappingURL=AttemptStore.js.map