@smthrs/flow 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/Poll.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Poll.ts"],
+  "sourcesContent": ["/**\n * Polling as a durable lineage: one attempt per round, a durable wait between\n * attempts, and a bound the lineage settles on.\n *\n * Smithers 0.x had a `Poller` component \u2014 a check, an interval, a backoff, an\n * attempt bound, and what to do at that bound. The pieces it was built from\n * already exist here: {@link module:Sleep.action} is the durable wait, and\n * `Flow.to` opens the next round. What was missing is the shape that puts them\n * together, and that is this module.\n *\n * A poll is a flow whose body is ONE attempt. It runs the check, and branches:\n * a satisfied check settles the lineage with the check's own output, an\n * unsatisfied one sleeps for this attempt's delay and hands off to the next\n * round with the attempt counter raised. The last attempt has no sleep and no\n * handoff \u2014 it either answers with the output it just read (`return-last`) or\n * fails {@link PollExhausted} (`fail`).\n *\n * Everything durable about it is durable for the ordinary reason. Each attempt\n * is a round with its own keyed plan nodes, so a check that already ran replays\n * from its recorded outcome instead of running again; the wait between attempts\n * is a durable timer, so a process that dies during it resumes on the round it\n * left rather than starting the poll over; and the attempt counter travels in\n * the payload, so nothing about \"which attempt is this\" lives in memory.\n *\n * The bound is stated twice on purpose. The body ends the lineage on the last\n * attempt, and `maxAttempts` is also the flow's `maxRounds` budget, so a\n * lineage that somehow opened another round is refused by the engine rather\n * than polling forever.\n *\n * @since 0.1.0\n */\n\nimport * as Node from \"@smthrs/plan/Node\"\nimport type * as Repetition from \"@smthrs/plan/Repetition\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\nimport * as Action from \"./Action/index.ts\"\nimport * as Flow from \"./Flow/index.ts\"\nimport type { FlowRuntime } from \"./FlowRuntime/FlowRuntime.ts\"\nimport * as Sleep from \"./Sleep.ts\"\n\n/**\n * How the wait between attempts grows.\n *\n * `fixed` waits the interval every time, `linear` waits the interval times the\n * attempt, and `exponential` doubles the interval on every attempt.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Backoff = \"fixed\" | \"linear\" | \"exponential\"\n\n/**\n * What a check reports: whether the poll is over, and the value this attempt\n * read.\n *\n * The output travels on every attempt, satisfied or not, because it is also\n * the answer a `return-last` poll settles with when it runs out of attempts.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Check<out Result> {\n  readonly satisfied: boolean\n  readonly output: Result\n}\n\n/**\n * The success schema a check action declares.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CheckResult = <Result extends Schema.Top>(\n  result: Result\n): Schema.Struct<{\n  readonly satisfied: typeof Schema.Boolean\n  readonly output: Result\n}> => Schema.Struct({ satisfied: Schema.Boolean, output: result })\n\n/**\n * A poll that used its last attempt without a satisfied check.\n *\n * It is a typed failure rather than a defect: running out of attempts is an\n * expected outcome of polling something that may never become ready, so a\n * caller recovers from it through `Node.catch` like any other declared failure.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class PollExhausted extends Schema.TaggedError<PollExhausted>()(\n  \"@smthrs/flow/PollExhausted\",\n  {\n    // This wire shape freezes at 1.0.0-rc.0.\n    code: Schema.Literal(\"poll_exhausted\").pipe(\n      Schema.withConstructorDefault(Effect.succeed(\"poll_exhausted\"))\n    ),\n    poll: Schema.String,\n    attempts: Schema.Number,\n    message: Schema.String\n  }\n) {}\n\n/**\n * The tag the exhaustion step is catalogued and resolved under.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const exhaustedTag = \"system/poll-exhausted\"\n\n/**\n * The declared step a poll takes when its last attempt was not satisfied.\n *\n * Running out of attempts is a step rather than a bare `Effect.fail` so the\n * exhaustion is in the plan and in the journal: the round that gave up shows\n * which poll gave up and after how many attempts, exactly like every other node\n * a body drove.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const exhausted: Action.Declared<\n  typeof exhaustedTag,\n  Schema.Struct<{\n    readonly poll: typeof Schema.String\n    readonly attempts: typeof Schema.Number\n  }>,\n  typeof Schema.Never,\n  typeof PollExhausted,\n  never\n> = Action.makeSystem(exhaustedTag, {\n  payload: { poll: Schema.String, attempts: Schema.Number },\n  success: Schema.Never,\n  error: PollExhausted,\n  tier: \"sealed\"\n})\n\n/**\n * The wait before the attempt after this one, in milliseconds.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const delayMillis = (options: {\n  readonly intervalMs: number\n  readonly backoff: Backoff\n  readonly attempt: number\n}): number =>\n  options.intervalMs *\n  (options.backoff === \"fixed\" ? 1 : options.backoff === \"linear\" ? options.attempt : 2 ** (options.attempt - 1))\n\n/**\n * What a poll round can fail with.\n *\n * {@link PollExhausted} is the poll's own failure. `SleepRequestInvalid` is the\n * wait node's, declared because the wait between attempts is an ordinary\n * {@link module:Sleep.action} node and its typed refusal is part of the\n * topology a poll carries. Its codes cover a payload that names no deadline,\n * names two deadlines, or names a value that is not a deadline. {@link make}\n * refuses invalid author schedules at construction. A caller-visible round\n * payload can still carry an invalid attempt that produces an invalid derived\n * wait, so `Sleep` refuses that wait before the round parks.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Failure: Schema.Union<\n  readonly [typeof PollExhausted, typeof Sleep.SleepRequestInvalid]\n> = Schema.Union([PollExhausted, Sleep.SleepRequestInvalid])\n\n/**\n * The payload schema {@link make} derives from an author's input fields: the\n * author's own fields, plus the attempt this round is.\n *\n * `attempt` is optional so a caller starts a poll with its own fields alone;\n * the first round reads it as one.\n *\n * @category models\n * @since 0.1.0\n */\nexport type PayloadSchema<Input extends Schema.Struct.Fields> = Schema.Struct<\n  Input & { readonly attempt: Schema.optional<typeof Schema.Number> }\n>\n\n/**\n * The payload schema one round is opened with: the author's fields, plus the\n * attempt counter the lineage carries between them.\n *\n * @private\n */\nconst payloadSchema = <Input extends Schema.Struct.Fields>(\n  input: Input,\n  maxAttempts: number\n): PayloadSchema<Input> =>\n  Schema.Struct({\n    ...input,\n    attempt: Schema.optional(\n      Schema.Int.check(\n        Schema.isGreaterThanOrEqualTo(1),\n        Schema.isLessThanOrEqualTo(maxAttempts)\n      )\n    )\n  })\n\n/**\n * The attempt a round payload carries, defaulting to the first.\n *\n * @private\n */\nconst attemptOf = (payload: object): number => {\n  const attempt = (payload as { readonly attempt?: unknown }).attempt\n  return typeof attempt === \"number\" ? attempt : 1\n}\n\n/**\n * Rebuilds a round payload with an explicit attempt.\n *\n * The two views of one round payload \u2014 what the check reads, and what the next\n * round is opened with \u2014 are the same fields with `attempt` resolved. TypeScript\n * cannot reduce a mapped type over an unresolved generic field set, so the\n * shape is stated once here instead of at each use.\n *\n * @private\n */\nconst withAttempt = <Payload>(payload: object, attempt: number): Payload =>\n  ({ ...payload, attempt }) as unknown as Payload\n\n/**\n * Declares a durable poller.\n *\n * **When to use**\n *\n * Use it wherever a run has to keep asking until something is ready \u2014 a build\n * that finishes, a deployment that goes live, a review that lands \u2014 and the\n * waiting has to survive a restart. `check` is the one thing an author writes:\n * a body fragment that reads whatever it polls and reports a {@link Check}.\n * Everything else is schedule. Under stable callback admission (the default of\n * `Interpreter.layerWithImplementations`), wrap `check` in `Node.capture` with\n * every semantic capture, including a version for imported behavior. An\n * uncaptured check keeps the poll process-local. The helper captures its own\n * callbacks using the schedule and the check's identity.\n *\n * ```ts\n * const Deployment = Poll.make(\"deploy/wait\", {\n *   input: { id: Schema.String },\n *   result: Schema.String,\n *   intervalMs: 5_000,\n *   backoff: \"exponential\",\n *   maxAttempts: 8,\n *   onTimeout: \"fail\",\n *   check: Node.capture(\n *     { action: Status.name, implementationVersion: \"deploy/status-check/v1\" },\n *     ({ attempt, id }) => Status.call({ attempt, id })\n *   )\n * })\n * ```\n *\n * The check may not fail. A check that can fail states what a failure means for\n * the poll \u2014 give up, or treat it as \"not ready yet\" \u2014 with `Node.catch` inside\n * the fragment, rather than leaving the poll to guess.\n *\n * A per-attempt time limit on the check itself is NOT a poll option. A plan\n * node's duration is not something the body around it can bound; that bound\n * belongs in the check's own implementation, where `DurableDeferred.raceAll`\n * races the work against a durable clock and stays replayable.\n *\n * A schedule no clock can be armed with is refused here, with a `RangeError`\n * naming the option that is wrong. `intervalMs` becomes the `millis` of a\n * {@link module:Sleep.action} node, and a wait of `Infinity`, `NaN`, or a\n * negative length arms a timer that never fires \u2014 a poll that hangs forever\n * with a plan that looks correct. The check is on the schedule, not only on the\n * interval: `{ intervalMs: 1000, maxAttempts: 2000, backoff: \"exponential\" }`\n * states three finite options and asks for an infinite wait, so the LAST wait\n * the poll can arm has to be a length too. `maxAttempts` is the lineage's round\n * budget, and a budget below one attempt reaches `Flow.make` as a `maxRounds`\n * complaint about an option the author never wrote.\n *\n * @throws A `RangeError` when `intervalMs` is not a duration a clock accepts,\n * when `maxAttempts` is not a whole number of attempts of at least one, or when\n * the interval under the declared backoff reaches a wait no clock can be armed\n * with before the budget is spent.\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <\n  const Tag extends string,\n  Input extends Schema.Struct.Fields,\n  Result extends Schema.Top,\n  R = never\n>(\n  tag: Tag,\n  options: {\n    readonly input: Input\n    readonly result: Result\n    readonly check: (\n      payload: Schema.Struct.Type<Input> & { readonly attempt: number }\n    ) => Node.Node<Check<Result[\"Type\"]>, never, R>\n    readonly intervalMs: number\n    readonly maxAttempts: number\n    readonly backoff?: Backoff | undefined\n    readonly onTimeout?: Repetition.AtCeiling | undefined\n  }\n): Flow.Flow<Tag, PayloadSchema<Input>, Result, typeof Failure, R> => {\n  type Round = Flow.Flow<Tag, PayloadSchema<Input>, Result, typeof Failure, R>\n  type RoundPayload = PayloadSchema<Input>[\"Type\"]\n  if (Object.prototype.hasOwnProperty.call(options.input, \"attempt\")) {\n    throw new TypeError(\n      `Poll.make: \"${tag}\" input cannot declare the reserved \"attempt\" field. ` +\n        \"Poll owns that counter across durable rounds.\"\n    )\n  }\n  const input = Object.freeze({ ...options.input }) as Input\n  const result = options.result\n  const check = options.check\n  const intervalMs = options.intervalMs\n  const maxAttempts = options.maxAttempts\n  if (!Number.isFinite(intervalMs) || intervalMs < 0) {\n    throw new RangeError(\n      `Poll.make: \"${tag}\" intervalMs must be a finite number of milliseconds that is not negative, ` +\n        `and was ${intervalMs}. The interval is the length of a durable wait, and a wait of ` +\n        \"that length never ends.\"\n    )\n  }\n  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {\n    throw new RangeError(\n      `Poll.make: \"${tag}\" maxAttempts must be a whole number of attempts of at least one, and was ` +\n        `${maxAttempts}. A poll checks at least once.`\n    )\n  }\n  const backoff = options.backoff ?? \"fixed\"\n  // The wait a poll arms is not `intervalMs`. {@link delayMillis} multiplies it\n  // by the backoff, so a schedule whose options are each finite can still ask\n  // for a wait that is not a length \u2014 and that wait arms the same timer that\n  // never fires the interval guard above exists to refuse. The last wait is the\n  // one before the final attempt, because the attempt at the budget gives up\n  // rather than sleeps, and the schedule never shrinks, so the last wait is\n  // also the longest: checking it checks all of them.\n  const longestWaitMs = maxAttempts > 1\n    ? delayMillis({ intervalMs, backoff, attempt: maxAttempts - 1 })\n    : 0\n  if (!Number.isFinite(longestWaitMs)) {\n    throw new RangeError(\n      `Poll.make: \"${tag}\" asks for a wait of ${longestWaitMs} ms before its last attempt. An ` +\n        `intervalMs of ${intervalMs} under the \"${backoff}\" backoff reaches a length no clock ` +\n        `can be armed with by attempt ${maxAttempts - 1} of ${maxAttempts}. Lower ` +\n        \"maxAttempts, shorten the interval, or slow the backoff.\"\n    )\n  }\n  const onTimeout = options.onTimeout ?? \"fail\"\n  const captures = { tag, intervalMs, backoff, maxAttempts, onTimeout, check: Node.functionIdentity(check) }\n  const body = (\n    payload: RoundPayload\n  ): Node.Node<Flow.BodySuccess<Result[\"Type\"]>, typeof Failure.Type, R> => {\n    const attempt = attemptOf(payload)\n    const last = attempt >= maxAttempts\n    return check(withAttempt(payload, attempt)).pipe(\n      Node.branch({\n        if: Node.capture(captures, (checked) => checked.satisfied),\n        then: (checked) => Flow.done(checked.output),\n        else: (checked): Node.Node<Flow.BodySuccess<Result[\"Type\"]>, typeof Failure.Type> =>\n          last\n            ? onTimeout === \"return-last\"\n              ? Flow.done(checked.output)\n              : exhausted.call({ poll: tag, attempts: attempt })\n            : Sleep.action.call({\n              millis: delayMillis({ intervalMs, backoff, attempt })\n            }).pipe(\n              Node.andThen(\n                self.to(withAttempt<Parameters<Round[\"to\"]>[0]>(payload, attempt + 1))\n              )\n            )\n      })\n    )\n  }\n  // The body names the flow it is the body of, which is what makes one round\n  // open the next. It is read when a round is planned, long after `Flow.make`\n  // has returned, so the binding is initialized by then.\n  const self: Round = Flow.make(tag, {\n    payload: payloadSchema(input, maxAttempts),\n    success: result,\n    error: Failure,\n    maxRounds: maxAttempts,\n    // A captured wrapper must not admit a process-local check as stable.\n    body: captures.check.algorithm === \"sha256-source-ephemeral/v4\" ? body : Node.capture(captures, body)\n  })\n  return self\n}\n\n/**\n * The exhaustion implementation, provided beside the other action layers a\n * poll's rounds call.\n *\n * ```ts\n * Layer.mergeAll(Poll.layer, Sleep.layer, Interpreter.layer(Deployment)).pipe(\n *   Layer.provideMerge(Action.layerImplementations)\n * )\n * ```\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime> = exhausted.toLayer(\n  ({ attempts, poll }) =>\n    Effect.fail(\n      new PollExhausted({\n        poll,\n        attempts,\n        message: `Poll \"${poll}\" used all ${attempts} attempts without a satisfied check.`\n      })\n    )\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,WAAsB;AAGtB,aAAwB;AAExB,aAAwB;AACxB,aAAwB;AACxB,WAAsB;AAEtB,YAAuB;AAkChB,MAAM,cAAc,CACzB,WAII,OAAO,OAAO,EAAE,WAAW,OAAO,SAAS,QAAQ,OAAO,CAAC;AAY1D,MAAM,sBAAsB,OAAO,YAA2B;AAAA,EACnE;AAAA,EACA;AAAA;AAAA,IAEE,MAAM,OAAO,QAAQ,gBAAgB,EAAE;AAAA,MACrC,OAAO,uBAAuB,OAAO,QAAQ,gBAAgB,CAAC;AAAA,IAChE;AAAA,IACA,MAAM,OAAO;AAAA,IACb,UAAU,OAAO;AAAA,IACjB,SAAS,OAAO;AAAA,EAClB;AACF,EAAE;AAAC;AAQI,MAAM,eAAe;AAarB,MAAM,YAST,OAAO,WAAW,cAAc;AAAA,EAClC,SAAS,EAAE,MAAM,OAAO,QAAQ,UAAU,OAAO,OAAO;AAAA,EACxD,SAAS,OAAO;AAAA,EAChB,OAAO;AAAA,EACP,MAAM;AACR,CAAC;AAQM,MAAM,cAAc,CAAC,YAK1B,QAAQ,cACP,QAAQ,YAAY,UAAU,IAAI,QAAQ,YAAY,WAAW,QAAQ,UAAU,MAAM,QAAQ,UAAU;AAiBvG,MAAM,UAET,OAAO,MAAM,CAAC,eAAe,MAAM,mBAAmB,CAAC;AAsB3D,MAAM,gBAAgB,CACpB,OACA,gBAEA,OAAO,OAAO;AAAA,EACZ,GAAG;AAAA,EACH,SAAS,OAAO;AAAA,IACd,OAAO,IAAI;AAAA,MACT,OAAO,uBAAuB,CAAC;AAAA,MAC/B,OAAO,oBAAoB,WAAW;AAAA,IACxC;AAAA,EACF;AACF,CAAC;AAOH,MAAM,YAAY,CAAC,YAA4B;AAC7C,QAAM,UAAW,QAA2C;AAC5D,SAAO,OAAO,YAAY,WAAW,UAAU;AACjD;AAYA,MAAM,cAAc,CAAU,SAAiB,aAC5C,EAAE,GAAG,SAAS,QAAQ;AA2DlB,MAAM,OAAO,CAMlB,KACA,YAWoE;AAGpE,MAAI,OAAO,UAAU,eAAe,KAAK,QAAQ,OAAO,SAAS,GAAG;AAClE,UAAM,IAAI;AAAA,MACR,eAAe,GAAG;AAAA,IAEpB;AAAA,EACF;AACA,QAAM,QAAQ,OAAO,OAAO,EAAE,GAAG,QAAQ,MAAM,CAAC;AAChD,QAAM,SAAS,QAAQ;AACvB,QAAM,QAAQ,QAAQ;AACtB,QAAM,aAAa,QAAQ;AAC3B,QAAM,cAAc,QAAQ;AAC5B,MAAI,CAAC,OAAO,SAAS,UAAU,KAAK,aAAa,GAAG;AAClD,UAAM,IAAI;AAAA,MACR,eAAe,GAAG,sFACL,UAAU;AAAA,IAEzB;AAAA,EACF;AACA,MAAI,CAAC,OAAO,cAAc,WAAW,KAAK,cAAc,GAAG;AACzD,UAAM,IAAI;AAAA,MACR,eAAe,GAAG,6EACb,WAAW;AAAA,IAClB;AAAA,EACF;AACA,QAAM,UAAU,QAAQ,WAAW;AAQnC,QAAM,gBAAgB,cAAc,IAChC,YAAY,EAAE,YAAY,SAAS,SAAS,cAAc,EAAE,CAAC,IAC7D;AACJ,MAAI,CAAC,OAAO,SAAS,aAAa,GAAG;AACnC,UAAM,IAAI;AAAA,MACR,eAAe,GAAG,wBAAwB,aAAa,iDACpC,UAAU,eAAe,OAAO,oEACjB,cAAc,CAAC,OAAO,WAAW;AAAA,IAErE;AAAA,EACF;AACA,QAAM,YAAY,QAAQ,aAAa;AACvC,QAAM,WAAW,EAAE,KAAK,YAAY,SAAS,aAAa,WAAW,OAAO,KAAK,iBAAiB,KAAK,EAAE;AACzG,QAAM,OAAO,CACX,YACwE;AACxE,UAAM,UAAU,UAAU,OAAO;AACjC,UAAM,OAAO,WAAW;AACxB,WAAO,MAAM,YAAY,SAAS,OAAO,CAAC,EAAE;AAAA,MAC1C,KAAK,OAAO;AAAA,QACV,IAAI,KAAK,QAAQ,UAAU,CAAC,YAAY,QAAQ,SAAS;AAAA,QACzD,MAAM,CAAC,YAAY,KAAK,KAAK,QAAQ,MAAM;AAAA,QAC3C,MAAM,CAAC,YACL,OACI,cAAc,gBACZ,KAAK,KAAK,QAAQ,MAAM,IACxB,UAAU,KAAK,EAAE,MAAM,KAAK,UAAU,QAAQ,CAAC,IACjD,MAAM,OAAO,KAAK;AAAA,UAClB,QAAQ,YAAY,EAAE,YAAY,SAAS,QAAQ,CAAC;AAAA,QACtD,CAAC,EAAE;AAAA,UACD,KAAK;AAAA,YACH,KAAK,GAAG,YAAwC,SAAS,UAAU,CAAC,CAAC;AAAA,UACvE;AAAA,QACF;AAAA,MACN,CAAC;AAAA,IACH;AAAA,EACF;AAIA,QAAM,OAAc,KAAK,KAAK,KAAK;AAAA,IACjC,SAAS,cAAc,OAAO,WAAW;AAAA,IACzC,SAAS;AAAA,IACT,OAAO;AAAA,IACP,WAAW;AAAA;AAAA,IAEX,MAAM,SAAS,MAAM,cAAc,+BAA+B,OAAO,KAAK,QAAQ,UAAU,IAAI;AAAA,EACtG,CAAC;AACD,SAAO;AACT;AAeO,MAAM,QAAgE,UAAU;AAAA,EACrF,CAAC,EAAE,UAAU,KAAK,MAChB,OAAO;AAAA,IACL,IAAI,cAAc;AAAA,MAChB;AAAA,MACA;AAAA,MACA,SAAS,SAAS,IAAI,cAAc,QAAQ;AAAA,IAC9C,CAAC;AAAA,EACH;AACJ;",
+  "names": []
+}

