{"version":3,"file":"index.mjs","names":[],"sources":["../../src/policy/types.ts","../../src/policy/validate.ts","../../src/policy/retry-policy.ts","../../src/policy/plan.ts","../../src/policy/index.ts"],"sourcesContent":["import type { RetryPolicy } from \"./retry-policy.js\";\nimport type { ReleaseFn } from \"../core/lifecycle.js\";\nimport type { RunContext } from \"../execution/runtime.js\";\nimport type { TimeoutError, UnhandledException } from \"../errors.js\";\nimport type { HKT } from \"../hkt.js\";\nimport type { Op } from \"../index.js\";\nimport type { Plan, PlanRewriter } from \"../plan/model.js\";\nimport type { Result } from \"../result.js\";\nimport { unsafeCoerce } from \"@prodkit/shared/runtime\";\n\nconst OP_POLICY = Symbol(\"prodkit.op.policy\");\nconst OP_POLICY_INPUT = Symbol(\"prodkit.op.policy.input\");\n\nexport interface OpPolicyType extends HKT {\n  readonly [HKT.TYPE]: Op<\n    HKT.Param<this, 0>,\n    HKT.Param<this, 1>,\n    HKT.Param<this, 2>,\n    HKT.Param<this, 3>\n  >;\n}\n\nexport interface OpPolicyInput<T = unknown, E = unknown, A = unknown, M = unknown> {\n  readonly ok: T;\n  readonly err: E;\n  readonly args: A;\n  readonly meta: M;\n}\n\nexport interface OpPolicySource<T, E, A, M> {\n  wrap<TNext, ENext, MNext>(\n    transform: (plan: Plan<T, E, M>) => Plan<TNext, ENext, MNext>,\n  ): Op<TNext, ENext, A, MNext>;\n  rewrite<TNext, ENext, MNext>(rewriter: PlanRewriter): Op<TNext, ENext, A, MNext>;\n  around<TNext, ENext, MNext = M>(\n    run: (\n      next: (context: RunContext<readonly unknown[]>) => Promise<Result<T, E | UnhandledException>>,\n      context: RunContext<readonly unknown[]>,\n    ) => PromiseLike<Result<TNext, ENext | UnhandledException>>,\n  ): Op<TNext, ENext, A, MNext>;\n}\n\nexport interface OpPolicy<Input = unknown, F extends HKT = OpPolicyType> {\n  readonly [OP_POLICY]: F;\n  readonly [OP_POLICY_INPUT]?: (input: Input) => void;\n  apply<T, E, A, M>(source: OpPolicySource<T, E, A, M>): HKT.Apply<F, [T, E, A, M]>;\n}\n\n/**\n * Builds a custom policy value for `.with(Policy.define(...))`.\n * Use `source.wrap`, `source.rewrite`, or `source.around` inside `apply` to transform the wrapped op.\n */\nexport function define<Input, F extends HKT, Extras extends object = Record<never, never>>(\n  definition: Extras & {\n    apply<T, E, A, M>(source: OpPolicySource<T, E, A, M>): HKT.Apply<F, [T, E, A, M]>;\n  },\n): OpPolicy<Input, F> & Extras {\n  Object.defineProperty(definition, OP_POLICY, { value: undefined });\n  // SAFETY: define() returns a plain object without OpPolicy branding; apply satisfies OpPolicy at runtime.\n  return unsafeCoerce(definition);\n}\n\nexport interface TimeoutPolicyType extends HKT {\n  readonly [HKT.TYPE]: Op<\n    HKT.Param<this, 0>,\n    HKT.Param<this, 1> | TimeoutError,\n    HKT.Param<this, 2>,\n    HKT.Param<this, 3>\n  >;\n}\n\nexport type RetryPolicyAttachment = OpPolicy<unknown, OpPolicyType> & {\n  readonly policy: RetryPolicy | undefined;\n};\n\nexport type TimeoutPolicyAttachment = OpPolicy<unknown, TimeoutPolicyType> & {\n  readonly timeoutMs: number;\n};\n\nexport type CancelPolicyAttachment = OpPolicy<unknown, OpPolicyType> & {\n  readonly abortSignal: AbortSignal;\n};\n\nexport type ReleasePolicyAttachment<T> = OpPolicy<OpPolicyInput<T>, OpPolicyType> & {\n  readonly release: ReleaseFn<T>;\n};\n\nexport type BuiltInPolicy<T = unknown> =\n  | RetryPolicyAttachment\n  | TimeoutPolicyAttachment\n  | CancelPolicyAttachment\n  | ReleasePolicyAttachment<T>;\n","export function assertFiniteNumber(value: number, name: string): void {\n  if (!Number.isFinite(value)) {\n    throw new RangeError(`${name} must be a finite number`);\n  }\n}\n\nexport function assertNonNegativeNumber(value: number, name: string): void {\n  assertFiniteNumber(value, name);\n  if (value < 0) {\n    throw new RangeError(`${name} must be greater than or equal to 0`);\n  }\n}\n\nexport function assertPositiveNumber(value: number, name: string): void {\n  assertFiniteNumber(value, name);\n  if (value <= 0) {\n    throw new RangeError(`${name} must be greater than 0`);\n  }\n}\n\nexport function assertNonNegativeInteger(value: number, name: string): void {\n  assertFiniteNumber(value, name);\n  if (!Number.isInteger(value)) {\n    throw new TypeError(`${name} must be an integer`);\n  }\n  if (value < 0) {\n    throw new RangeError(`${name} must be greater than or equal to 0`);\n  }\n}\n\nexport function assertJitter(value: number): void {\n  assertFiniteNumber(value, \"jitter\");\n  if (value < 0 || value > 1) {\n    throw new RangeError(\"jitter must be between 0 and 1\");\n  }\n}\n\n/** Maximum delay accepted by typical `setTimeout` implementations (2^31 - 1 ms). */\nexport const MAX_TIMEOUT_MS = 2 ** 31 - 1;\n\n/** Validates `Policy.timeout(timeoutMs)` at run time. */\nexport function validateTimeoutMs(timeoutMs: number): void {\n  assertNonNegativeNumber(timeoutMs, \"timeoutMs\");\n  if (timeoutMs > MAX_TIMEOUT_MS) {\n    throw new RangeError(`timeoutMs must be less than or equal to ${MAX_TIMEOUT_MS}`);\n  }\n}\n","import {\n  assertJitter,\n  assertNonNegativeInteger,\n  assertNonNegativeNumber,\n  assertPositiveNumber,\n  assertFiniteNumber,\n} from \"./validate.js\";\n\n/**\n * Retry delay configuration for `RetryPolicy.delay`: fixed milliseconds or\n * `(retry, cause) => ms` before an upcoming retry (`retry` is 0-based). For built-in delay\n * functions, use the `Delay` helper namespace (`Delay.fixed`, `Delay.exponential`, and so on).\n */\nexport type Delay = number | ((retry: number, cause: unknown) => number);\n\n/** Configuration for `Policy.retry(policy)`. `retries` is the post-failure budget; `delay(retry, cause)` uses a 0-based retry index. */\nexport interface RetryPolicy {\n  /** How many times to retry after the first failure. */\n  retries?: number;\n  /** Whether to retry after a failure. Receives the root cause. */\n  when?: (cause: unknown) => boolean;\n  /** Delay before the next retry: fixed milliseconds or `(retry, cause) => ms`. */\n  delay?: Delay;\n}\n\n/** Options for `Delay.exponential(options)`. */\nexport interface ExponentialDelayOptions {\n  /** Initial delay in milliseconds. */\n  baseMs?: number;\n  /** Maximum delay in milliseconds. */\n  maxMs?: number;\n  /** Fraction of the computed delay to randomize, from `0` to `1`. */\n  jitter?: number;\n}\n\nexport interface NormalizedRetryPolicy {\n  readonly validate: () => void;\n  readonly maxAttempts: number;\n  readonly shouldRetry: (cause: unknown) => boolean;\n  readonly getDelay: (retry: number, cause: unknown) => number;\n}\n\nconst DELAY_VALIDATE: unique symbol = Symbol(\"prodkit.op.delay.validate\");\nconst DEFAULT_RETRIES = 2;\nconst DEFAULT_EXPONENTIAL_DELAY_OPTIONS = Object.freeze({\n  baseMs: 1_000,\n  maxMs: 30_000,\n  jitter: 1,\n}) satisfies Required<ExponentialDelayOptions>;\n\ntype ValidatedDelay = ((retry: number, cause: unknown) => number) & {\n  readonly [DELAY_VALIDATE]: () => void;\n};\n\nfunction withDelayValidation(\n  getDelay: (retry: number, cause: unknown) => number,\n  validate: () => void,\n): ValidatedDelay {\n  return Object.assign(getDelay, { [DELAY_VALIDATE]: validate });\n}\n\nfunction isValidatedDelay(\n  delay: (retry: number, cause: unknown) => number,\n): delay is ValidatedDelay {\n  return DELAY_VALIDATE in delay;\n}\n\nfunction validateDelay(delay: Delay): void {\n  if (typeof delay === \"number\") {\n    assertNonNegativeNumber(delay, \"delay\");\n    return;\n  }\n\n  if (isValidatedDelay(delay)) {\n    delay[DELAY_VALIDATE]();\n  }\n}\n\nconst fixed = (ms: number) =>\n  withDelayValidation(\n    () => ms,\n    () => assertNonNegativeNumber(ms, \"delay\"),\n  );\n\nconst exponential = (options?: ExponentialDelayOptions) => {\n  const normalized = {\n    baseMs: options?.baseMs ?? DEFAULT_EXPONENTIAL_DELAY_OPTIONS.baseMs,\n    maxMs: options?.maxMs ?? DEFAULT_EXPONENTIAL_DELAY_OPTIONS.maxMs,\n    jitter: options?.jitter ?? DEFAULT_EXPONENTIAL_DELAY_OPTIONS.jitter,\n  };\n  const validate = () => {\n    assertPositiveNumber(normalized.baseMs, \"baseMs\");\n    assertFiniteNumber(normalized.maxMs, \"maxMs\");\n    if (normalized.maxMs < normalized.baseMs) {\n      throw new RangeError(\"maxMs must be greater than or equal to baseMs\");\n    }\n    assertJitter(normalized.jitter);\n  };\n\n  return withDelayValidation((retry) => {\n    const exp = Math.min(normalized.baseMs * Math.pow(2, retry), normalized.maxMs);\n\n    if (normalized.jitter === 0) return exp;\n\n    const spread = exp * normalized.jitter;\n    return exp - spread + Math.random() * spread;\n  }, validate);\n};\n\n/** Built-in retry delay helpers for `RetryPolicy.delay`. See also the `Delay` type alias. */\nexport const Delay = Object.freeze({\n  /** Constant delay in milliseconds before each retry attempt. */\n  fixed,\n  /** Exponential backoff: `baseMs * 2 ** retry`, capped at `maxMs`. */\n  exponential,\n  /** Zero delay between retries. */\n  immediate: fixed(0),\n  /** Default exponential backoff used by `Policy.retry()` with no policy argument. */\n  defaultRetry: exponential(DEFAULT_EXPONENTIAL_DELAY_OPTIONS),\n});\n\nconst DEFAULT_RETRY_POLICY = Object.freeze({\n  retries: DEFAULT_RETRIES,\n  when: () => true,\n  delay: Delay.defaultRetry,\n}) satisfies Required<RetryPolicy>;\n\nfunction validateRetryPolicy(policy: Required<RetryPolicy>): void {\n  assertNonNegativeInteger(policy.retries, \"retries\");\n\n  if (typeof policy.when !== \"function\") {\n    throw new TypeError(\"when must be a function\");\n  }\n\n  if (typeof policy.delay !== \"number\" && typeof policy.delay !== \"function\") {\n    throw new TypeError(\"delay must be a number or function\");\n  }\n\n  validateDelay(policy.delay);\n}\n\nfunction normalizeDelay(delay: Delay): (retry: number, cause: unknown) => number {\n  if (typeof delay === \"number\") return () => delay;\n  return delay;\n}\n\nexport function normalizeRetryPolicy(policy?: RetryPolicy): NormalizedRetryPolicy {\n  if (policy === null) {\n    return {\n      validate: () => {\n        throw new TypeError(\"retry policy must not be null\");\n      },\n      maxAttempts: 1,\n      shouldRetry: () => false,\n      getDelay: () => 0,\n    };\n  }\n\n  const normalized = {\n    retries: policy?.retries ?? DEFAULT_RETRY_POLICY.retries,\n    when: policy?.when ?? DEFAULT_RETRY_POLICY.when,\n    delay: policy?.delay ?? DEFAULT_RETRY_POLICY.delay,\n  } satisfies Required<RetryPolicy>;\n\n  return {\n    validate: () => validateRetryPolicy(normalized),\n    maxAttempts: normalized.retries + 1,\n    shouldRetry: normalized.when,\n    getDelay: (retry, cause) => {\n      const delay = normalizeDelay(normalized.delay)(retry, cause);\n      assertNonNegativeNumber(delay, \"delay\");\n      return delay;\n    },\n  };\n}\n","import { TimeoutError, UnhandledException } from \"../errors.js\";\nimport { Result } from \"../result.js\";\nimport { sleepWithSignal } from \"@prodkit/shared/runtime\";\nimport { SuspendInstruction, RegisterExitFinalizerInstruction } from \"../execution/instructions.js\";\nimport { runWithBoundCancel, runWithTimeout } from \"../execution/child-run.js\";\nimport { Settlement } from \"../execution/settlement.js\";\nimport { normalizeRetryPolicy, type NormalizedRetryPolicy } from \"./retry-policy.js\";\nimport { validateTimeoutMs } from \"./validate.js\";\nimport type { ReleaseFn } from \"../core/lifecycle.js\";\nimport { createPlan, createUnaryPlan, type Plan, type PlanRewriter } from \"../plan/model.js\";\n\nexport function releasePlan<T, E, M>(source: Plan<T, E, M>, release: ReleaseFn<T>): Plan<T, E, M> {\n  return createUnaryPlan(\n    function* () {\n      const result: Result<T, E | UnhandledException> =\n        yield* Settlement.cooperative.suspendPlan(source);\n\n      if (result.isErr()) return yield* result;\n\n      yield new RegisterExitFinalizerInstruction(\n        () => Promise.resolve(release(result.value)).then(() => {}),\n        undefined,\n      );\n\n      return result.value;\n    },\n    source,\n    (inner) => releasePlan(inner, release),\n  );\n}\n\nfunction retryPlan<T, E, M>(\n  source: Plan<T, E, M>,\n  policy: NormalizedRetryPolicy = normalizeRetryPolicy(),\n): Plan<T, E, M> {\n  return createPlan(function* () {\n    try {\n      policy.validate();\n    } catch (cause) {\n      return yield* Result.err(new UnhandledException({ cause }));\n    }\n\n    let attempt = 1;\n\n    while (true) {\n      type AttemptStep = { result: Result<T, E | UnhandledException>; aborted: boolean };\n      const attemptStep: AttemptStep = yield* new SuspendInstruction((context) =>\n        Settlement.cooperative\n          .runPlan(source, context)\n          .then((result) => ({ result, aborted: context.signal.aborted })),\n      );\n\n      const result = attemptStep.result;\n\n      if (result.isOk()) return result.value;\n\n      const error = result.error;\n      const retryCause = UnhandledException.is(error) ? error.cause : error;\n\n      const canRetry =\n        !attemptStep.aborted && attempt < policy.maxAttempts && policy.shouldRetry(retryCause);\n\n      if (!canRetry) return yield* Result.err(error);\n\n      let delayMs: number;\n      try {\n        delayMs = policy.getDelay(attempt - 1, retryCause);\n      } catch (cause) {\n        return yield* Result.err(new UnhandledException({ cause }));\n      }\n\n      if (delayMs > 0) {\n        const delayAborted: boolean = yield* new SuspendInstruction((context) =>\n          abortableDelay(delayMs, context.signal).then(() => context.signal.aborted),\n        );\n\n        if (delayAborted) return yield* result;\n      }\n\n      attempt += 1;\n    }\n  });\n}\n\nfunction timeoutPlan<T, E, M>(\n  source: Plan<T, E, M>,\n  timeoutMs: number,\n): Plan<T, E | TimeoutError, M> {\n  return createPlan(function* () {\n    try {\n      validateTimeoutMs(timeoutMs);\n    } catch (cause) {\n      return yield* Result.err(new UnhandledException({ cause }));\n    }\n\n    const result: Result<T, E | UnhandledException | TimeoutError> =\n      yield* Settlement.abortOwned.suspend((outerContext) =>\n        runWithTimeout(\n          (context) => Settlement.interrupting.runPlan(source, context),\n          timeoutMs,\n          outerContext,\n        ),\n      );\n\n    if (result.isErr()) return yield* result;\n    return result.value;\n  });\n}\n\nfunction cancelPlan<T, E, M>(source: Plan<T, E, M>, abortSignal: AbortSignal): Plan<T, E, M> {\n  return createPlan(function* () {\n    const result: Result<T, E | UnhandledException> = yield* Settlement.abortOwned.suspend(\n      (outerContext) =>\n        runWithBoundCancel(\n          (context) => Settlement.interrupting.runPlan(source, context),\n          abortSignal,\n          outerContext,\n        ),\n    );\n\n    if (result.isErr()) return yield* result;\n    return result.value;\n  });\n}\n\nexport function retryRewriter(policy?: NormalizedRetryPolicy): PlanRewriter {\n  const retryPolicy = policy ?? normalizeRetryPolicy();\n  return { apply: (source) => retryPlan(source, retryPolicy) };\n}\n\nexport function timeoutRewriter(timeoutMs: number): PlanRewriter {\n  return { apply: (source) => timeoutPlan(source, timeoutMs) };\n}\n\nexport function cancelRewriter(abortSignal: AbortSignal): PlanRewriter {\n  return { apply: (source) => cancelPlan(source, abortSignal) };\n}\n\nasync function abortableDelay(ms: number, signal: AbortSignal): Promise<void> {\n  try {\n    return await sleepWithSignal(ms, signal);\n  } catch {\n    // intentionally ignored\n  }\n}\n","import { unsafeCoerce } from \"@prodkit/shared/runtime\";\nimport { define } from \"./types.js\";\nimport { cancelRewriter, releasePlan, retryRewriter, timeoutRewriter } from \"./plan.js\";\nimport { Delay, normalizeRetryPolicy } from \"./retry-policy.js\";\nimport type {\n  BuiltInPolicy,\n  CancelPolicyAttachment,\n  OpPolicy,\n  OpPolicyInput,\n  OpPolicySource,\n  OpPolicyType,\n  ReleasePolicyAttachment,\n  RetryPolicyAttachment,\n  TimeoutPolicyAttachment,\n  TimeoutPolicyType,\n} from \"./types.js\";\nimport type { ExponentialDelayOptions, RetryPolicy } from \"./retry-policy.js\";\nimport type { ReleaseFn } from \"../core/lifecycle.js\";\nimport type { HKT } from \"../hkt.js\";\n\nfunction retry(policy?: RetryPolicy): RetryPolicyAttachment {\n  const rewriter = retryRewriter(normalizeRetryPolicy(policy));\n  return define<unknown, OpPolicyType, { readonly policy: RetryPolicy | undefined }>({\n    policy,\n    apply: (source) => source.rewrite(rewriter),\n  });\n}\n\nfunction timeout(timeoutMs: number): TimeoutPolicyAttachment {\n  const rewriter = timeoutRewriter(timeoutMs);\n  return define<unknown, TimeoutPolicyType, { readonly timeoutMs: number }>({\n    timeoutMs,\n    apply: (source) => source.rewrite(rewriter),\n  });\n}\n\nfunction cancel(abortSignal: AbortSignal): CancelPolicyAttachment {\n  const rewriter = cancelRewriter(abortSignal);\n  return define<unknown, OpPolicyType, { readonly abortSignal: AbortSignal }>({\n    abortSignal,\n    apply: (source) => source.rewrite(rewriter),\n  });\n}\n\nfunction release<T>(releaseFn: ReleaseFn<T>): ReleasePolicyAttachment<T> {\n  // SAFETY: wrap cannot prove ReleaseFn<T> matches plan T; release is only called with result.value after success.\n  const releaseForPlan: ReleaseFn<unknown> = unsafeCoerce(releaseFn);\n  return define<OpPolicyInput<T>, OpPolicyType, { readonly release: ReleaseFn<T> }>({\n    release: releaseFn,\n    apply: (source) => source.wrap((plan) => releasePlan(plan, releaseForPlan)),\n  });\n}\n\n/** Built-in and custom policy constructors for `.with(...)`. */\nexport const Policy = {\n  /** Creates a retry policy attachment for `.with(Policy.retry(...))`. Uses default `retries: 2` when omitted. */\n  retry,\n  /** Creates a timeout policy attachment for `.with(Policy.timeout(...))`. */\n  timeout,\n  /** Creates a cancellation policy attachment for `.with(Policy.cancel(...))`. */\n  cancel,\n  /** Creates a release policy attachment for `.with(Policy.release(...))`. */\n  release,\n  /** Builds a custom policy value for `.with(Policy.define(...))`. */\n  define,\n} as const;\n\n/** Policy attachment for `.with(...)`. Custom factories return `Policy<Input, YourPolicyHKT>`. */\nexport type Policy<Input = unknown, F extends HKT = OpPolicyType> = OpPolicy<Input, F>;\n\n/** Nested type helpers for custom `Policy.define(...)` authors. */\nexport namespace Policy {\n  /** Contravariant input phantom; enables contextual typing for `Policy.release((value) => ...)`. */\n  export type Input<T = unknown, E = unknown, A = unknown, M = unknown> = OpPolicyInput<T, E, A, M>;\n  /** Plan surface passed to `apply(source)` inside `Policy.define(...)`. */\n  export type Source<T, E, A, M> = OpPolicySource<T, E, A, M>;\n  /** Identity policy HKT; built-in policies extend this or `TimeoutPolicyType`. */\n  export type Type = OpPolicyType;\n  /** Union of built-in policy attachment types. */\n  export type BuiltIn<T = unknown> = BuiltInPolicy<T>;\n}\n\nexport { Delay };\nexport type {\n  CancelPolicyAttachment,\n  ExponentialDelayOptions,\n  ReleasePolicyAttachment,\n  RetryPolicy,\n  RetryPolicyAttachment,\n  TimeoutPolicyAttachment,\n  TimeoutPolicyType,\n};\n"],"mappings":"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"}