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

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

@@ -0,0 +1,53 @@
+/**
+ * The in-process attempt admission mutex.
+ *
+ * One instance lives per store incarnation (per `EngineStore.make`, alongside
+ * the owner nonce). Every durable action dispatch holds the key's permit
+ * for its whole admission-execute-finish span, so at most one fiber of this
+ * process can be driving a given `(runId, stepKeyDigest, attempt)` at a time.
+ *
+ * That exclusion is the liveness evidence adoption needs (issues #86, #102,
+ * #103): a persisted `running` row observed *while holding the key's permit*
+ * cannot belong to a live fiber of this process — a live same-key dispatch
+ * would be holding the permit — so it is crash or interruption evidence and
+ * safe to adopt, whether the admitting incarnation was another process
+ * (superseded by the run fence) or this very one (a dead fiber after an
+ * in-process re-drive). The recorded incarnation nonce alone could not make
+ * that distinction, which both let a TOCTOU window double-execute an
+ * irreversible body (issue #102) and permanently failed a same-incarnation
+ * re-drive with `AttemptAdmissionRejected` (issue #103).
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+/**
+ * The single operation the admission mutex exposes: run something while
+ * holding a key's exclusive permit.
+ *
+ * It is deliberately not a lock/unlock pair. Handing out a permit a caller
+ * must remember to return would make an interrupted dispatch leak exclusion
+ * for the rest of the process's life; a bracketing combinator cannot.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export interface Service {
+    /**
+     * Runs `effect` while holding this process's exclusive permit for `key`.
+     * Concurrent same-key callers wait; the permit is released on any exit,
+     * including interruption.
+     */
+    readonly withPermit: (key: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+/**
+ * Constructs the keyed admission mutex synchronously.
+ *
+ * Gates are reference-counted and removed once no fiber holds or awaits
+ * them, so the map does not grow with the number of distinct keys a
+ * long-lived process dispatches.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const makeUnsafe: () => Service;
+//# sourceMappingURL=AttemptAdmission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AttemptAdmission.d.ts","sourceRoot":"","sources":["../../../src/internal/AttemptAdmission.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC;;;;;;;;;;GAUG;AACH,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,CACnB,GAAG,EAAE,MAAM,KACR,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACzE;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,QAAO,OAc7B,CAAA"}

package/dist/cjs/internal/AttemptAdmission.js

@@ -0,0 +1,52 @@
+"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 AttemptAdmission_exports = {};
+__export(AttemptAdmission_exports, {
+  makeUnsafe: () => makeUnsafe
+});
+module.exports = __toCommonJS(AttemptAdmission_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var RcMap = __toESM(require("effect/RcMap"), 1);
+var Scope = __toESM(require("effect/Scope"), 1);
+var Semaphore = __toESM(require("effect/Semaphore"), 1);
+const makeUnsafe = () => {
+  const Locks = Context.Service("AttemptAdmission/Locks");
+  const layer = Layer.effect(Locks, RcMap.make({ lookup: (_key) => Semaphore.make(1) }));
+  const owners = Layer.makeMemoMapUnsafe();
+  return {
+    withPermit: (key) => (effect) => Effect.scoped(Effect.gen(function* () {
+      const services = yield* Layer.buildWithMemoMap(layer, owners, yield* Scope.Scope);
+      const lock = yield* RcMap.get(Context.get(services, Locks), key);
+      return yield* lock.withPermit(effect);
+    }))
+  };
+};
+//# sourceMappingURL=AttemptAdmission.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/AttemptAdmission.ts"],
+  "sourcesContent": ["/**\n * The in-process attempt admission mutex.\n *\n * One instance lives per store incarnation (per `EngineStore.make`, alongside\n * the owner nonce). Every durable action dispatch holds the key's permit\n * for its whole admission-execute-finish span, so at most one fiber of this\n * process can be driving a given `(runId, stepKeyDigest, attempt)` at a time.\n *\n * That exclusion is the liveness evidence adoption needs (issues #86, #102,\n * #103): a persisted `running` row observed *while holding the key's permit*\n * cannot belong to a live fiber of this process \u2014 a live same-key dispatch\n * would be holding the permit \u2014 so it is crash or interruption evidence and\n * safe to adopt, whether the admitting incarnation was another process\n * (superseded by the run fence) or this very one (a dead fiber after an\n * in-process re-drive). The recorded incarnation nonce alone could not make\n * that distinction, which both let a TOCTOU window double-execute an\n * irreversible body (issue #102) and permanently failed a same-incarnation\n * re-drive with `AttemptAdmissionRejected` (issue #103).\n *\n * @since 0.1.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as RcMap from \"effect/RcMap\"\nimport * as Scope from \"effect/Scope\"\nimport * as Semaphore from \"effect/Semaphore\"\n\n/**\n * The single operation the admission mutex exposes: run something while\n * holding a key's exclusive permit.\n *\n * It is deliberately not a lock/unlock pair. Handing out a permit a caller\n * must remember to return would make an interrupted dispatch leak exclusion\n * for the rest of the process's life; a bracketing combinator cannot.\n *\n * @since 0.1.0\n * @category services\n */\nexport interface Service {\n  /**\n   * Runs `effect` while holding this process's exclusive permit for `key`.\n   * Concurrent same-key callers wait; the permit is released on any exit,\n   * including interruption.\n   */\n  readonly withPermit: (\n    key: string\n  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>\n}\n\n/**\n * Constructs the keyed admission mutex synchronously.\n *\n * Gates are reference-counted and removed once no fiber holds or awaits\n * them, so the map does not grow with the number of distinct keys a\n * long-lived process dispatches.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const makeUnsafe = (): Service => {\n  // One layer identity per incarnation; each operation borrows its owner\n  // through a shared memo map, so the last operation releases the RcMap.\n  const Locks = Context.Service<RcMap.RcMap<string, Semaphore.Semaphore>>(\"AttemptAdmission/Locks\")\n  const layer = Layer.effect(Locks, RcMap.make({ lookup: (_key: string) => Semaphore.make(1) }))\n  const owners = Layer.makeMemoMapUnsafe()\n  return {\n    withPermit: (key) => (effect) =>\n      Effect.scoped(Effect.gen(function*() {\n        const services = yield* Layer.buildWithMemoMap(layer, owners, yield* Scope.Scope)\n        const lock = yield* RcMap.get(Context.get(services, Locks), key)\n        return yield* lock.withPermit(effect)\n      }))\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,cAAyB;AACzB,aAAwB;AACxB,YAAuB;AACvB,YAAuB;AACvB,YAAuB;AACvB,gBAA2B;AAkCpB,MAAM,aAAa,MAAe;AAGvC,QAAM,QAAQ,QAAQ,QAAkD,wBAAwB;AAChG,QAAM,QAAQ,MAAM,OAAO,OAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,SAAiB,UAAU,KAAK,CAAC,EAAE,CAAC,CAAC;AAC7F,QAAM,SAAS,MAAM,kBAAkB;AACvC,SAAO;AAAA,IACL,YAAY,CAAC,QAAQ,CAAC,WACpB,OAAO,OAAO,OAAO,IAAI,aAAY;AACnC,YAAM,WAAW,OAAO,MAAM,iBAAiB,OAAO,QAAQ,OAAO,MAAM,KAAK;AAChF,YAAM,OAAO,OAAO,MAAM,IAAI,QAAQ,IAAI,UAAU,KAAK,GAAG,GAAG;AAC/D,aAAO,OAAO,KAAK,WAAW,MAAM;AAAA,IACtC,CAAC,CAAC;AAAA,EACN;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,245 @@
+/**
+ * Complete attempt-history projection. The attempt store remains authoritative;
+ * only v2 histories contain enough evidence to rebuild this projection.
+ *
+ * @since 1.0.0
+ */
+import * as EngineEvent from "@smthrs/journal/EngineEvent";
+import type * as Projection from "@smthrs/journal/Projection";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/**
+ * An attempt state with completion data required only at completion.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const AttemptLifecycle: Schema.Union<readonly [Schema.Struct<{
+    readonly heartbeatAtMs: Schema.optionalKey<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+    readonly checkpoint: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly finishedAtMs: Schema.optionalKey<Schema.Never>;
+    readonly result: Schema.optionalKey<Schema.Never>;
+    readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+    readonly state: Schema.Literal<"running">;
+}>, Schema.Struct<{
+    readonly heartbeatAtMs: Schema.optionalKey<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+    readonly checkpoint: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly finishedAtMs: Schema.optionalKey<Schema.Never>;
+    readonly result: Schema.optionalKey<Schema.Never>;
+    readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+    readonly state: Schema.Literal<"suspended">;
+}>, Schema.Struct<{
+    readonly finishedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+    readonly result: Schema.TaggedStruct<"Success", {
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+    readonly state: Schema.Literal<"succeeded">;
+}>, Schema.Struct<{
+    readonly finishedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+    readonly result: Schema.TaggedStruct<"Failure", {
+        readonly reason: Schema.Literals<readonly ["error", "defect", "interrupted", "encoding"]>;
+        readonly detail: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+    readonly state: Schema.Literal<"failed">;
+}>]>;
+/**
+ * An attempt state with completion data required only at completion.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type AttemptLifecycle = EngineEvent.AttemptLifecycle;
+/**
+ * Validate untrusted encoded state without dropping contradictory fields.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const decode: (input: unknown) => Effect.Effect<{
+    readonly state: "running";
+    readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly result?: never;
+    readonly heartbeatAtMs?: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly checkpoint?: Schema.Json;
+    readonly finishedAtMs?: never;
+} | {
+    readonly state: "suspended";
+    readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly result?: never;
+    readonly heartbeatAtMs?: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly checkpoint?: Schema.Json;
+    readonly finishedAtMs?: never;
+} | {
+    readonly finishedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly result: {
+        readonly _tag: "Success";
+        readonly value: Schema.Json;
+    };
+    readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly state: "succeeded";
+} | {
+    readonly finishedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly result: {
+        readonly _tag: "Failure";
+        readonly reason: "error" | "encoding" | "defect" | "interrupted";
+        readonly detail: Schema.Json;
+    };
+    readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+    readonly state: "failed";
+}, EngineEvent.EventError, never>;
+/**
+ * The latest complete journal state for one attempt.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Row {
+    readonly executionId: string;
+    readonly stepKeyDigest: string;
+    readonly attempt: number;
+    readonly seq: number;
+    readonly lifecycle: AttemptLifecycle;
+}
+/**
+ * Attempt projection rows, independent of executable engine storage.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type State = ReadonlyArray<Row>;
+/**
+ * A versioned retained projection. Its sequence covers every included row.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Snapshot: Schema.Struct<{
+    readonly version: Schema.Literal<2>;
+    readonly lineage: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"root">;
+        readonly runId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+        readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/LineageId">;
+        readonly rootRunId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+        readonly round: Schema.Literal<0>;
+        readonly parentRunId: Schema.Null;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["child", "fork", "continuation"]>;
+        readonly runId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+        readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/LineageId">;
+        readonly rootRunId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+        readonly round: Schema.Int;
+        readonly parentRunId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+    }>]>;
+    readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly executionId: Schema.String;
+        readonly stepKeyDigest: Schema.String;
+        readonly attempt: Schema.Int;
+        readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+        readonly lifecycle: Schema.Union<readonly [Schema.Struct<{
+            readonly heartbeatAtMs: Schema.optionalKey<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly checkpoint: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly finishedAtMs: Schema.optionalKey<Schema.Never>;
+            readonly result: Schema.optionalKey<Schema.Never>;
+            readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly state: Schema.Literal<"running">;
+        }>, Schema.Struct<{
+            readonly heartbeatAtMs: Schema.optionalKey<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly checkpoint: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly finishedAtMs: Schema.optionalKey<Schema.Never>;
+            readonly result: Schema.optionalKey<Schema.Never>;
+            readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly state: Schema.Literal<"suspended">;
+        }>, Schema.Struct<{
+            readonly finishedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly result: Schema.TaggedStruct<"Success", {
+                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>;
+            readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly state: Schema.Literal<"succeeded">;
+        }>, Schema.Struct<{
+            readonly finishedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly result: Schema.TaggedStruct<"Failure", {
+                readonly reason: Schema.Literals<readonly ["error", "defect", "interrupted", "encoding"]>;
+                readonly detail: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>;
+            readonly startedAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly state: Schema.Literal<"failed">;
+        }>]>;
+    }>>;
+}>;
+/**
+ * Decode retained state and check all lineage coordinates before suffix replay.
+ * Source admission still applies independently to every suffix event.
+ *
+ * @category decoders
+ * @since 1.0.0
+ */
+export declare const restore: (input: unknown, consumer: EngineEvent.Consumer) => Effect.Effect<{
+    readonly version: 2;
+    readonly lineage: {
+        readonly kind: "root";
+        readonly runId: string & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/RunId">;
+        readonly lineageId: string & import("effect/Brand").Brand<"@smthrs/journal/LineageId">;
+        readonly rootRunId: string & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/RunId">;
+        readonly round: 0;
+        readonly parentRunId: null;
+    } | {
+        readonly kind: "child" | "fork" | "continuation";
+        readonly runId: string & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/RunId">;
+        readonly lineageId: string & import("effect/Brand").Brand<"@smthrs/journal/LineageId">;
+        readonly rootRunId: string & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/RunId">;
+        readonly round: number;
+        readonly parentRunId: string & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/RunId">;
+    };
+    readonly seq: number & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/Seq">;
+    readonly rows: readonly {
+        readonly executionId: string;
+        readonly stepKeyDigest: string;
+        readonly attempt: number;
+        readonly seq: number & import("effect/Brand").Brand<"@smthrs/journal/JournalEvent/Seq">;
+        readonly lifecycle: {
+            readonly state: "running";
+            readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly result?: never;
+            readonly heartbeatAtMs?: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly checkpoint?: Schema.Json;
+            readonly finishedAtMs?: never;
+        } | {
+            readonly state: "suspended";
+            readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly result?: never;
+            readonly heartbeatAtMs?: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly checkpoint?: Schema.Json;
+            readonly finishedAtMs?: never;
+        } | {
+            readonly finishedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly result: {
+                readonly _tag: "Success";
+                readonly value: Schema.Json;
+            };
+            readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly state: "succeeded";
+        } | {
+            readonly finishedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly result: {
+                readonly _tag: "Failure";
+                readonly reason: "error" | "encoding" | "defect" | "interrupted";
+                readonly detail: Schema.Json;
+            };
+            readonly startedAtMs: number & import("effect/Brand").Brand<"@smthrs/journal/TimestampMs">;
+            readonly state: "failed";
+        };
+    }[];
+}, EngineEvent.EventError, never>;
+/**
+ * Reduces full lifecycle records with monotonic sequence and legal state
+ * transitions. A missing start is incomplete history, never terminal success.
+ *
+ * @category projections
+ * @since 1.0.0
+ */
+export declare const projection: (consumer: EngineEvent.Consumer) => Projection.Projection<State, EngineEvent.EventError>;
+//# sourceMappingURL=AttemptLifecycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AttemptLifecycle.d.ts","sourceRoot":"","sources":["../../../src/internal/AttemptLifecycle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,WAAW,MAAM,6BAA6B,CAAA;AAE1D,OAAO,KAAK,KAAK,UAAU,MAAM,4BAA4B,CAAA;AAE7D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA+B,CAAA;AAC5D;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,gBAAgB,CAAA;AAC3D;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAWlC,CAAA;AAEH;;;;;GAKG;AACH,MAAM,WAAW,GAAG;IAClB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAA;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBpB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,EAAE,UAAU,WAAW,CAAC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAwBnE,CAAA;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,UAAU,WAAW,CAAC,QAAQ,KAAG,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,WAAW,CAAC,UAAU,CA4B7G,CAAA"}

package/dist/cjs/internal/AttemptLifecycle.js

@@ -0,0 +1,112 @@
+"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 AttemptLifecycle_exports = {};
+__export(AttemptLifecycle_exports, {
+  AttemptLifecycle: () => AttemptLifecycle,
+  Snapshot: () => Snapshot,
+  decode: () => decode,
+  projection: () => projection,
+  restore: () => restore
+});
+module.exports = __toCommonJS(AttemptLifecycle_exports);
+var EngineEvent = __toESM(require("@smthrs/journal/EngineEvent"), 1);
+var JournalEvent = __toESM(require("@smthrs/journal/JournalEvent"), 1);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const AttemptLifecycle = EngineEvent.AttemptLifecycle;
+const decode = (input) => Effect.suspend(() => Schema.decodeUnknownEffect(AttemptLifecycle, { onExcessProperty: "error" })(input)).pipe(
+  Effect.catchCause(
+    (cause) => Effect.fail(
+      new EngineEvent.EventError({
+        code: "malformed",
+        message: "invalid attempt lifecycle",
+        cause: Cause.squash(cause)
+      })
+    )
+  )
+);
+const Snapshot = Schema.Struct({
+  version: Schema.Literal(2),
+  lineage: EngineEvent.Lineage,
+  seq: JournalEvent.Seq,
+  rows: Schema.Array(Schema.Struct({
+    executionId: JournalEvent.Identifier,
+    stepKeyDigest: JournalEvent.Identifier,
+    attempt: JournalEvent.NonNegativeQuantity,
+    seq: JournalEvent.Seq,
+    lifecycle: AttemptLifecycle
+  }))
+}).check(
+  Schema.makeFilter(
+    (snapshot) => snapshot.rows.every((row) => row.seq <= snapshot.seq && row.executionId === snapshot.lineage.runId) && new Set(snapshot.rows.map((row) => JSON.stringify([row.executionId, row.stepKeyDigest, row.attempt]))).size === snapshot.rows.length
+  )
+);
+const restore = (input, consumer) => Effect.suspend(() => Schema.decodeUnknownEffect(Snapshot, { onExcessProperty: "error" })(input)).pipe(
+  Effect.flatMap((snapshot) => {
+    const lineage = snapshot.lineage;
+    return lineage.runId !== consumer.runId || lineage.lineageId !== consumer.lineageId || lineage.rootRunId !== consumer.rootRunId || lineage.round !== consumer.round || lineage.parentRunId !== consumer.parentRunId ? Effect.fail(
+      new EngineEvent.EventError({
+        code: "foreign",
+        message: "attempt snapshot is outside the consumer lineage",
+        cause: lineage
+      })
+    ) : Effect.succeed(snapshot);
+  }),
+  Effect.catchCause((failure) => {
+    const cause = Cause.squash(failure);
+    return Effect.fail(
+      cause instanceof EngineEvent.EventError ? cause : new EngineEvent.EventError({ code: "malformed", message: "invalid attempt snapshot", cause })
+    );
+  })
+);
+const projection = (consumer) => ({
+  name: "flows/engine/attempts/v2",
+  initial: [],
+  reduce: (state, entry) => Effect.gen(function* () {
+    const decoded = yield* EngineEvent.decodeEntry(entry, consumer);
+    if (decoded._tag !== "Attempt") return state;
+    const { attempt, executionId, lifecycle, stepKeyDigest } = decoded.payload;
+    const previous = state.find(
+      (row2) => row2.executionId === executionId && row2.stepKeyDigest === stepKeyDigest && row2.attempt === attempt
+    );
+    if (previous === void 0 ? lifecycle.state !== "running" : entry.seq <= previous.seq || previous.lifecycle.state === "succeeded" || previous.lifecycle.state === "failed" || lifecycle.startedAtMs !== previous.lifecycle.startedAtMs) {
+      return yield* Effect.fail(
+        new EngineEvent.EventError({
+          code: "transition",
+          message: "attempt history has a missing start, reordered record or transition after completion",
+          cause: { previous, entry }
+        })
+      );
+    }
+    const row = { executionId, stepKeyDigest, attempt, seq: entry.seq, lifecycle };
+    return [...state.filter((candidate) => candidate !== previous), row];
+  })
+});
+//# sourceMappingURL=AttemptLifecycle.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/AttemptLifecycle.ts"],
+  "sourcesContent": ["/**\n * Complete attempt-history projection. The attempt store remains authoritative;\n * only v2 histories contain enough evidence to rebuild this projection.\n *\n * @since 1.0.0\n */\n\nimport * as EngineEvent from \"@smthrs/journal/EngineEvent\"\nimport * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport type * as Projection from \"@smthrs/journal/Projection\"\nimport * as Cause from \"effect/Cause\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * An attempt state with completion data required only at completion.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const AttemptLifecycle = EngineEvent.AttemptLifecycle\n/**\n * An attempt state with completion data required only at completion.\n *\n * @category models\n * @since 1.0.0\n */\nexport type AttemptLifecycle = EngineEvent.AttemptLifecycle\n/**\n * Validate untrusted encoded state without dropping contradictory fields.\n *\n * @category decoders\n * @since 1.0.0\n */\nexport const decode = (input: unknown) =>\n  Effect.suspend(() => Schema.decodeUnknownEffect(AttemptLifecycle, { onExcessProperty: \"error\" })(input)).pipe(\n    Effect.catchCause((cause) =>\n      Effect.fail(\n        new EngineEvent.EventError({\n          code: \"malformed\",\n          message: \"invalid attempt lifecycle\",\n          cause: Cause.squash(cause)\n        })\n      )\n    )\n  )\n\n/**\n * The latest complete journal state for one attempt.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Row {\n  readonly executionId: string\n  readonly stepKeyDigest: string\n  readonly attempt: number\n  readonly seq: number\n  readonly lifecycle: AttemptLifecycle\n}\n\n/**\n * Attempt projection rows, independent of executable engine storage.\n *\n * @category models\n * @since 1.0.0\n */\nexport type State = ReadonlyArray<Row>\n\n/**\n * A versioned retained projection. Its sequence covers every included row.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Snapshot = Schema.Struct({\n  version: Schema.Literal(2),\n  lineage: EngineEvent.Lineage,\n  seq: JournalEvent.Seq,\n  rows: Schema.Array(Schema.Struct({\n    executionId: JournalEvent.Identifier,\n    stepKeyDigest: JournalEvent.Identifier,\n    attempt: JournalEvent.NonNegativeQuantity,\n    seq: JournalEvent.Seq,\n    lifecycle: AttemptLifecycle\n  }))\n}).check(\n  Schema.makeFilter((snapshot) =>\n    snapshot.rows.every((row) => row.seq <= snapshot.seq && row.executionId === snapshot.lineage.runId) &&\n    new Set(snapshot.rows.map((row) => JSON.stringify([row.executionId, row.stepKeyDigest, row.attempt]))).size ===\n      snapshot.rows.length\n  )\n)\n\n/**\n * Decode retained state and check all lineage coordinates before suffix replay.\n * Source admission still applies independently to every suffix event.\n *\n * @category decoders\n * @since 1.0.0\n */\nexport const restore = (input: unknown, consumer: EngineEvent.Consumer) =>\n  Effect.suspend(() => Schema.decodeUnknownEffect(Snapshot, { onExcessProperty: \"error\" })(input)).pipe(\n    Effect.flatMap((snapshot) => {\n      const lineage = snapshot.lineage\n      return lineage.runId !== consumer.runId || lineage.lineageId !== consumer.lineageId ||\n          lineage.rootRunId !== consumer.rootRunId || lineage.round !== consumer.round ||\n          lineage.parentRunId !== consumer.parentRunId\n        ? Effect.fail(\n          new EngineEvent.EventError({\n            code: \"foreign\",\n            message: \"attempt snapshot is outside the consumer lineage\",\n            cause: lineage\n          })\n        )\n        : Effect.succeed(snapshot)\n    }),\n    Effect.catchCause((failure) => {\n      const cause = Cause.squash(failure)\n      return Effect.fail(\n        cause instanceof EngineEvent.EventError ?\n          cause\n          : new EngineEvent.EventError({ code: \"malformed\", message: \"invalid attempt snapshot\", cause })\n      )\n    })\n  )\n\n/**\n * Reduces full lifecycle records with monotonic sequence and legal state\n * transitions. A missing start is incomplete history, never terminal success.\n *\n * @category projections\n * @since 1.0.0\n */\nexport const projection = (consumer: EngineEvent.Consumer): Projection.Projection<State, EngineEvent.EventError> => ({\n  name: \"flows/engine/attempts/v2\",\n  initial: [],\n  reduce: (state, entry) =>\n    Effect.gen(function*() {\n      const decoded = yield* EngineEvent.decodeEntry(entry, consumer)\n      if (decoded._tag !== \"Attempt\") return state\n      const { attempt, executionId, lifecycle, stepKeyDigest } = decoded.payload\n      const previous = state.find((row) =>\n        row.executionId === executionId && row.stepKeyDigest === stepKeyDigest && row.attempt === attempt\n      )\n      if (\n        previous === undefined\n          ? lifecycle.state !== \"running\"\n          : entry.seq <= previous.seq || previous.lifecycle.state === \"succeeded\" ||\n            previous.lifecycle.state === \"failed\" || lifecycle.startedAtMs !== previous.lifecycle.startedAtMs\n      ) {\n        return yield* Effect.fail(\n          new EngineEvent.EventError({\n            code: \"transition\",\n            message: \"attempt history has a missing start, reordered record or transition after completion\",\n            cause: { previous, entry }\n          })\n        )\n      }\n      const row: Row = { executionId, stepKeyDigest, attempt, seq: entry.seq, lifecycle }\n      return [...state.filter((candidate) => candidate !== previous), row]\n    })\n})\n"],
+  "mappings": "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",
+  "names": ["row"]
+}

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

@@ -0,0 +1,53 @@
+/**
+ * Survivor discovery for an action key's attempt rows.
+ *
+ * Two implementations answer the same question — the durable state's single
+ * ordered range read (issue #77) and the point-probe walk against
+ * `AttemptStore` for storage that cannot range-scan. They are kept here
+ * together, behind one entry point, because their answers must agree: a run
+ * that resumes under SQL state and under the fallback must restore the same
+ * retry origin and the same attempt counter (issue #96).
+ *
+ * @since 0.1.0
+ */
+import type { AttemptStore } from "@smthrs/run-store";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type * as DurableEngineState from "../DurableEngineState.ts";
+/**
+ * How long a pruned leading run of attempt numbers the survivor scan
+ * tolerates before it reports "no attempt row survives".
+ *
+ * A retention/prune job removes attempts oldest-first, so a surviving
+ * sequence is contiguous once its first row is found; the bound caps the
+ * pruned prefix walk (issue #69). It is a *semantic* bound, not merely a
+ * cost bound: the point-probe fallback cannot distinguish "nothing ever ran"
+ * from "the first 33 attempts were pruned" without a range read, so both
+ * paths apply the same tolerance and a key whose earliest survivor sits past
+ * it restarts its expiration budget and attempt numbering on either backend
+ * (issue #96). Restarting is safe — the pruned numbers are gone, so the
+ * fresh counter cannot collide — and, unlike the previous split, it is the
+ * same behaviour on every backend.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const prunedPrefixScanLimit = 32;
+/**
+ * Finds the surviving attempt rows for an action key: the earliest row's
+ * start time — the durable retry origin when attempt 1 itself was pruned
+ * (issue #69) — and the highest attempt number contiguous from it, from
+ * which the engine resumes the attempt counter (issue #59). `Option.none()`
+ * means no attempt row survives within `prunedPrefixScanLimit`.
+ *
+ * When the durable state can range-scan attempts, one ordered SELECT answers
+ * both questions (issue #77); otherwise the point-read scan against
+ * `AttemptStore` answers them, paying up to `prunedPrefixScanLimit`
+ * sequential gets for a key that never ran. Both answers pass through the
+ * same tolerance check, so the two paths cannot diverge (issue #96).
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const probeAttempts: (attemptStore: AttemptStore.Service, survivors: DurableEngineState.Service["attemptSurvivors"], runId: string, stepKeyDigest: string) => Effect.Effect<Option.Option<DurableEngineState.AttemptSurvivors>>;
+//# sourceMappingURL=AttemptProbe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AttemptProbe.d.ts","sourceRoot":"","sources":["../../../src/internal/AttemptProbe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,kBAAkB,MAAM,0BAA0B,CAAA;AAEnE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAA;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,GACxB,cAAc,YAAY,CAAC,OAAO,EAClC,WAAW,kBAAkB,CAAC,OAAO,CAAC,kBAAkB,CAAC,EACzD,OAAO,MAAM,EACb,eAAe,MAAM,KACpB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,CA8B/D,CAAA"}

package/dist/cjs/internal/AttemptProbe.js

@@ -0,0 +1,66 @@
+"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 AttemptProbe_exports = {};
+__export(AttemptProbe_exports, {
+  probeAttempts: () => probeAttempts,
+  prunedPrefixScanLimit: () => prunedPrefixScanLimit
+});
+module.exports = __toCommonJS(AttemptProbe_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+const prunedPrefixScanLimit = 32;
+const probeAttempts = (attemptStore, survivors, runId, stepKeyDigest) => Effect.gen(function* () {
+  if (survivors !== void 0) {
+    const found = yield* survivors(runId, stepKeyDigest);
+    if (Option.isNone(found)) return Option.none();
+    return found.value.earliestAttempt > prunedPrefixScanLimit ? Option.none() : found;
+  }
+  let earliest = Option.none();
+  let attempt = 1;
+  for (; attempt <= prunedPrefixScanLimit; attempt++) {
+    const row = yield* attemptStore.get({ runId, stepKeyDigest, attempt }).pipe(Effect.orDie);
+    if (Option.isSome(row)) {
+      earliest = row;
+      break;
+    }
+  }
+  if (Option.isNone(earliest)) return Option.none();
+  let latest = attempt;
+  for (let next = attempt + 1; ; next++) {
+    const row = yield* attemptStore.get({ runId, stepKeyDigest, attempt: next }).pipe(Effect.orDie);
+    if (Option.isNone(row)) break;
+    latest = next;
+  }
+  return Option.some({
+    earliestAttempt: attempt,
+    earliestStartedAtMs: earliest.value.startedAtMs,
+    latest
+  });
+});
+//# sourceMappingURL=AttemptProbe.js.map