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

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": []
+}

package/dist/cjs/Sleep.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The system timer, as an ordinary declared action.
+ *
+ * `docs/concepts/flows-and-actions.md` names the timer primitive a
+ * gap and says how to close it: ship it over the existing `DurableClock`, so a
+ * wait is a visible, keyed plan node rather than a second execution mechanism.
+ * That is this module. {@link action} is a plain `Action.make` declaration —
+ * it appears in a catalog, `.call()` records a node, and `Graph.build` puts that
+ * node in the plan beside every other step — and {@link layer} is the
+ * implementation the hosts that can run a timer provide.
+ *
+ * The wait itself is `DurableClock`'s, not a new one. The implementation arms
+ * the durable clock and awaits its deferred, which is what parks the execution;
+ * the park is declared through the ordinary waiting vocabulary
+ * ({@link module:WaitingAnnotation.annotateWaiting}) under `timer`, with the
+ * deadline as `wakeAt`, so a durable driver records the same waiting row it
+ * records for a hand-written `DurableClock.sleep`. Replay is the deferred's:
+ * once the clock has fired, its result is persisted, so a re-driven round reads
+ * it and runs straight through instead of parking a second time.
+ *
+ * Which clock a wait arms is the dispatch's own, read from
+ * {@link module:Context.CurrentInvocationKey}: a keyed node already owns an
+ * identity that survives replay and separates two identical calls, so the timer
+ * inherits it rather than being addressed by the payload it was called with.
+ *
+ * @since 0.1.0
+ */
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Action from "./Action/index.ts";
+import type { FlowRuntime } from "./FlowRuntime/FlowRuntime.ts";
+declare const SleepRequestInvalid_base: Schema.Class<SleepRequestInvalid, Schema.TaggedStruct<"@smthrs/flow/SleepRequestInvalid", {
+    readonly code: Schema.Literals<readonly ["missing_deadline", "ambiguous_deadline", "invalid_deadline"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A sleep whose payload does not name exactly one deadline.
+ *
+ * A payload carries a relative `millis` or an absolute `until`, and naming
+ * both, or neither, leaves no deadline to arm a clock with. It is a typed
+ * failure rather than a defect because the payload of a driven node is
+ * assembled from plan values, so an author's mistake is recoverable through
+ * `Node.catch` like any other declared failure.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class SleepRequestInvalid extends SleepRequestInvalid_base {
+}
+/**
+ * The tag the sleep declaration is catalogued and resolved under.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const tag = "system/sleep";
+/**
+ * The declared sleep action: `millis` from now, or an absolute `until`.
+ *
+ * **When to use**
+ *
+ * Use it in a body wherever a round has to wait for time to pass —
+ * `Sleep.action.call({ millis: 60_000 })` — rather than reaching for
+ * `DurableClock.sleep`, which is only callable from a handler and leaves
+ * nothing in the plan. A sleep node is keyed, inspectable, and skippable by a
+ * branch exactly like an action that does work.
+ *
+ * Two waits of the same length are two waits: `sleep(1h)` followed by
+ * `sleep(1h)` sleeps for two hours, because each call is its own node with its
+ * own identity, exactly as two calls of any other declaration are.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const action: Action.Declared<typeof tag, Schema.Struct<{
+    readonly millis: Schema.optional<Schema.Number>;
+    readonly until: Schema.optional<Schema.Number>;
+}>, typeof Schema.Void, typeof SleepRequestInvalid, never>;
+/**
+ * The sleep implementation: arm the durable clock, park under `timer`, wake.
+ *
+ * Provide it beside the other action implementation layers a body calls, over
+ * the {@link module:Implementations.layerImplementations} table they file
+ * themselves in:
+ *
+ * ```ts
+ * Layer.mergeAll(Sleep.layer, Interpreter.layer(Pipeline)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ * ```
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime>;
+export {};
+//# sourceMappingURL=Sleep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sleep.d.ts","sourceRoot":"","sources":["../../src/Sleep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAG5C,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;;;;;AAG/D;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAoB,SAAQ,wBAMxC;CAAG;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,GAAG,iBAAiB,CAAA;AAEjC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,QAAQ,CAClC,OAAO,GAAG,EACV,MAAM,CAAC,MAAM,CAAC;IACZ,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;CAC/C,CAAC,EACF,OAAO,MAAM,CAAC,IAAI,EAClB,OAAO,mBAAmB,EAC1B,KAAK,CASL,CAAA;AA0IF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,CAuCxE,CAAA"}

package/dist/cjs/Sleep.js

@@ -0,0 +1,141 @@
+"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 Sleep_exports = {};
+__export(Sleep_exports, {
+  SleepRequestInvalid: () => SleepRequestInvalid,
+  action: () => action,
+  layer: () => layer,
+  tag: () => tag
+});
+module.exports = __toCommonJS(Sleep_exports);
+var Clock = __toESM(require("effect/Clock"), 1);
+var Duration = __toESM(require("effect/Duration"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Action = __toESM(require("./Action/index.js"), 1);
+var DurableClock = __toESM(require("./DurableClock.js"), 1);
+var import_WaitingAnnotation = require("./FlowRuntime/WaitingAnnotation.js");
+class SleepRequestInvalid extends Schema.TaggedError()(
+  "@smthrs/flow/SleepRequestInvalid",
+  {
+    code: Schema.Literals(["missing_deadline", "ambiguous_deadline", "invalid_deadline"]),
+    message: Schema.String
+  }
+) {
+}
+const tag = "system/sleep";
+const action = Action.makeSystem(tag, {
+  payload: {
+    millis: Schema.optional(Schema.Number),
+    until: Schema.optional(Schema.Number)
+  },
+  success: Schema.Void,
+  error: SleepRequestInvalid,
+  tier: "sealed"
+});
+const latestDeadline = Number.MAX_SAFE_INTEGER;
+const tooLate = (stated) => new SleepRequestInvalid({
+  code: "invalid_deadline",
+  message: `${tag} was called with ${stated}, which ends after ${latestDeadline}, the latest epoch millisecond a durable timer records.`
+});
+const deadlineOf = (payload, now) => {
+  if (payload.millis !== void 0 && payload.until !== void 0) {
+    return Effect.fail(
+      new SleepRequestInvalid({
+        code: "ambiguous_deadline",
+        message: `${tag} was called with both "millis" and "until". A sleep names one deadline: a relative duration, or an absolute epoch time.`
+      })
+    );
+  }
+  if (payload.millis !== void 0) {
+    if (!Number.isFinite(payload.millis) || payload.millis < 0) {
+      return Effect.fail(
+        new SleepRequestInvalid({
+          code: "invalid_deadline",
+          message: `${tag} was called with millis ${payload.millis}. A deadline is a finite number of milliseconds that is not negative; the sleep would be over before it started, or never over at all.`
+        })
+      );
+    }
+    const deadline = now + payload.millis;
+    if (!Number.isFinite(deadline)) {
+      return Effect.fail(
+        new SleepRequestInvalid({
+          code: "invalid_deadline",
+          message: `${tag} was called with millis ${payload.millis} at current time ${now}, which produces ${deadline}. A deadline is a finite epoch time in milliseconds.`
+        })
+      );
+    }
+    return Math.ceil(deadline) > latestDeadline ? Effect.fail(tooLate(`millis ${payload.millis} at current time ${now}`)) : Effect.succeed(deadline);
+  }
+  if (payload.until !== void 0) {
+    if (!Number.isFinite(payload.until)) {
+      return Effect.fail(
+        new SleepRequestInvalid({
+          code: "invalid_deadline",
+          message: `${tag} was called with until ${payload.until}. A deadline is a finite epoch time in milliseconds; the sleep must end at a real point in time.`
+        })
+      );
+    }
+    return Math.ceil(payload.until) > latestDeadline ? Effect.fail(tooLate(`until ${payload.until}`)) : Effect.succeed(payload.until);
+  }
+  return Effect.fail(
+    new SleepRequestInvalid({
+      code: "missing_deadline",
+      message: `${tag} was called with neither "millis" nor "until", so there is no deadline to wait for.`
+    })
+  );
+};
+const clockName = Effect.gen(function* () {
+  const invocation = yield* Action.CurrentInvocationKey;
+  if (invocation === void 0) {
+    return yield* Effect.die(
+      `${tag} ran under a runtime that supplies no Action.CurrentInvocationKey. A durable timer is named by the dispatch that armed it, so a runtime that does not identify the dispatch cannot arm one.`
+    );
+  }
+  return `Sleep/${invocation}`;
+});
+const layer = action.toLayer(
+  (payload) => Effect.gen(function* () {
+    const now = Math.floor(yield* Clock.currentTimeMillis);
+    const wakeAt = Math.ceil(yield* deadlineOf(payload, now));
+    const remaining = wakeAt - now;
+    if (remaining <= 0) return;
+    const name = yield* clockName;
+    yield* (0, import_WaitingAnnotation.annotateWaiting)({ reason: "timer", wakeAt });
+    yield* DurableClock.sleep({
+      name,
+      duration: Duration.millis(remaining),
+      // The wait is the point: a sleep called as a plan node parks the
+      // execution rather than holding a fiber open, so the in-memory shortcut
+      // is disabled instead of being left at its 60-second default.
+      inMemoryThreshold: Duration.zero
+    });
+  })
+);
+//# sourceMappingURL=Sleep.js.map

package/dist/cjs/Sleep.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Sleep.ts"],
+  "sourcesContent": ["/**\n * The system timer, as an ordinary declared action.\n *\n * `docs/concepts/flows-and-actions.md` names the timer primitive a\n * gap and says how to close it: ship it over the existing `DurableClock`, so a\n * wait is a visible, keyed plan node rather than a second execution mechanism.\n * That is this module. {@link action} is a plain `Action.make` declaration \u2014\n * it appears in a catalog, `.call()` records a node, and `Graph.build` puts that\n * node in the plan beside every other step \u2014 and {@link layer} is the\n * implementation the hosts that can run a timer provide.\n *\n * The wait itself is `DurableClock`'s, not a new one. The implementation arms\n * the durable clock and awaits its deferred, which is what parks the execution;\n * the park is declared through the ordinary waiting vocabulary\n * ({@link module:WaitingAnnotation.annotateWaiting}) under `timer`, with the\n * deadline as `wakeAt`, so a durable driver records the same waiting row it\n * records for a hand-written `DurableClock.sleep`. Replay is the deferred's:\n * once the clock has fired, its result is persisted, so a re-driven round reads\n * it and runs straight through instead of parking a second time.\n *\n * Which clock a wait arms is the dispatch's own, read from\n * {@link module:Context.CurrentInvocationKey}: a keyed node already owns an\n * identity that survives replay and separates two identical calls, so the timer\n * inherits it rather than being addressed by the payload it was called with.\n *\n * @since 0.1.0\n */\n\nimport * as Clock from \"effect/Clock\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Duration from \"effect/Duration\"\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 DurableClock from \"./DurableClock.ts\"\nimport type { FlowRuntime } from \"./FlowRuntime/FlowRuntime.ts\"\nimport { annotateWaiting } from \"./FlowRuntime/WaitingAnnotation.ts\"\n\n/**\n * A sleep whose payload does not name exactly one deadline.\n *\n * A payload carries a relative `millis` or an absolute `until`, and naming\n * both, or neither, leaves no deadline to arm a clock with. It is a typed\n * failure rather than a defect because the payload of a driven node is\n * assembled from plan values, so an author's mistake is recoverable through\n * `Node.catch` like any other declared failure.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class SleepRequestInvalid extends Schema.TaggedError<SleepRequestInvalid>()(\n  \"@smthrs/flow/SleepRequestInvalid\",\n  {\n    code: Schema.Literals([\"missing_deadline\", \"ambiguous_deadline\", \"invalid_deadline\"]),\n    message: Schema.String\n  }\n) {}\n\n/**\n * The tag the sleep declaration is catalogued and resolved under.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const tag = \"system/sleep\"\n\n/**\n * The declared sleep action: `millis` from now, or an absolute `until`.\n *\n * **When to use**\n *\n * Use it in a body wherever a round has to wait for time to pass \u2014\n * `Sleep.action.call({ millis: 60_000 })` \u2014 rather than reaching for\n * `DurableClock.sleep`, which is only callable from a handler and leaves\n * nothing in the plan. A sleep node is keyed, inspectable, and skippable by a\n * branch exactly like an action that does work.\n *\n * Two waits of the same length are two waits: `sleep(1h)` followed by\n * `sleep(1h)` sleeps for two hours, because each call is its own node with its\n * own identity, exactly as two calls of any other declaration are.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const action: Action.Declared<\n  typeof tag,\n  Schema.Struct<{\n    readonly millis: Schema.optional<Schema.Number>\n    readonly until: Schema.optional<Schema.Number>\n  }>,\n  typeof Schema.Void,\n  typeof SleepRequestInvalid,\n  never\n> = Action.makeSystem(tag, {\n  payload: {\n    millis: Schema.optional(Schema.Number),\n    until: Schema.optional(Schema.Number)\n  },\n  success: Schema.Void,\n  error: SleepRequestInvalid,\n  tier: \"sealed\"\n})\n\n/**\n * The latest deadline a sleep can arm, in epoch milliseconds.\n *\n * A durable store records `wakeAt` and a clock's due time as a non-negative\n * safe integer. A finite deadline past this one passed every other check and\n * then failed the park write, so it is refused with the payload's other\n * invalid deadlines instead.\n *\n * @private\n */\nconst latestDeadline = Number.MAX_SAFE_INTEGER\n\n/**\n * The refusal for a deadline later than {@link latestDeadline}.\n *\n * @private\n */\nconst tooLate = (stated: string): SleepRequestInvalid =>\n  new SleepRequestInvalid({\n    code: \"invalid_deadline\",\n    message: `${tag} was called with ${stated}, which ends after ${latestDeadline}, the latest epoch ` +\n      \"millisecond a durable timer records.\"\n  })\n\n/**\n * The absolute deadline a payload names, in epoch milliseconds.\n *\n * DECIDED: a payload names EXACTLY one of `millis`\n * and `until`, and both other shapes are refused rather than resolved by\n * precedence. A precedence rule would silently ignore half of a payload an\n * author believed in, and the two fields are the same fact stated two ways, so\n * there is no shape where carrying both is meaningful.\n *\n * `Duration.millis` accepts every number, so an unchecked deadline changes the\n * sleep instead of refusing it. `NaN` becomes zero, a negative relative delay\n * has already passed, and `Infinity` never ends. The implementation rejects\n * those values before it annotates the instance or arms a clock. A finite\n * absolute `until` remains legal when it is in the past because that sleep can\n * settle immediately.\n *\n * @private\n */\nconst deadlineOf = (\n  payload: { readonly millis?: number | undefined; readonly until?: number | undefined },\n  now: number\n): Effect.Effect<number, SleepRequestInvalid> => {\n  if (payload.millis !== undefined && payload.until !== undefined) {\n    return Effect.fail(\n      new SleepRequestInvalid({\n        code: \"ambiguous_deadline\",\n        message: `${tag} was called with both \"millis\" and \"until\". A sleep names one deadline: ` +\n          \"a relative duration, or an absolute epoch time.\"\n      })\n    )\n  }\n  if (payload.millis !== undefined) {\n    if (!Number.isFinite(payload.millis) || payload.millis < 0) {\n      return Effect.fail(\n        new SleepRequestInvalid({\n          code: \"invalid_deadline\",\n          message: `${tag} was called with millis ${payload.millis}. A deadline is a finite number of ` +\n            \"milliseconds that is not negative; the sleep would be over before it started, or never over at all.\"\n        })\n      )\n    }\n    const deadline = now + payload.millis\n    if (!Number.isFinite(deadline)) {\n      return Effect.fail(\n        new SleepRequestInvalid({\n          code: \"invalid_deadline\",\n          message: `${tag} was called with millis ${payload.millis} at current time ${now}, which produces ` +\n            `${deadline}. A deadline is a finite epoch time in milliseconds.`\n        })\n      )\n    }\n    return Math.ceil(deadline) > latestDeadline\n      ? Effect.fail(tooLate(`millis ${payload.millis} at current time ${now}`))\n      : Effect.succeed(deadline)\n  }\n  if (payload.until !== undefined) {\n    if (!Number.isFinite(payload.until)) {\n      return Effect.fail(\n        new SleepRequestInvalid({\n          code: \"invalid_deadline\",\n          message:\n            `${tag} was called with until ${payload.until}. A deadline is a finite epoch time in milliseconds; ` +\n            \"the sleep must end at a real point in time.\"\n        })\n      )\n    }\n    return Math.ceil(payload.until) > latestDeadline\n      ? Effect.fail(tooLate(`until ${payload.until}`))\n      : Effect.succeed(payload.until)\n  }\n  return Effect.fail(\n    new SleepRequestInvalid({\n      code: \"missing_deadline\",\n      message: `${tag} was called with neither \"millis\" nor \"until\", so there is no deadline to wait for.`\n    })\n  )\n}\n\n/**\n * The durable clock the dispatch currently executing arms.\n *\n * DECIDED: the name is derived from the ENGINE's\n * per-dispatch identity \u2014 the invocation key it already allocated \u2014 rather than\n * from the payload. A durable clock's deferred is addressed by (execution,\n * name), so the name has to be stable across replays of one node and distinct\n * between two identical nodes, and the invocation key is exactly that: it is\n * allocated on every dispatch including a replayed one, because the driver\n * addresses the recorded outcome by it. A payload-derived name has only the\n * first property \u2014 `sleep(1h); work(); sleep(1h)` would address ONE wake and\n * sleep once \u2014 and closing that with a discriminator in the payload would make\n * an author carry identity that a keyed plan node already has.\n *\n * DECIDED: a runtime that supplies no dispatch\n * identity is refused as a defect rather than falling back to the payload. The\n * fallback is unobservable in the one-wait case and silently collapses two\n * waits in every other, so it would trade a wiring error a host fixes once for\n * a run that quietly sleeps for half as long as it declared.\n *\n * @private\n */\nconst clockName: Effect.Effect<string> = Effect.gen(function*() {\n  const invocation = yield* Action.CurrentInvocationKey\n  if (invocation === undefined) {\n    return yield* Effect.die(\n      `${tag} ran under a runtime that supplies no Action.CurrentInvocationKey. ` +\n        \"A durable timer is named by the dispatch that armed it, so a runtime that does not \" +\n        \"identify the dispatch cannot arm one.\"\n    )\n  }\n  return `Sleep/${invocation}`\n})\n\n/**\n * The sleep implementation: arm the durable clock, park under `timer`, wake.\n *\n * Provide it beside the other action implementation layers a body calls, over\n * the {@link module:Implementations.layerImplementations} table they file\n * themselves in:\n *\n * ```ts\n * Layer.mergeAll(Sleep.layer, Interpreter.layer(Pipeline)).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> = action.toLayer((payload) =>\n  Effect.gen(function*() {\n    // Whole milliseconds, both of them. A durable deadline lands in an INTEGER\n    // column whose CHECK constraint refuses anything else\n    // (`flows_runs.waiting_wake_at_ms`, `flows_clock_deadlines.due_at_ms`), and\n    // `Clock.currentTimeMillis` is not integral under every clock: a test clock\n    // advanced by a fractional-millisecond sleep reports a fractional now, and\n    // a fractional `millis` or `until` in the payload does the same. The\n    // unrounded deadline reached the park write as a raw SQL constraint\n    // failure, which killed the drive and left the run `running` with nothing\n    // left to wake it. `now` floors, and the deadline ceils so a rounded sleep\n    // never ends before the instant it was asked to wait for.\n    const now = Math.floor(yield* Clock.currentTimeMillis)\n    const wakeAt = Math.ceil(yield* deadlineOf(payload, now))\n    const remaining = wakeAt - now\n    // DECIDED: a deadline that has already passed\n    // settles the node instead of parking it. A durable wait exists to survive\n    // the gap until a deadline, and a run that resumes after its own deadline\n    // has to make progress rather than park again on a timer that can only fire\n    // in the past.\n    if (remaining <= 0) return\n    const name = yield* clockName\n    // DECIDED: the park is declared rather than\n    // left to a driver's derivation, so a host with no clock table still parks\n    // under `timer`. A `millis` deadline is recomputed from the current clock,\n    // so a round re-driven before its timer fires re-declares a `wakeAt` later\n    // than the armed one; the wake itself is unaffected, because the durable\n    // clock row is keyed by name and keeps the deadline it was first armed\n    // with, and `wakeAt` is a sweeper hint rather than the wake.\n    yield* annotateWaiting({ reason: \"timer\", wakeAt })\n    yield* DurableClock.sleep({\n      name,\n      duration: Duration.millis(remaining),\n      // The wait is the point: a sleep called as a plan node parks the\n      // execution rather than holding a fiber open, so the in-memory shortcut\n      // is disabled instead of being left at its 60-second default.\n      inMemoryThreshold: Duration.zero\n    })\n  })\n)\n"],
+  "mappings": "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",
+  "names": []
+}