package/dist/cjs/RetryPolicy.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Defines data-shaped retry policies for durable action retries.
+ *
+ * A `RetryPolicy` is a plain value — initial interval, backoff factor, cap,
+ * optional maximum attempts, optional jitter, and optional non-retryable
+ * error tags — so the next retry delay can be derived from a persisted
+ * attempt count instead of fiber-local `Schedule` state. `nextDelay` mirrors
+ * Temporal's `ExponentialRetryPolicy.ComputeNextDelay` formula, and `decide`
+ * is the engine's single retry decision point: the core default a pluggable
+ * `resolveRetry` resolution can later dispatch in front of.
+ *
+ * The historical terminal-failure schemas below use the `@smthrs/flow/` tags settled for
+ * 1.0.0-rc.0. The release candidate makes no compatibility promise to 0.x
+ * journals, and these tags freeze at the RC. Current action dispatch preserves
+ * the final declared failure when a retry policy is spent.
+ *
+ * See `docs/guides/retry-a-failing-action.md`; its "Infrastructure
+ * interrupts" section covers the interrupt retry schedule.
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+/**
+ * Data-shaped retry policy schema. Decoding enforces the same relational
+ * contract as {@link make}; persisted data cannot bypass constructor checks.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const RetryPolicy: Schema.Struct<{
+    readonly initialMs: Schema.Number;
+    readonly factor: Schema.Number;
+    readonly maxMs: Schema.Number;
+    readonly maxAttempts: Schema.optional<Schema.Number>;
+    readonly expirationMs: Schema.optional<Schema.Number>;
+    readonly jitterRatio: Schema.optional<Schema.Number>;
+    readonly nonRetryable: Schema.optional<Schema.$Array<Schema.String>>;
+}>;
+/**
+ * The value form of a {@link RetryPolicy}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RetryPolicy = typeof RetryPolicy.Type;
+/**
+ * Creates a `RetryPolicy` value after checking every numeric bound.
+ * `initialMs` must be greater than zero: a zero initial interval would
+ * compute a zero delay for every attempt, which {@link nextDelay} reads as
+ * exhausted, so the policy would never retry. `jitterRatio` must be between
+ * zero and one, inclusive, and `jitterRatio: 0` disables jitter.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: (options: {
+    readonly initialMs: number;
+    readonly factor: number;
+    readonly maxMs: number;
+    readonly maxAttempts?: number | undefined;
+    readonly expirationMs?: number | undefined;
+    readonly jitterRatio?: number | undefined;
+    readonly nonRetryable?: ReadonlyArray<string> | undefined;
+}) => RetryPolicy;
+/**
+ * The default engine retry policy.
+ *
+ * Uses a 200ms initial delay growing by 1.5x, capped at 30s, and never gives
+ * up: it declares neither `maxAttempts` nor `expirationMs`. Bound long-lived
+ * retries with `make({ ..., expirationMs })` when a wall-clock give-up is
+ * required.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const defaultRetryPolicy: RetryPolicy;
+/**
+ * Bounded infrastructure retry: 5 seconds doubling to 5 minutes, for 2 hours.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const transient: RetryPolicy;
+/**
+ * A retry decision: wait `delayMs` before the next attempt.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface RetryAfter {
+    readonly _tag: "RetryAfter";
+    readonly delayMs: number;
+}
+/**
+ * A retry decision: stop retrying.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface GiveUp {
+    readonly _tag: "GiveUp";
+    readonly reason: "nonRetryable" | "exhausted" | "expired";
+}
+/**
+ * The outcome of the engine's retry decision point.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RetryDecision = RetryAfter | GiveUp;
+/**
+ * Creates a `RetryAfter` decision.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const retryAfter: (delayMs: number) => RetryDecision;
+/**
+ * Creates a `GiveUp` decision.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const giveUp: (reason: GiveUp["reason"]) => RetryDecision;
+declare const RetryPolicyExpired_base: Schema.Class<RetryPolicyExpired, Schema.TaggedStruct<"@smthrs/flow/RetryPolicyExpired", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"retry_policy_expired">>;
+    readonly actionName: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly expirationMs: Schema.Number;
+    readonly lastError: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A historical retry sequence crossed its `expirationMs` wall-clock bound.
+ * Current dispatch preserves the final declared failure instead of emitting this defect.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class RetryPolicyExpired extends RetryPolicyExpired_base {
+}
+declare const RetryAttemptsExhausted_base: Schema.Class<RetryAttemptsExhausted, Schema.TaggedStruct<"@smthrs/flow/RetryAttemptsExhausted", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"retry_attempts_exhausted">>;
+    readonly actionName: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly maxAttempts: Schema.Number;
+    readonly lastError: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A historical retry sequence exhausted its `maxAttempts` bound.
+ * Current dispatch preserves the final declared failure instead of emitting this defect.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class RetryAttemptsExhausted extends RetryAttemptsExhausted_base {
+}
+/**
+ * Computes the delay before attempt `attempt + 1` from the persisted attempt
+ * count, mirroring Temporal's `ComputeNextDelay`
+ * (`common/backoff/retrypolicy.go`).
+ *
+ * `attempt` is the 1-based attempt that just failed. Returns `None` when the
+ * policy gives up: `maxAttempts` reached, a non-positive computed interval,
+ * a cap below the initial interval, or — when the policy declares
+ * `expirationMs` and the caller supplies `elapsedMs` — an elapsed duration
+ * past the expiration bound. Otherwise the delay is capped to the remaining
+ * expiration window, expiring only when that window cannot fit one more
+ * full-value (`initialMs`) attempt.
+ *
+ * Jitter is deterministic-friendly: `options.random` is a `[0, 1]` sample
+ * supplied by the caller and defaults to `1`, which leaves the delay at its
+ * un-jittered value. Use {@link nextDelayEffect} to sample the `Random`
+ * service instead. A sample outside `[0, 1]`, or a persisted `jitterRatio`
+ * above one, gives up rather than returning a delay the policy never
+ * declared. A sample of zero under `jitterRatio: 1` is a delay of zero, which
+ * retries immediately.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const nextDelay: (policy: RetryPolicy, attempt: number, options?: {
+    readonly random?: number | undefined;
+    readonly elapsedMs?: number | undefined;
+}) => Option.Option<number>;
+/**
+ * Computes the next retry delay, sampling the `Random` service for jitter.
+ *
+ * Deterministic under `Random.withSeed`. Policies without a `jitterRatio`
+ * never touch the service.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const nextDelayEffect: (policy: RetryPolicy, attempt: number, options?: {
+    readonly elapsedMs?: number | undefined;
+}) => Effect.Effect<Option.Option<number>>;
+/**
+ * Extracts the stable identity tag of an error for non-retryable matching:
+ * an own string `_tag` when present, otherwise the first own `name` descriptor
+ * found while walking a bounded prototype chain. That first descriptor decides
+ * the result: only a string data value is a tag.
+ *
+ * Descriptors keep accessors inert instead of running author code through a
+ * property read. A bounded walk also terminates when a hostile proxy reports a
+ * cyclic prototype chain; any proxy trap that throws leaves the error untagged.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const errorTag: (error: unknown) => string | undefined;
+/**
+ * Error tags that are non-retryable by type, under every policy (issue #156).
+ *
+ * These failures are integrity verdicts that must reach the driver without an
+ * action-level retry hiding the first detection. Their persistence seams
+ * take a quarantine state action before raising them, so a later dispatch can
+ * heal, but the detecting dispatch remains a non-retryable failure. No
+ * per-callsite or per-policy opt-out exists; the tags are matched by string so
+ * the classification does not invert the package dependency direction.
+ *
+ * `AttemptEvidenceQuarantined` (issue #171) is the succeeded-attempt-row
+ * counterpart: the corrupt boundary evidence is removed while the completed
+ * outcome stays durable. It reaches the driver unretried, which parks the
+ * first detection in the `quarantine` waiting state; the next explicit resume
+ * returns the recorded outcome without re-executing the action.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const defaultNonRetryable: ReadonlyArray<string>;
+/**
+ * Whether an error is classified non-retryable, either by type (see
+ * {@link defaultNonRetryable}) or by the policy's declared tag list.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const isNonRetryable: (policy: RetryPolicy, error: unknown) => boolean;
+/**
+ * The pure core of the engine's single retry decision point.
+ *
+ * Non-retryable classification is evaluated here and nowhere else. This is
+ * the default a pluggable `resolveRetry` resolution falls back to when no
+ * plugin claims the decision.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const decide: (policy: RetryPolicy, options: {
+    readonly attempt: number;
+    readonly error: unknown;
+    readonly random?: number | undefined;
+    readonly elapsedMs?: number | undefined;
+}) => RetryDecision;
+/**
+ * Effect form of {@link decide}, sampling the `Random` service for jitter.
+ *
+ * This is the engine-facing decision function: keep calls to it behind a
+ * single decision point so a plugin hook dispatch can later be inserted in
+ * front of it without touching call sites.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const decideEffect: (policy: RetryPolicy, options: {
+    readonly attempt: number;
+    readonly error: unknown;
+    readonly elapsedMs?: number | undefined;
+}) => Effect.Effect<RetryDecision>;
+export {};
+//# sourceMappingURL=RetryPolicy.d.ts.map

package/dist/cjs/RetryPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryPolicy.d.ts","sourceRoot":"","sources":["../../src/RetryPolicy.ts"],"names":[],"mappings":"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"}

package/dist/cjs/RetryPolicy.js

@@ -0,0 +1,251 @@
+"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 RetryPolicy_exports = {};
+__export(RetryPolicy_exports, {
+  RetryAttemptsExhausted: () => RetryAttemptsExhausted,
+  RetryPolicy: () => RetryPolicy,
+  RetryPolicyExpired: () => RetryPolicyExpired,
+  decide: () => decide,
+  decideEffect: () => decideEffect,
+  defaultNonRetryable: () => defaultNonRetryable,
+  defaultRetryPolicy: () => defaultRetryPolicy,
+  errorTag: () => errorTag,
+  giveUp: () => giveUp,
+  isNonRetryable: () => isNonRetryable,
+  make: () => make,
+  nextDelay: () => nextDelay,
+  nextDelayEffect: () => nextDelayEffect,
+  retryAfter: () => retryAfter,
+  transient: () => transient
+});
+module.exports = __toCommonJS(RetryPolicy_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Random = __toESM(require("effect/Random"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const RetryPolicyFields = Schema.Struct({
+  initialMs: Schema.Number,
+  factor: Schema.Number,
+  maxMs: Schema.Number,
+  maxAttempts: Schema.optional(Schema.Number),
+  expirationMs: Schema.optional(Schema.Number),
+  jitterRatio: Schema.optional(Schema.Number),
+  nonRetryable: Schema.optional(Schema.Array(Schema.String))
+});
+const validationIssue = (policy) => {
+  if (!Number.isFinite(policy.initialMs) || policy.initialMs <= 0) {
+    return `"initialMs" must be a finite number of milliseconds greater than zero, and was ${policy.initialMs}.`;
+  }
+  if (!Number.isFinite(policy.factor) || policy.factor <= 0) {
+    return `"factor" must be a finite number greater than zero, and was ${policy.factor}.`;
+  }
+  if (!Number.isFinite(policy.maxMs) || policy.maxMs < policy.initialMs) {
+    return `"maxMs" must be a finite number of milliseconds at least as large as initialMs, and was ${policy.maxMs}.`;
+  }
+  if (policy.maxAttempts !== void 0 && (!Number.isSafeInteger(policy.maxAttempts) || policy.maxAttempts < 1)) {
+    return `"maxAttempts" must be a safe integer of at least one, and was ${policy.maxAttempts}.`;
+  }
+  if (policy.expirationMs !== void 0 && (!Number.isFinite(policy.expirationMs) || policy.expirationMs <= 0)) {
+    return `"expirationMs" must be a finite number of milliseconds greater than zero, and was ${policy.expirationMs}.`;
+  }
+  if (policy.jitterRatio !== void 0 && (!Number.isFinite(policy.jitterRatio) || policy.jitterRatio < 0 || policy.jitterRatio > 1)) {
+    return `"jitterRatio" must be a finite number between zero and one, inclusive, and was ${policy.jitterRatio}.`;
+  }
+  return void 0;
+};
+const RetryPolicy = RetryPolicyFields.check(
+  Schema.makeFilter(
+    (policy) => validationIssue(policy) ?? true,
+    { title: "validRetryPolicy" }
+  )
+);
+const make = (options) => {
+  const issue = validationIssue(options);
+  if (issue !== void 0) throw new RangeError(`RetryPolicy.make: ${issue}`);
+  return Object.freeze({
+    initialMs: options.initialMs,
+    factor: options.factor,
+    maxMs: options.maxMs,
+    ...options.maxAttempts !== void 0 ? { maxAttempts: options.maxAttempts } : {},
+    ...options.expirationMs !== void 0 ? { expirationMs: options.expirationMs } : {},
+    ...options.jitterRatio !== void 0 ? { jitterRatio: options.jitterRatio } : {},
+    ...options.nonRetryable !== void 0 ? { nonRetryable: Object.freeze([...options.nonRetryable]) } : {}
+  });
+};
+const defaultRetryPolicy = Object.freeze(
+  make({
+    initialMs: 200,
+    factor: 1.5,
+    maxMs: 3e4
+  })
+);
+const transient = make({
+  initialMs: 5e3,
+  factor: 2,
+  maxMs: 3e5,
+  expirationMs: 72e5
+});
+const retryAfter = (delayMs) => ({
+  _tag: "RetryAfter",
+  delayMs
+});
+const giveUp = (reason) => ({
+  _tag: "GiveUp",
+  reason
+});
+class RetryPolicyExpired extends Schema.TaggedError()(
+  "@smthrs/flow/RetryPolicyExpired",
+  {
+    code: Schema.Literal("retry_policy_expired").pipe(
+      Schema.withConstructorDefault(Effect.succeed("retry_policy_expired"))
+    ),
+    actionName: Schema.String,
+    attempt: Schema.Number,
+    expirationMs: Schema.Number,
+    lastError: Schema.optional(Schema.Unknown)
+  }
+) {
+}
+class RetryAttemptsExhausted extends Schema.TaggedError()(
+  "@smthrs/flow/RetryAttemptsExhausted",
+  {
+    code: Schema.Literal("retry_attempts_exhausted").pipe(
+      Schema.withConstructorDefault(Effect.succeed("retry_attempts_exhausted"))
+    ),
+    actionName: Schema.String,
+    attempt: Schema.Number,
+    maxAttempts: Schema.Number,
+    lastError: Schema.optional(Schema.Unknown)
+  }
+) {
+}
+const nextDelay = (policy, attempt, options) => {
+  if (validationIssue(policy) !== void 0 || !Number.isSafeInteger(attempt) || attempt < 1) {
+    return Option.none();
+  }
+  if (options?.elapsedMs !== void 0 && (!Number.isFinite(options.elapsedMs) || options.elapsedMs < 0)) {
+    return Option.none();
+  }
+  if (policy.maxAttempts !== void 0 && attempt >= policy.maxAttempts) {
+    return Option.none();
+  }
+  if (policy.expirationMs !== void 0 && options?.elapsedMs !== void 0 && options.elapsedMs > policy.expirationMs) {
+    return Option.none();
+  }
+  const raw = policy.initialMs * Math.pow(policy.factor, attempt - 1);
+  if (!(raw > 0)) {
+    return Option.none();
+  }
+  let delay = Math.min(raw, policy.maxMs);
+  if (policy.expirationMs !== void 0 && options?.elapsedMs !== void 0) {
+    delay = Math.min(delay, Math.max(0, policy.expirationMs - options.elapsedMs));
+  }
+  if (delay < policy.initialMs) {
+    return Option.none();
+  }
+  if (policy.jitterRatio !== void 0 && policy.jitterRatio > 0) {
+    const random = options?.random ?? 1;
+    if (!(random >= 0 && random <= 1)) {
+      return Option.none();
+    }
+    const jittered = delay * (1 - policy.jitterRatio) + random * delay * policy.jitterRatio;
+    delay = Math.min(delay, jittered);
+  }
+  return Option.some(delay);
+};
+const nextDelayEffect = (policy, attempt, options) => policy.jitterRatio === void 0 || policy.jitterRatio <= 0 ? Effect.sync(() => nextDelay(policy, attempt, { elapsedMs: options?.elapsedMs })) : Effect.map(Random.next, (random) => nextDelay(policy, attempt, { random, elapsedMs: options?.elapsedMs }));
+const errorTag = (error) => {
+  if (typeof error !== "object" || error === null) return void 0;
+  try {
+    const tag = Object.getOwnPropertyDescriptor(error, "_tag");
+    if (tag !== void 0 && "value" in tag && typeof tag.value === "string") return tag.value;
+    let current = error;
+    for (let depth = 0; current !== null && depth < 64; depth++) {
+      const name = Object.getOwnPropertyDescriptor(current, "name");
+      if (name !== void 0) {
+        return "value" in name && typeof name.value === "string" ? name.value : void 0;
+      }
+      current = Object.getPrototypeOf(current);
+    }
+  } catch {
+  }
+  return void 0;
+};
+const defaultNonRetryable = [
+  "@smthrs/engine-store/CacheCorruptionDetected",
+  "@smthrs/engine-store/AttemptEvidenceQuarantined"
+];
+const isNonRetryable = (policy, error) => {
+  const tag = errorTag(error);
+  if (tag === void 0) {
+    return false;
+  }
+  if (defaultNonRetryable.includes(tag)) {
+    return true;
+  }
+  return policy.nonRetryable !== void 0 && policy.nonRetryable.includes(tag);
+};
+const decide = (policy, options) => {
+  if (isNonRetryable(policy, options.error)) {
+    return giveUp("nonRetryable");
+  }
+  return Option.match(
+    nextDelay(policy, options.attempt, { random: options.random, elapsedMs: options.elapsedMs }),
+    {
+      onNone: () => (
+        // A policy can report `expired` only when it declares an expiration
+        // bound and dropping elapsed time would have allowed another attempt.
+        // A malformed elapsed value still gives up because the sequence cannot
+        // continue without a trustworthy clock reading; without an expiration
+        // bound, the public terminal reason for that refusal is `exhausted`.
+        policy.expirationMs !== void 0 && Option.isSome(nextDelay(policy, options.attempt, { random: options.random })) ? giveUp("expired") : giveUp("exhausted")
+      ),
+      onSome: (delay) => {
+        let hint;
+        if (typeof options.error === "object" && options.error !== null) {
+          try {
+            const descriptor = Object.getOwnPropertyDescriptor(options.error, "retryAfterMs");
+            if (descriptor !== void 0 && "value" in descriptor) hint = descriptor.value;
+          } catch {
+          }
+        }
+        if (typeof hint !== "number" || !Number.isFinite(hint) || hint < 0) {
+          return retryAfter(delay);
+        }
+        return retryAfter(Math.min(
+          hint,
+          policy.maxMs,
+          policy.expirationMs !== void 0 && options.elapsedMs !== void 0 ? Math.max(0, policy.expirationMs - options.elapsedMs) : policy.maxMs
+        ));
+      }
+    }
+  );
+};
+const decideEffect = (policy, options) => policy.jitterRatio === void 0 || policy.jitterRatio <= 0 ? Effect.sync(() => decide(policy, options)) : Effect.map(Random.next, (random) => decide(policy, { ...options, random }));
+//# sourceMappingURL=RetryPolicy.js.map

package/dist/cjs/RetryPolicy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/RetryPolicy.ts"],
+  "sourcesContent": ["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Defines data-shaped retry policies for durable action retries.\n *\n * A `RetryPolicy` is a plain value \u2014 initial interval, backoff factor, cap,\n * optional maximum attempts, optional jitter, and optional non-retryable\n * error tags \u2014 so the next retry delay can be derived from a persisted\n * attempt count instead of fiber-local `Schedule` state. `nextDelay` mirrors\n * Temporal's `ExponentialRetryPolicy.ComputeNextDelay` formula, and `decide`\n * is the engine's single retry decision point: the core default a pluggable\n * `resolveRetry` resolution can later dispatch in front of.\n *\n * The historical terminal-failure schemas below use the `@smthrs/flow/` tags settled for\n * 1.0.0-rc.0. The release candidate makes no compatibility promise to 0.x\n * journals, and these tags freeze at the RC. Current action dispatch preserves\n * the final declared failure when a retry policy is spent.\n *\n * See `docs/guides/retry-a-failing-action.md`; its \"Infrastructure\n * interrupts\" section covers the interrupt retry schedule.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Random from \"effect/Random\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Data-shaped retry policy schema.\n *\n * The delay before attempt `n + 1` is\n * `min(initialMs * factor^(n - 1), maxMs)`, where `n` is the attempt that\n * just failed. `maxAttempts` bounds the total number of attempts;\n * `expirationMs` bounds the total wall-clock retry duration\n * (schedule-to-close, mirroring Temporal's `expirationInterval`);\n * `jitterRatio` spreads the final portion of each delay uniformly;\n * `nonRetryable` lists error tags that must never be retried.\n *\n * The bounds are per STEP KEY, which is what makes them the provider-retry\n * budget for one agent ask rather than a budget for the exchange the ask\n * belongs to. A structured-output correction re-prompts under a NEW session,\n * so the corrected ask is a different sealed step with its own attempt\n * sequence: `maxAttempts` bounds the provider retries inside one correction\n * session and does not bound the correction ladder, which `AgentAction`\n * bounds separately with its own `corrections` budget.\n *\n * @category models\n * @since 0.1.0\n */\nconst RetryPolicyFields = Schema.Struct({\n  initialMs: Schema.Number,\n  factor: Schema.Number,\n  maxMs: Schema.Number,\n  maxAttempts: Schema.optional(Schema.Number),\n  expirationMs: Schema.optional(Schema.Number),\n  jitterRatio: Schema.optional(Schema.Number),\n  nonRetryable: Schema.optional(Schema.Array(Schema.String))\n})\n\ntype RetryPolicyFields = typeof RetryPolicyFields.Type\n\n/** Returns the first contract violation shared by decoding and construction. */\nconst validationIssue = (policy: RetryPolicyFields): string | undefined => {\n  // Zero is refused rather than read as \"retry immediately\": every computed\n  // delay would be zero, so such a policy would give up on its first failure\n  // no matter what `maxAttempts` promised. Use `initialMs: 1` for a\n  // near-immediate retry.\n  if (!Number.isFinite(policy.initialMs) || policy.initialMs <= 0) {\n    return `\"initialMs\" must be a finite number of milliseconds greater than zero, and was ${policy.initialMs}.`\n  }\n  if (!Number.isFinite(policy.factor) || policy.factor <= 0) {\n    return `\"factor\" must be a finite number greater than zero, and was ${policy.factor}.`\n  }\n  if (!Number.isFinite(policy.maxMs) || policy.maxMs < policy.initialMs) {\n    return `\"maxMs\" must be a finite number of milliseconds at least as large as initialMs, and was ${policy.maxMs}.`\n  }\n  if (\n    policy.maxAttempts !== undefined &&\n    (!Number.isSafeInteger(policy.maxAttempts) || policy.maxAttempts < 1)\n  ) {\n    return `\"maxAttempts\" must be a safe integer of at least one, and was ${policy.maxAttempts}.`\n  }\n  if (\n    policy.expirationMs !== undefined &&\n    (!Number.isFinite(policy.expirationMs) || policy.expirationMs <= 0)\n  ) {\n    return `\"expirationMs\" must be a finite number of milliseconds greater than zero, and was ${policy.expirationMs}.`\n  }\n  if (\n    policy.jitterRatio !== undefined &&\n    (!Number.isFinite(policy.jitterRatio) || policy.jitterRatio < 0 || policy.jitterRatio > 1)\n  ) {\n    return `\"jitterRatio\" must be a finite number between zero and one, inclusive, and was ${policy.jitterRatio}.`\n  }\n  return undefined\n}\n\n/**\n * Data-shaped retry policy schema. Decoding enforces the same relational\n * contract as {@link make}; persisted data cannot bypass constructor checks.\n *\n * @category models\n * @since 0.1.0\n */\nexport const RetryPolicy = RetryPolicyFields.check(\n  Schema.makeFilter(\n    (policy) => validationIssue(policy) ?? true,\n    { title: \"validRetryPolicy\" }\n  )\n)\n\n/**\n * The value form of a {@link RetryPolicy}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RetryPolicy = typeof RetryPolicy.Type\n\n/**\n * Creates a `RetryPolicy` value after checking every numeric bound.\n * `initialMs` must be greater than zero: a zero initial interval would\n * compute a zero delay for every attempt, which {@link nextDelay} reads as\n * exhausted, so the policy would never retry. `jitterRatio` must be between\n * zero and one, inclusive, and `jitterRatio: 0` disables jitter.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (options: {\n  readonly initialMs: number\n  readonly factor: number\n  readonly maxMs: number\n  readonly maxAttempts?: number | undefined\n  readonly expirationMs?: number | undefined\n  readonly jitterRatio?: number | undefined\n  readonly nonRetryable?: ReadonlyArray<string> | undefined\n}): RetryPolicy => {\n  const issue = validationIssue(options)\n  if (issue !== undefined) throw new RangeError(`RetryPolicy.make: ${issue}`)\n  return Object.freeze({\n    initialMs: options.initialMs,\n    factor: options.factor,\n    maxMs: options.maxMs,\n    ...(options.maxAttempts !== undefined ? { maxAttempts: options.maxAttempts } : {}),\n    ...(options.expirationMs !== undefined ? { expirationMs: options.expirationMs } : {}),\n    ...(options.jitterRatio !== undefined ? { jitterRatio: options.jitterRatio } : {}),\n    ...(options.nonRetryable !== undefined\n      ? { nonRetryable: Object.freeze([...options.nonRetryable]) }\n      : {})\n  })\n}\n\n/**\n * The default engine retry policy.\n *\n * Uses a 200ms initial delay growing by 1.5x, capped at 30s, and never gives\n * up: it declares neither `maxAttempts` nor `expirationMs`. Bound long-lived\n * retries with `make({ ..., expirationMs })` when a wall-clock give-up is\n * required.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const defaultRetryPolicy: RetryPolicy = Object.freeze(\n  make({\n    initialMs: 200,\n    factor: 1.5,\n    maxMs: 30000\n  })\n)\n\n/**\n * Bounded infrastructure retry: 5 seconds doubling to 5 minutes, for 2 hours.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const transient: RetryPolicy = make({\n  initialMs: 5000,\n  factor: 2,\n  maxMs: 300000,\n  expirationMs: 7200000\n})\n\n/**\n * A retry decision: wait `delayMs` before the next attempt.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface RetryAfter {\n  readonly _tag: \"RetryAfter\"\n  readonly delayMs: number\n}\n\n/**\n * A retry decision: stop retrying.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface GiveUp {\n  readonly _tag: \"GiveUp\"\n  readonly reason: \"nonRetryable\" | \"exhausted\" | \"expired\"\n}\n\n/**\n * The outcome of the engine's retry decision point.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RetryDecision = RetryAfter | GiveUp\n\n/**\n * Creates a `RetryAfter` decision.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const retryAfter = (delayMs: number): RetryDecision => ({\n  _tag: \"RetryAfter\",\n  delayMs\n})\n\n/**\n * Creates a `GiveUp` decision.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const giveUp = (reason: GiveUp[\"reason\"]): RetryDecision => ({\n  _tag: \"GiveUp\",\n  reason\n})\n\n/**\n * A historical retry sequence crossed its `expirationMs` wall-clock bound.\n * Current dispatch preserves the final declared failure instead of emitting this defect.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class RetryPolicyExpired extends Schema.TaggedError<RetryPolicyExpired>()(\n  \"@smthrs/flow/RetryPolicyExpired\",\n  {\n    code: Schema.Literal(\"retry_policy_expired\").pipe(\n      Schema.withConstructorDefault(Effect.succeed(\"retry_policy_expired\"))\n    ),\n    actionName: Schema.String,\n    attempt: Schema.Number,\n    expirationMs: Schema.Number,\n    lastError: Schema.optional(Schema.Unknown)\n  }\n) {}\n\n/**\n * A historical retry sequence exhausted its `maxAttempts` bound.\n * Current dispatch preserves the final declared failure instead of emitting this defect.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class RetryAttemptsExhausted extends Schema.TaggedError<RetryAttemptsExhausted>()(\n  \"@smthrs/flow/RetryAttemptsExhausted\",\n  {\n    code: Schema.Literal(\"retry_attempts_exhausted\").pipe(\n      Schema.withConstructorDefault(Effect.succeed(\"retry_attempts_exhausted\"))\n    ),\n    actionName: Schema.String,\n    attempt: Schema.Number,\n    maxAttempts: Schema.Number,\n    lastError: Schema.optional(Schema.Unknown)\n  }\n) {}\n\n/**\n * Computes the delay before attempt `attempt + 1` from the persisted attempt\n * count, mirroring Temporal's `ComputeNextDelay`\n * (`common/backoff/retrypolicy.go`).\n *\n * `attempt` is the 1-based attempt that just failed. Returns `None` when the\n * policy gives up: `maxAttempts` reached, a non-positive computed interval,\n * a cap below the initial interval, or \u2014 when the policy declares\n * `expirationMs` and the caller supplies `elapsedMs` \u2014 an elapsed duration\n * past the expiration bound. Otherwise the delay is capped to the remaining\n * expiration window, expiring only when that window cannot fit one more\n * full-value (`initialMs`) attempt.\n *\n * Jitter is deterministic-friendly: `options.random` is a `[0, 1]` sample\n * supplied by the caller and defaults to `1`, which leaves the delay at its\n * un-jittered value. Use {@link nextDelayEffect} to sample the `Random`\n * service instead. A sample outside `[0, 1]`, or a persisted `jitterRatio`\n * above one, gives up rather than returning a delay the policy never\n * declared. A sample of zero under `jitterRatio: 1` is a delay of zero, which\n * retries immediately.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const nextDelay = (\n  policy: RetryPolicy,\n  attempt: number,\n  options?: {\n    readonly random?: number | undefined\n    readonly elapsedMs?: number | undefined\n  }\n): Option.Option<number> => {\n  // Persisted policies can be decoded without `make`, so these guards treat a\n  // corrupt row as terminal instead of sending an invalid delay to the engine.\n  if (validationIssue(policy) !== undefined || !Number.isSafeInteger(attempt) || attempt < 1) {\n    return Option.none()\n  }\n  if (\n    options?.elapsedMs !== undefined &&\n    (!Number.isFinite(options.elapsedMs) || options.elapsedMs < 0)\n  ) {\n    return Option.none()\n  }\n  if (policy.maxAttempts !== undefined && attempt >= policy.maxAttempts) {\n    return Option.none()\n  }\n  if (\n    policy.expirationMs !== undefined &&\n    options?.elapsedMs !== undefined &&\n    options.elapsedMs > policy.expirationMs\n  ) {\n    return Option.none()\n  }\n  const raw = policy.initialMs * Math.pow(policy.factor, attempt - 1)\n  if (!(raw > 0)) {\n    return Option.none()\n  }\n  let delay = Math.min(raw, policy.maxMs)\n  // Temporal caps the delay to the remaining expiration window rather than\n  // refusing outright; the below-initial check then expires sequences whose\n  // remaining window cannot fit one more full-value attempt.\n  if (policy.expirationMs !== undefined && options?.elapsedMs !== undefined) {\n    delay = Math.min(delay, Math.max(0, policy.expirationMs - options.elapsedMs))\n  }\n  if (delay < policy.initialMs) {\n    return Option.none()\n  }\n  // `validationIssue` established finite `maxMs`, so `Math.min` made the\n  // un-jittered delay finite even when the exponential itself overflowed.\n  // This check belongs before jitter conceptually: a full-jitter sample of\n  // zero is a legitimate immediate retry rather than a give-up.\n  if (policy.jitterRatio !== undefined && policy.jitterRatio > 0) {\n    // Both jitter inputs are bounded to [0, 1] where they are accepted --\n    // `make` for `jitterRatio` and this function's contract for `random` --\n    // while `random` is a public option that still needs checking here.\n    const random = options?.random ?? 1\n    if (!(random >= 0 && random <= 1)) {\n      return Option.none()\n    }\n    // In range, the result is between `delay * (1 - jitterRatio)` and `delay`,\n    // so it is finite and never negative. A jittered value of zero retries\n    // immediately; it does not exhaust the sequence.\n    //\n    // The two terms do not sum to exactly `delay` at `random: 1`: at\n    // `jitterRatio: 0.000002` a delay of 100 rounds up to 100.00000000000001,\n    // above the policy's own cap and above the remaining expiration window.\n    // Clamping down to the un-jittered delay is what makes the upper bound\n    // stated above exact rather than approximate.\n    const jittered = delay * (1 - policy.jitterRatio) + random * delay * policy.jitterRatio\n    delay = Math.min(delay, jittered)\n  }\n  return Option.some(delay)\n}\n\n/**\n * Computes the next retry delay, sampling the `Random` service for jitter.\n *\n * Deterministic under `Random.withSeed`. Policies without a `jitterRatio`\n * never touch the service.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const nextDelayEffect = (\n  policy: RetryPolicy,\n  attempt: number,\n  options?: { readonly elapsedMs?: number | undefined }\n): Effect.Effect<Option.Option<number>> =>\n  policy.jitterRatio === undefined || policy.jitterRatio <= 0\n    ? Effect.sync(() => nextDelay(policy, attempt, { elapsedMs: options?.elapsedMs }))\n    : Effect.map(Random.next, (random) => nextDelay(policy, attempt, { random, elapsedMs: options?.elapsedMs }))\n\n/**\n * Extracts the stable identity tag of an error for non-retryable matching:\n * an own string `_tag` when present, otherwise the first own `name` descriptor\n * found while walking a bounded prototype chain. That first descriptor decides\n * the result: only a string data value is a tag.\n *\n * Descriptors keep accessors inert instead of running author code through a\n * property read. A bounded walk also terminates when a hostile proxy reports a\n * cyclic prototype chain; any proxy trap that throws leaves the error untagged.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const errorTag = (error: unknown): string | undefined => {\n  if (typeof error !== \"object\" || error === null) return undefined\n  try {\n    const tag = Object.getOwnPropertyDescriptor(error, \"_tag\")\n    if (tag !== undefined && \"value\" in tag && typeof tag.value === \"string\") return tag.value\n\n    let current: object | null = error\n    for (let depth = 0; current !== null && depth < 64; depth++) {\n      const name = Object.getOwnPropertyDescriptor(current, \"name\")\n      if (name !== undefined) {\n        return \"value\" in name && typeof name.value === \"string\" ? name.value : undefined\n      }\n      current = Object.getPrototypeOf(current)\n    }\n  } catch {\n    // Proxies and hostile accessors are untrusted failure payloads. An error\n    // that cannot be inspected inertly simply has no stable retry tag.\n  }\n  return undefined\n}\n\n/**\n * Error tags that are non-retryable by type, under every policy (issue #156).\n *\n * These failures are integrity verdicts that must reach the driver without an\n * action-level retry hiding the first detection. Their persistence seams\n * take a quarantine state action before raising them, so a later dispatch can\n * heal, but the detecting dispatch remains a non-retryable failure. No\n * per-callsite or per-policy opt-out exists; the tags are matched by string so\n * the classification does not invert the package dependency direction.\n *\n * `AttemptEvidenceQuarantined` (issue #171) is the succeeded-attempt-row\n * counterpart: the corrupt boundary evidence is removed while the completed\n * outcome stays durable. It reaches the driver unretried, which parks the\n * first detection in the `quarantine` waiting state; the next explicit resume\n * returns the recorded outcome without re-executing the action.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const defaultNonRetryable: ReadonlyArray<string> = [\n  \"@smthrs/engine-store/CacheCorruptionDetected\",\n  \"@smthrs/engine-store/AttemptEvidenceQuarantined\"\n]\n\n/**\n * Whether an error is classified non-retryable, either by type (see\n * {@link defaultNonRetryable}) or by the policy's declared tag list.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const isNonRetryable = (policy: RetryPolicy, error: unknown): boolean => {\n  const tag = errorTag(error)\n  if (tag === undefined) {\n    return false\n  }\n  if (defaultNonRetryable.includes(tag)) {\n    return true\n  }\n  return policy.nonRetryable !== undefined && policy.nonRetryable.includes(tag)\n}\n\n/**\n * The pure core of the engine's single retry decision point.\n *\n * Non-retryable classification is evaluated here and nowhere else. This is\n * the default a pluggable `resolveRetry` resolution falls back to when no\n * plugin claims the decision.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const decide = (\n  policy: RetryPolicy,\n  options: {\n    readonly attempt: number\n    readonly error: unknown\n    readonly random?: number | undefined\n    readonly elapsedMs?: number | undefined\n  }\n): RetryDecision => {\n  if (isNonRetryable(policy, options.error)) {\n    return giveUp(\"nonRetryable\")\n  }\n  return Option.match(\n    nextDelay(policy, options.attempt, { random: options.random, elapsedMs: options.elapsedMs }),\n    {\n      onNone: () =>\n        // A policy can report `expired` only when it declares an expiration\n        // bound and dropping elapsed time would have allowed another attempt.\n        // A malformed elapsed value still gives up because the sequence cannot\n        // continue without a trustworthy clock reading; without an expiration\n        // bound, the public terminal reason for that refusal is `exhausted`.\n        policy.expirationMs !== undefined &&\n          Option.isSome(nextDelay(policy, options.attempt, { random: options.random }))\n          ? giveUp(\"expired\")\n          : giveUp(\"exhausted\"),\n      onSome: (delay) => {\n        // Tool failures may supply a delay instead of using policy backoff.\n        // Inspect only an own data property: failure payloads can be untrusted.\n        let hint: unknown\n        if (typeof options.error === \"object\" && options.error !== null) {\n          try {\n            const descriptor = Object.getOwnPropertyDescriptor(options.error, \"retryAfterMs\")\n            if (descriptor !== undefined && \"value\" in descriptor) hint = descriptor.value\n          } catch {\n            // An uninspectable failure falls back to the policy delay.\n          }\n        }\n        if (typeof hint !== \"number\" || !Number.isFinite(hint) || hint < 0) {\n          return retryAfter(delay)\n        }\n        return retryAfter(Math.min(\n          hint,\n          policy.maxMs,\n          policy.expirationMs !== undefined && options.elapsedMs !== undefined\n            ? Math.max(0, policy.expirationMs - options.elapsedMs)\n            : policy.maxMs\n        ))\n      }\n    }\n  )\n}\n\n/**\n * Effect form of {@link decide}, sampling the `Random` service for jitter.\n *\n * This is the engine-facing decision function: keep calls to it behind a\n * single decision point so a plugin hook dispatch can later be inserted in\n * front of it without touching call sites.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const decideEffect = (\n  policy: RetryPolicy,\n  options: {\n    readonly attempt: number\n    readonly error: unknown\n    readonly elapsedMs?: number | undefined\n  }\n): Effect.Effect<RetryDecision> =>\n  policy.jitterRatio === undefined || policy.jitterRatio <= 0\n    ? Effect.sync(() => decide(policy, options))\n    : Effect.map(Random.next, (random) => decide(policy, { ...options, random }))\n"],
+  "mappings": "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",
+  "names": []
+}