@zap-studio/retry 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,4 +1,7 @@
-import { RetryError } from "./error.mjs";
+import { RetryError } from "./errors.mjs";
+import { runResultMode } from "./result-mode.mjs";
+import { defaultSleep } from "./sleep.mjs";
+import { runThrowMode } from "./throw-mode.mjs";
 //#region src/index.ts
 /**
 * Retry runner base class and shared orchestration implementation.
@@ -40,7 +43,8 @@ var BaseRetryPolicy = class {
 	* @throws Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`
 	*   function. When `throwOnExhausted` is `false`, exhaustion itself is returned
 	*   as `{ ok: false }` instead of thrown.
-	*   Abort errors are also returned as `{ ok: false }` in non-throw mode.
+	*   Cancellation is returned as `{ ok: false, error: AbortError }` in non-throw
+	*   mode (not wrapped in `RetryError`).
 	*
 	* @example
 	* const result = await policy.run(doWork, { throwOnExhausted: false });
@@ -49,178 +53,11 @@ var BaseRetryPolicy = class {
 	async run(execute, options = {}) {
 		const sleep = options.sleep ?? defaultSleep;
 		const signal = options.signal;
-		if (options.throwOnExhausted === false) return this.runResultMode(execute, sleep, signal);
-		return this.runThrowMode(execute, sleep, signal);
-	}
-	/**
-	* Runs retry orchestration in throwing mode.
-	*
-	* This path is selected when `throwOnExhausted` is not `false`.
-	*
-	* @param execute - Async function to execute per attempt.
-	* @param sleep - Delay function used between retry attempts.
-	* @returns The successful execution value.
-	* @throws {RetryError} Terminal error returned by `onExhausted(...)`.
-	* @throws Any error thrown by `next`, by `onExhausted`, or by `sleep`.
-	*/
-	async runThrowMode(execute, sleep, signal) {
-		let attempt = 1;
-		while (true) {
-			throwIfAborted(signal);
-			try {
-				return await execute(attempt);
-			} catch (error) {
-				throwIfAborted(signal);
-				const typedError = error;
-				const decision = this.next({
-					attempt,
-					error: typedError
-				});
-				if (!decision.shouldRetry) throw this.onExhausted({
-					attempts: attempt,
-					error: typedError
-				});
-				if (decision.delayMs > 0) if (signal) await sleepWithAbortSignal(sleep, decision.delayMs, signal);
-				else await sleep(decision.delayMs);
-				attempt += 1;
-			}
-		}
-	}
-	/**
-	* Runs retry orchestration in non-throw mode.
-	*
-	* This path is selected when `throwOnExhausted` is `false`.
-	*
-	* @param execute - Async function to execute per attempt.
-	* @param sleep - Delay function used between retry attempts.
-	* @returns A discriminated result union containing success value or terminal error.
-	* @throws Any error thrown by `next`, by `onExhausted`, or by `sleep`.
-	*/
-	async runResultMode(execute, sleep, signal) {
-		let attempt = 1;
-		while (true) {
-			if (signal?.aborted) {
-				const attempts = Math.max(0, attempt - 1);
-				return {
-					ok: false,
-					error: toRetryError(signal.reason, attempts),
-					attempts
-				};
-			}
-			try {
-				return {
-					ok: true,
-					value: await execute(attempt)
-				};
-			} catch (error) {
-				if (signal?.aborted) {
-					const attempts = Math.max(0, attempt - 1);
-					return {
-						ok: false,
-						error: toRetryError(signal.reason, attempts),
-						attempts
-					};
-				}
-				const typedError = error;
-				const decision = this.next({
-					attempt,
-					error: typedError
-				});
-				if (!decision.shouldRetry) return {
-					ok: false,
-					error: this.onExhausted({
-						attempts: attempt,
-						error: typedError
-					}),
-					attempts: attempt
-				};
-				if (decision.delayMs > 0) if (signal) try {
-					await sleepWithAbortSignal(sleep, decision.delayMs, signal);
-				} catch (error) {
-					if (signal.aborted) return {
-						ok: false,
-						error: toRetryError(signal.reason, attempt),
-						attempts: attempt
-					};
-					throw error;
-				}
-				else await sleep(decision.delayMs);
-				attempt += 1;
-			}
-		}
+		if (options.throwOnExhausted === false) return runResultMode(this, execute, sleep, signal);
+		return runThrowMode(this, execute, sleep, signal);
 	}
 };
-/**
-* Default delay implementation used by `run(...)` when no custom sleep function is provided.
-*
-* Returns immediately when `delayMs` is non-positive.
-*/
-async function defaultSleep(delayMs) {
-	if (delayMs <= 0) return;
-	await new Promise((resolve) => setTimeout(resolve, delayMs));
-}
-/**
-* Throws an abort error when the provided signal is already aborted.
-*
-* @param signal - Optional cancellation signal.
-* @throws {Error} Abort reason converted to an `Error`.
-*/
-function throwIfAborted(signal) {
-	if (!signal?.aborted) return;
-	throw toAbortError(signal.reason);
-}
-/**
-* Normalizes an abort reason value into an `Error` instance.
-*
-* @param reason - Abort reason from `AbortSignal.reason`.
-* @returns Normalized error instance.
-*/
-function toAbortError(reason) {
-	if (reason instanceof Error) return reason;
-	if (typeof reason === "string" && reason.length > 0) return new Error(reason);
-	if (reason === void 0) return /* @__PURE__ */ new Error("Retry aborted.");
-	try {
-		return /* @__PURE__ */ new Error(`Retry aborted: ${JSON.stringify(reason)}`);
-	} catch {
-		return /* @__PURE__ */ new Error("Retry aborted.");
-	}
-}
-/**
-* Converts an abort reason into a `RetryError` for non-throw runner mode.
-*
-* @param reason - Abort reason from `AbortSignal.reason`.
-* @returns Retry terminal error value.
-*/
-function toRetryError(reason, attempts) {
-	const abortError = toAbortError(reason);
-	return new RetryError(abortError.message, {
-		attempts,
-		lastError: abortError
-	});
-}
-/**
-* Awaits delay sleep while also observing cancellation via `AbortSignal`.
-*
-* @param sleep - Delay function.
-* @param delayMs - Delay duration in milliseconds.
-* @param signal - Cancellation signal.
-* @throws {Error} Abort reason converted to an `Error` when canceled.
-*/
-async function sleepWithAbortSignal(sleep, delayMs, signal) {
-	if (signal.aborted) throw toAbortError(signal.reason);
-	let onAbort;
-	try {
-		await Promise.race([sleep(delayMs), new Promise((_, reject) => {
-			onAbort = () => {
-				reject(toAbortError(signal.reason));
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-		})]);
-	} finally {
-		if (onAbort) signal.removeEventListener("abort", onAbort);
-	}
-}
 //#endregion
-export { BaseRetryPolicy, defaultSleep };
+export { BaseRetryPolicy };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Retry runner base class and shared orchestration implementation.\n *\n * @module @zap-studio/retry\n */\n\nimport { RetryError } from \"./error.js\";\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryExhaustedInput,\n  RetryPolicy,\n  RetryRunOptions,\n  RetryRunResult,\n} from \"./types.js\";\n\n/**\n * Base class for implementing retry policies and running retry orchestration.\n *\n * Extend this class and implement {@link BaseRetryPolicy.next} to define retry\n * behavior, then call {@link BaseRetryPolicy.run} to execute operations with that\n * policy.\n */\nexport abstract class BaseRetryPolicy<TError = unknown, TData = unknown> implements RetryPolicy<\n  TError,\n  TData\n> {\n  /**\n   * Returns the retry decision for a failed attempt.\n   *\n   * @param input - Attempt context used to compute retry behavior.\n   * @throws Any error thrown by a concrete retry policy implementation.\n   */\n  public abstract next(input: RetryDecisionInput<TError, TData>): RetryDecision;\n\n  /**\n   * Builds the terminal error thrown or returned when retries are exhausted.\n   *\n   * Override this when you need custom terminal error types.\n   *\n   * @param input - Exhaustion context.\n   * @returns `RetryError` by default.\n   * @throws Any error thrown by an overriding policy implementation.\n   */\n  public onExhausted(input: RetryExhaustedInput<TError, TData>): RetryError {\n    return new RetryError(\"Retry policy exhausted all attempts.\", {\n      attempts: input.attempts,\n      lastError: input.error,\n      lastData: input.data,\n    });\n  }\n\n  /**\n   * Runs retry orchestration in non-throw mode.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param options - Runner settings with `throwOnExhausted: false`.\n   * @returns A discriminated result union containing success value or terminal error.\n   * @throws Any error thrown by `next`, `onExhausted`, or a custom `sleep`.\n   */\n  public async run<T>(\n    execute: (attempt: number) => Promise<T>,\n    options: RetryRunOptions & { throwOnExhausted: false },\n  ): Promise<RetryRunResult<T>>;\n\n  /**\n   * Runs retry orchestration and throws terminal error on exhaustion.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param options - Optional runner settings.\n   * @returns The successful execution value.\n   * @throws {RetryError} When retries are exhausted and `onExhausted` returns the\n   *   terminal retry error. The default implementation returns `RetryError` with the last\n   *   execution failure available on `RetryError.lastError`.\n   * @throws {Error} When `options.signal` is already aborted or aborts while retrying.\n   * @throws Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`\n   *   function.\n   */\n  public async run<T>(\n    execute: (attempt: number) => Promise<T>,\n    options?: RetryRunOptions & { throwOnExhausted?: true },\n  ): Promise<T>;\n\n  /**\n   * Runs retry orchestration in non-throw mode.\n   *\n   * When `throwOnExhausted` is `false`, returns a discriminated result union.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param options - Runner settings.\n   * @returns Success value or terminal result object based on option mode.\n   * @throws Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`\n   *   function. When `throwOnExhausted` is `false`, exhaustion itself is returned\n   *   as `{ ok: false }` instead of thrown.\n   *   Abort errors are also returned as `{ ok: false }` in non-throw mode.\n   *\n   * @example\n   * const result = await policy.run(doWork, { throwOnExhausted: false });\n   * if (!result.ok) console.error(result.error);\n   */\n  public async run<T>(\n    execute: (attempt: number) => Promise<T>,\n    options: RetryRunOptions = {},\n  ): Promise<T | RetryRunResult<T>> {\n    const sleep = options.sleep ?? defaultSleep;\n    const signal = options.signal;\n    if (options.throwOnExhausted === false) {\n      return this.runResultMode(execute, sleep, signal);\n    }\n\n    return this.runThrowMode(execute, sleep, signal);\n  }\n\n  /**\n   * Runs retry orchestration in throwing mode.\n   *\n   * This path is selected when `throwOnExhausted` is not `false`.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param sleep - Delay function used between retry attempts.\n   * @returns The successful execution value.\n   * @throws {RetryError} Terminal error returned by `onExhausted(...)`.\n   * @throws Any error thrown by `next`, by `onExhausted`, or by `sleep`.\n   */\n  private async runThrowMode<T>(\n    execute: (attempt: number) => Promise<T>,\n    sleep: (delayMs: number) => Promise<void>,\n    signal?: AbortSignal,\n  ): Promise<T> {\n    let attempt = 1;\n\n    while (true) {\n      throwIfAborted(signal);\n\n      try {\n        return await execute(attempt);\n      } catch (error) {\n        throwIfAborted(signal);\n\n        const typedError = error as TError;\n        const decision = this.next({\n          attempt,\n          error: typedError,\n        });\n\n        if (!decision.shouldRetry) {\n          throw this.onExhausted({\n            attempts: attempt,\n            error: typedError,\n          });\n        }\n\n        if (decision.delayMs > 0) {\n          if (signal) {\n            await sleepWithAbortSignal(sleep, decision.delayMs, signal);\n          } else {\n            await sleep(decision.delayMs);\n          }\n        }\n\n        attempt += 1;\n      }\n    }\n  }\n\n  /**\n   * Runs retry orchestration in non-throw mode.\n   *\n   * This path is selected when `throwOnExhausted` is `false`.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param sleep - Delay function used between retry attempts.\n   * @returns A discriminated result union containing success value or terminal error.\n   * @throws Any error thrown by `next`, by `onExhausted`, or by `sleep`.\n   */\n  private async runResultMode<T>(\n    execute: (attempt: number) => Promise<T>,\n    sleep: (delayMs: number) => Promise<void>,\n    signal?: AbortSignal,\n  ): Promise<RetryRunResult<T>> {\n    let attempt = 1;\n\n    while (true) {\n      if (signal?.aborted) {\n        const attempts = Math.max(0, attempt - 1);\n        return {\n          ok: false,\n          error: toRetryError(signal.reason, attempts),\n          attempts,\n        };\n      }\n\n      try {\n        const value = await execute(attempt);\n        return { ok: true, value };\n      } catch (error) {\n        if (signal?.aborted) {\n          const attempts = Math.max(0, attempt - 1);\n          return {\n            ok: false,\n            error: toRetryError(signal.reason, attempts),\n            attempts,\n          };\n        }\n\n        const typedError = error as TError;\n        const decision = this.next({\n          attempt,\n          error: typedError,\n        });\n\n        if (!decision.shouldRetry) {\n          const terminalError = this.onExhausted({\n            attempts: attempt,\n            error: typedError,\n          });\n\n          return {\n            ok: false,\n            error: terminalError,\n            attempts: attempt,\n          };\n        }\n\n        if (decision.delayMs > 0) {\n          if (signal) {\n            try {\n              await sleepWithAbortSignal(sleep, decision.delayMs, signal);\n            } catch (error) {\n              if (signal.aborted) {\n                return {\n                  ok: false,\n                  error: toRetryError(signal.reason, attempt),\n                  attempts: attempt,\n                };\n              }\n              throw error;\n            }\n          } else {\n            await sleep(decision.delayMs);\n          }\n        }\n\n        attempt += 1;\n      }\n    }\n  }\n}\n\n/**\n * Default delay implementation used by `run(...)` when no custom sleep function is provided.\n *\n * Returns immediately when `delayMs` is non-positive.\n */\nexport async function defaultSleep(delayMs: number): Promise<void> {\n  if (delayMs <= 0) {\n    return;\n  }\n\n  await new Promise((resolve) => setTimeout(resolve, delayMs));\n}\n\n/**\n * Throws an abort error when the provided signal is already aborted.\n *\n * @param signal - Optional cancellation signal.\n * @throws {Error} Abort reason converted to an `Error`.\n */\nfunction throwIfAborted(signal?: AbortSignal): void {\n  if (!signal?.aborted) {\n    return;\n  }\n\n  throw toAbortError(signal.reason);\n}\n\n/**\n * Normalizes an abort reason value into an `Error` instance.\n *\n * @param reason - Abort reason from `AbortSignal.reason`.\n * @returns Normalized error instance.\n */\nfunction toAbortError(reason: unknown): Error {\n  if (reason instanceof Error) {\n    return reason;\n  }\n\n  if (typeof reason === \"string\" && reason.length > 0) {\n    return new Error(reason);\n  }\n\n  if (reason === undefined) {\n    return new Error(\"Retry aborted.\");\n  }\n\n  try {\n    return new Error(`Retry aborted: ${JSON.stringify(reason)}`);\n  } catch {\n    return new Error(\"Retry aborted.\");\n  }\n}\n\n/**\n * Converts an abort reason into a `RetryError` for non-throw runner mode.\n *\n * @param reason - Abort reason from `AbortSignal.reason`.\n * @returns Retry terminal error value.\n */\nfunction toRetryError(reason: unknown, attempts: number): RetryError {\n  const abortError = toAbortError(reason);\n  return new RetryError(abortError.message, {\n    attempts,\n    lastError: abortError,\n  });\n}\n\n/**\n * Awaits delay sleep while also observing cancellation via `AbortSignal`.\n *\n * @param sleep - Delay function.\n * @param delayMs - Delay duration in milliseconds.\n * @param signal - Cancellation signal.\n * @throws {Error} Abort reason converted to an `Error` when canceled.\n */\nasync function sleepWithAbortSignal(\n  sleep: (delayMs: number) => Promise<void>,\n  delayMs: number,\n  signal: AbortSignal,\n): Promise<void> {\n  if (signal.aborted) {\n    throw toAbortError(signal.reason);\n  }\n\n  let onAbort: (() => void) | undefined;\n\n  try {\n    await Promise.race([\n      sleep(delayMs),\n      new Promise<never>((_, reject) => {\n        onAbort = (): void => {\n          reject(toAbortError(signal.reason));\n        };\n\n        signal.addEventListener(\"abort\", onAbort, { once: true });\n      }),\n    ]);\n  } finally {\n    if (onAbort) {\n      signal.removeEventListener(\"abort\", onAbort);\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Retry runner base class and shared orchestration implementation.\n *\n * @module @zap-studio/retry\n */\n\nimport { RetryError } from \"./errors.js\";\nimport { runResultMode } from \"./result-mode.js\";\nimport { defaultSleep } from \"./sleep.js\";\nimport { runThrowMode } from \"./throw-mode.js\";\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryExhaustedInput,\n  RetryPolicy,\n  RetryRunOptions,\n  RetryRunResult,\n} from \"./types.js\";\n\n/**\n * Base class for implementing retry policies and running retry orchestration.\n *\n * Extend this class and implement {@link BaseRetryPolicy.next} to define retry\n * behavior, then call {@link BaseRetryPolicy.run} to execute operations with that\n * policy.\n */\nexport abstract class BaseRetryPolicy<TError = unknown, TData = unknown> implements RetryPolicy<\n  TError,\n  TData\n> {\n  /**\n   * Returns the retry decision for a failed attempt.\n   *\n   * @param input - Attempt context used to compute retry behavior.\n   * @throws Any error thrown by a concrete retry policy implementation.\n   */\n  public abstract next(input: RetryDecisionInput<TError, TData>): RetryDecision;\n\n  /**\n   * Builds the terminal error thrown or returned when retries are exhausted.\n   *\n   * Override this when you need custom terminal error types.\n   *\n   * @param input - Exhaustion context.\n   * @returns `RetryError` by default.\n   * @throws Any error thrown by an overriding policy implementation.\n   */\n  public onExhausted(input: RetryExhaustedInput<TError, TData>): RetryError {\n    return new RetryError(\"Retry policy exhausted all attempts.\", {\n      attempts: input.attempts,\n      lastError: input.error,\n      lastData: input.data,\n    });\n  }\n\n  /**\n   * Runs retry orchestration in non-throw mode.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param options - Runner settings with `throwOnExhausted: false`.\n   * @returns A discriminated result union containing success value or terminal error.\n   * @throws Any error thrown by `next`, `onExhausted`, or a custom `sleep`.\n   */\n  public async run<T>(\n    execute: (attempt: number) => Promise<T>,\n    options: RetryRunOptions & { throwOnExhausted: false },\n  ): Promise<RetryRunResult<T>>;\n\n  /**\n   * Runs retry orchestration and throws terminal error on exhaustion.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param options - Optional runner settings.\n   * @returns The successful execution value.\n   * @throws {RetryError} When retries are exhausted and `onExhausted` returns the\n   *   terminal retry error. The default implementation returns `RetryError` with the last\n   *   execution failure available on `RetryError.lastError`.\n   * @throws {AbortError} When `options.signal` is already aborted or aborts while retrying.\n   * @throws Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`\n   *   function.\n   */\n  public async run<T>(\n    execute: (attempt: number) => Promise<T>,\n    options?: RetryRunOptions & { throwOnExhausted?: true },\n  ): Promise<T>;\n\n  /**\n   * Runs retry orchestration in non-throw mode.\n   *\n   * When `throwOnExhausted` is `false`, returns a discriminated result union.\n   *\n   * @param execute - Async function to execute per attempt.\n   * @param options - Runner settings.\n   * @returns Success value or terminal result object based on option mode.\n   * @throws Any error thrown by `next`, by `onExhausted`, or by a custom `sleep`\n   *   function. When `throwOnExhausted` is `false`, exhaustion itself is returned\n   *   as `{ ok: false }` instead of thrown.\n   *   Cancellation is returned as `{ ok: false, error: AbortError }` in non-throw\n   *   mode (not wrapped in `RetryError`).\n   *\n   * @example\n   * const result = await policy.run(doWork, { throwOnExhausted: false });\n   * if (!result.ok) console.error(result.error);\n   */\n  public async run<T>(\n    execute: (attempt: number) => Promise<T>,\n    options: RetryRunOptions = {},\n  ): Promise<T | RetryRunResult<T>> {\n    const sleep = options.sleep ?? defaultSleep;\n    const signal = options.signal;\n    if (options.throwOnExhausted === false) {\n      return runResultMode(this, execute, sleep, signal);\n    }\n\n    return runThrowMode(this, execute, sleep, signal);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,IAAsB,kBAAtB,MAGE;;;;;;;;;;CAkBA,YAAmB,OAAuD;AACxE,SAAO,IAAI,WAAW,wCAAwC;GAC5D,UAAU,MAAM;GAChB,WAAW,MAAM;GACjB,UAAU,MAAM;GACjB,CAAC;;;;;;;;;;;;;;;;;;;;CAoDJ,MAAa,IACX,SACA,UAA2B,EAAE,EACG;EAChC,MAAM,QAAQ,QAAQ,SAAS;EAC/B,MAAM,SAAS,QAAQ;AACvB,MAAI,QAAQ,qBAAqB,MAC/B,QAAO,cAAc,MAAM,SAAS,OAAO,OAAO;AAGpD,SAAO,aAAa,MAAM,SAAS,OAAO,OAAO"}

package/dist/result-mode.d.mts

@@ -0,0 +1,24 @@
+import { r as RetryError } from "./errors-fWo_KyVO.mjs";
+import { RetryDecision, RetryDecisionInput, RetryExhaustedInput, RetryRunResult } from "./types.mjs";
+
+//#region src/result-mode.d.ts
+/**
+* Runs the non-throw retry loop, returning
+* `RetryRunResult`.
+*
+* @param policy - Object providing `next` and `onExhausted` (same contract as
+*   `BaseRetryPolicy`).
+* @param execute - Async work callback per attempt.
+* @param sleep - Delay function between retries.
+* @param signal - Optional cancel signal.
+* @returns Terminal success or failure object.
+* @throws Any error thrown by `next`, `onExhausted`, or a non-abort `sleep`
+*   failure.
+*/
+declare function runResultMode<T, TError, TData>(policy: {
+  next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;
+  onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;
+}, execute: (attempt: number) => Promise<T>, sleep: (delayMs: number) => Promise<void>, signal?: AbortSignal): Promise<RetryRunResult<T>>;
+//#endregion
+export { runResultMode };
+//# sourceMappingURL=result-mode.d.mts.map

package/dist/result-mode.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-mode.d.mts","names":[],"sources":["../src/result-mode.ts"],"mappings":";;;;;;AA6BA;;;;;;;;;;;iBAAsB,aAAA,kBAAA,CACpB,MAAA;EACE,IAAA,GAAO,KAAA,EAAO,kBAAA,CAAmB,MAAA,EAAQ,KAAA,MAAW,aAAA;EACpD,WAAA,GAAc,KAAA,EAAO,mBAAA,CAAoB,MAAA,EAAQ,KAAA,MAAW,UAAA;AAAA,GAE9D,OAAA,GAAU,OAAA,aAAoB,OAAA,CAAQ,CAAA,GACtC,KAAA,GAAQ,OAAA,aAAoB,OAAA,QAC5B,MAAA,GAAS,WAAA,GACR,OAAA,CAAQ,cAAA,CAAe,CAAA"}

package/dist/result-mode.mjs

@@ -0,0 +1,145 @@
+import { sleepWithAbortSignal, toAbortError } from "./abort.mjs";
+//#region src/result-mode.ts
+/**
+* Result-mode execution path for `BaseRetryPolicy.run` when
+* `throwOnExhausted: false` is set.
+*
+* @module @zap-studio/retry/result-mode
+*/
+/**
+* Runs the non-throw retry loop, returning
+* `RetryRunResult`.
+*
+* @param policy - Object providing `next` and `onExhausted` (same contract as
+*   `BaseRetryPolicy`).
+* @param execute - Async work callback per attempt.
+* @param sleep - Delay function between retries.
+* @param signal - Optional cancel signal.
+* @returns Terminal success or failure object.
+* @throws Any error thrown by `next`, `onExhausted`, or a non-abort `sleep`
+*   failure.
+*/
+async function runResultMode(policy, execute, sleep, signal) {
+	let attempt = 1;
+	while (true) {
+		const earlyAbortResult = abortResult(signal, Math.max(0, attempt - 1));
+		if (earlyAbortResult) return earlyAbortResult;
+		const execution = await runAttempt(execute, attempt);
+		if (execution.ok) return {
+			ok: true,
+			value: execution.value
+		};
+		const failure = await handleFailure(policy, {
+			attempt,
+			error: execution.error,
+			sleep,
+			signal
+		});
+		if (failure) return failure;
+		attempt += 1;
+	}
+}
+/**
+* Runs one `execute(attempt)` call and returns either a success value or a
+* captured error without rethrowing.
+*
+* @param execute - User work callback.
+* @param attempt - One-based attempt number passed to `execute`.
+* @returns A tagged success with `value` or a tagged failure with `error`.
+*/
+async function runAttempt(execute, attempt) {
+	try {
+		return {
+			ok: true,
+			value: await execute(attempt)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
+}
+/**
+* After a failed attempt, applies abort rules, `next`, optional delay, and
+* either returns a terminal `RetryRunResult` or `undefined` to continue.
+*
+* @param policy - Retry policy hooks (`next`, `onExhausted`) matching
+*   `BaseRetryPolicy`.
+* @param params - Failure context for the current attempt.
+* @param params.attempt - Current attempt number.
+* @param params.error - Error thrown by the attempt.
+* @param params.sleep - Delay function between retries.
+* @param params.signal - Optional abort signal.
+* @returns Terminal non-throw result if the loop should stop, otherwise
+*   `undefined` to schedule another attempt.
+* @throws Any error thrown by `next`, `onExhausted`, or a custom `sleep` when
+*   the error is not an abort.
+*/
+async function handleFailure(policy, params) {
+	const { attempt, error, sleep, signal } = params;
+	const postExecuteAbortResult = abortResult(signal, attempt);
+	if (postExecuteAbortResult) return postExecuteAbortResult;
+	const decision = policy.next({
+		attempt,
+		error
+	});
+	if (!decision.shouldRetry) return {
+		ok: false,
+		error: policy.onExhausted({
+			attempts: attempt,
+			error
+		}),
+		attempts: attempt
+	};
+	if (decision.delayMs > 0) {
+		const sleepAbortResult = await waitForDelay(sleep, decision.delayMs, signal, attempt);
+		if (sleepAbortResult) return sleepAbortResult;
+	}
+}
+/**
+* When `signal` is already aborted, builds the terminal `{ ok: false }` object
+* with a normalized `AbortError` on `error` (not wrapped in `RetryError`).
+*
+* @param signal - Optional abort signal; only acts when `aborted` is set.
+* @param attempts - Number of finished attempts to report in the result.
+* @returns Failure result or `undefined` if not aborted.
+*/
+function abortResult(signal, attempts) {
+	if (!signal?.aborted) return;
+	return {
+		ok: false,
+		error: toAbortError(signal.reason),
+		attempts
+	};
+}
+/**
+* Awaits inter-attempt delay in result mode, mapping an abort during wait to
+* a terminal result instead of throwing when `throwOnExhausted` is false.
+*
+* @param sleep - Custom or default sleep implementation.
+* @param delayMs - Milliseconds to wait.
+* @param signal - If set, `sleep` is raced with the abort signal.
+* @param attempts - Attempt count to attach if the wait ends in abort.
+* @returns A terminal result when canceled during the wait, otherwise
+*   `undefined`.
+* @throws The underlying `sleep` rejection when it is not an abort.
+*/
+async function waitForDelay(sleep, delayMs, signal, attempts) {
+	if (!signal) {
+		await sleep(delayMs);
+		return;
+	}
+	try {
+		await sleepWithAbortSignal(sleep, delayMs, signal);
+		return;
+	} catch (error) {
+		const aborted = abortResult(signal, attempts);
+		if (aborted) return aborted;
+		throw error;
+	}
+}
+//#endregion
+export { runResultMode };
+
+//# sourceMappingURL=result-mode.mjs.map

package/dist/result-mode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-mode.mjs","names":[],"sources":["../src/result-mode.ts"],"sourcesContent":["/**\n * Result-mode execution path for `BaseRetryPolicy.run` when\n * `throwOnExhausted: false` is set.\n *\n * @module @zap-studio/retry/result-mode\n */\n\nimport { sleepWithAbortSignal, toAbortError } from \"./abort.js\";\nimport type { RetryError } from \"./errors.js\";\nimport type {\n  RetryDecision,\n  RetryDecisionInput,\n  RetryExhaustedInput,\n  RetryRunResult,\n} from \"./types.js\";\n\n/**\n * Runs the non-throw retry loop, returning\n * `RetryRunResult`.\n *\n * @param policy - Object providing `next` and `onExhausted` (same contract as\n *   `BaseRetryPolicy`).\n * @param execute - Async work callback per attempt.\n * @param sleep - Delay function between retries.\n * @param signal - Optional cancel signal.\n * @returns Terminal success or failure object.\n * @throws Any error thrown by `next`, `onExhausted`, or a non-abort `sleep`\n *   failure.\n */\nexport async function runResultMode<T, TError, TData>(\n  policy: {\n    next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;\n    onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;\n  },\n  execute: (attempt: number) => Promise<T>,\n  sleep: (delayMs: number) => Promise<void>,\n  signal?: AbortSignal,\n): Promise<RetryRunResult<T>> {\n  let attempt = 1;\n\n  while (true) {\n    const earlyAbortResult = abortResult(signal, Math.max(0, attempt - 1));\n    if (earlyAbortResult) return earlyAbortResult;\n\n    const execution = await runAttempt(execute, attempt);\n    if (execution.ok) {\n      return { ok: true, value: execution.value };\n    }\n\n    const failure = await handleFailure(policy, {\n      attempt,\n      error: execution.error as TError,\n      sleep,\n      signal,\n    });\n    if (failure) return failure;\n\n    attempt += 1;\n  }\n}\n\n/**\n * Runs one `execute(attempt)` call and returns either a success value or a\n * captured error without rethrowing.\n *\n * @param execute - User work callback.\n * @param attempt - One-based attempt number passed to `execute`.\n * @returns A tagged success with `value` or a tagged failure with `error`.\n */\nasync function runAttempt<T>(\n  execute: (attempt: number) => Promise<T>,\n  attempt: number,\n): Promise<{ ok: true; value: T } | { ok: false; error: unknown }> {\n  try {\n    return {\n      ok: true,\n      value: await execute(attempt),\n    };\n  } catch (error) {\n    return {\n      ok: false,\n      error,\n    };\n  }\n}\n\n/**\n * After a failed attempt, applies abort rules, `next`, optional delay, and\n * either returns a terminal `RetryRunResult` or `undefined` to continue.\n *\n * @param policy - Retry policy hooks (`next`, `onExhausted`) matching\n *   `BaseRetryPolicy`.\n * @param params - Failure context for the current attempt.\n * @param params.attempt - Current attempt number.\n * @param params.error - Error thrown by the attempt.\n * @param params.sleep - Delay function between retries.\n * @param params.signal - Optional abort signal.\n * @returns Terminal non-throw result if the loop should stop, otherwise\n *   `undefined` to schedule another attempt.\n * @throws Any error thrown by `next`, `onExhausted`, or a custom `sleep` when\n *   the error is not an abort.\n */\nasync function handleFailure<TError, TData>(\n  policy: {\n    next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;\n    onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;\n  },\n  params: {\n    attempt: number;\n    error: TError;\n    sleep: (delayMs: number) => Promise<void>;\n    signal: AbortSignal | undefined;\n  },\n): Promise<RetryRunResult<never> | undefined> {\n  const { attempt, error, sleep, signal } = params;\n  const postExecuteAbortResult = abortResult(signal, attempt);\n  if (postExecuteAbortResult) return postExecuteAbortResult;\n\n  const decision = policy.next({\n    attempt,\n    error,\n  });\n\n  if (!decision.shouldRetry) {\n    const terminalError = policy.onExhausted({\n      attempts: attempt,\n      error,\n    });\n\n    return {\n      ok: false,\n      error: terminalError,\n      attempts: attempt,\n    };\n  }\n\n  if (decision.delayMs > 0) {\n    const sleepAbortResult = await waitForDelay(sleep, decision.delayMs, signal, attempt);\n    if (sleepAbortResult) return sleepAbortResult;\n  }\n\n  return;\n}\n\n/**\n * When `signal` is already aborted, builds the terminal `{ ok: false }` object\n * with a normalized `AbortError` on `error` (not wrapped in `RetryError`).\n *\n * @param signal - Optional abort signal; only acts when `aborted` is set.\n * @param attempts - Number of finished attempts to report in the result.\n * @returns Failure result or `undefined` if not aborted.\n */\nfunction abortResult(\n  signal: AbortSignal | undefined,\n  attempts: number,\n): RetryRunResult<never> | undefined {\n  if (!signal?.aborted) {\n    return;\n  }\n\n  return {\n    ok: false,\n    error: toAbortError(signal.reason),\n    attempts,\n  };\n}\n\n/**\n * Awaits inter-attempt delay in result mode, mapping an abort during wait to\n * a terminal result instead of throwing when `throwOnExhausted` is false.\n *\n * @param sleep - Custom or default sleep implementation.\n * @param delayMs - Milliseconds to wait.\n * @param signal - If set, `sleep` is raced with the abort signal.\n * @param attempts - Attempt count to attach if the wait ends in abort.\n * @returns A terminal result when canceled during the wait, otherwise\n *   `undefined`.\n * @throws The underlying `sleep` rejection when it is not an abort.\n */\nasync function waitForDelay(\n  sleep: (delayMs: number) => Promise<void>,\n  delayMs: number,\n  signal: AbortSignal | undefined,\n  attempts: number,\n): Promise<RetryRunResult<never> | undefined> {\n  if (!signal) {\n    await sleep(delayMs);\n    return;\n  }\n\n  try {\n    await sleepWithAbortSignal(sleep, delayMs, signal);\n    return;\n  } catch (error) {\n    const aborted = abortResult(signal, attempts);\n    if (aborted) {\n      return aborted;\n    }\n    throw error;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA6BA,eAAsB,cACpB,QAIA,SACA,OACA,QAC4B;CAC5B,IAAI,UAAU;AAEd,QAAO,MAAM;EACX,MAAM,mBAAmB,YAAY,QAAQ,KAAK,IAAI,GAAG,UAAU,EAAE,CAAC;AACtE,MAAI,iBAAkB,QAAO;EAE7B,MAAM,YAAY,MAAM,WAAW,SAAS,QAAQ;AACpD,MAAI,UAAU,GACZ,QAAO;GAAE,IAAI;GAAM,OAAO,UAAU;GAAO;EAG7C,MAAM,UAAU,MAAM,cAAc,QAAQ;GAC1C;GACA,OAAO,UAAU;GACjB;GACA;GACD,CAAC;AACF,MAAI,QAAS,QAAO;AAEpB,aAAW;;;;;;;;;;;AAYf,eAAe,WACb,SACA,SACiE;AACjE,KAAI;AACF,SAAO;GACL,IAAI;GACJ,OAAO,MAAM,QAAQ,QAAQ;GAC9B;UACM,OAAO;AACd,SAAO;GACL,IAAI;GACJ;GACD;;;;;;;;;;;;;;;;;;;AAoBL,eAAe,cACb,QAIA,QAM4C;CAC5C,MAAM,EAAE,SAAS,OAAO,OAAO,WAAW;CAC1C,MAAM,yBAAyB,YAAY,QAAQ,QAAQ;AAC3D,KAAI,uBAAwB,QAAO;CAEnC,MAAM,WAAW,OAAO,KAAK;EAC3B;EACA;EACD,CAAC;AAEF,KAAI,CAAC,SAAS,YAMZ,QAAO;EACL,IAAI;EACJ,OAPoB,OAAO,YAAY;GACvC,UAAU;GACV;GACD,CAAC;EAKA,UAAU;EACX;AAGH,KAAI,SAAS,UAAU,GAAG;EACxB,MAAM,mBAAmB,MAAM,aAAa,OAAO,SAAS,SAAS,QAAQ,QAAQ;AACrF,MAAI,iBAAkB,QAAO;;;;;;;;;;;AAcjC,SAAS,YACP,QACA,UACmC;AACnC,KAAI,CAAC,QAAQ,QACX;AAGF,QAAO;EACL,IAAI;EACJ,OAAO,aAAa,OAAO,OAAO;EAClC;EACD;;;;;;;;;;;;;;AAeH,eAAe,aACb,OACA,SACA,QACA,UAC4C;AAC5C,KAAI,CAAC,QAAQ;AACX,QAAM,MAAM,QAAQ;AACpB;;AAGF,KAAI;AACF,QAAM,qBAAqB,OAAO,SAAS,OAAO;AAClD;UACO,OAAO;EACd,MAAM,UAAU,YAAY,QAAQ,SAAS;AAC7C,MAAI,QACF,QAAO;AAET,QAAM"}

package/dist/sleep.d.mts

@@ -0,0 +1,17 @@
+//#region src/sleep.d.ts
+/**
+* Default delay implementation used by `BaseRetryPolicy.run` when no custom
+* `sleep` is provided.
+*
+* @module @zap-studio/retry/sleep
+*/
+/**
+* Awaits a timer-based delay, unless `delayMs` is non-positive.
+*
+* @param delayMs - Milliseconds to wait before resolving.
+* @returns Promise that resolves when the delay completes.
+*/
+declare function defaultSleep(delayMs: number): Promise<void>;
+//#endregion
+export { defaultSleep };
+//# sourceMappingURL=sleep.d.mts.map

package/dist/sleep.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.mts","names":[],"sources":["../src/sleep.ts"],"mappings":";;AAaA;;;;;;;;;;;iBAAsB,YAAA,CAAa,OAAA,WAAkB,OAAA"}

package/dist/sleep.mjs

@@ -0,0 +1,21 @@
+//#region src/sleep.ts
+/**
+* Default delay implementation used by `BaseRetryPolicy.run` when no custom
+* `sleep` is provided.
+*
+* @module @zap-studio/retry/sleep
+*/
+/**
+* Awaits a timer-based delay, unless `delayMs` is non-positive.
+*
+* @param delayMs - Milliseconds to wait before resolving.
+* @returns Promise that resolves when the delay completes.
+*/
+async function defaultSleep(delayMs) {
+	if (delayMs <= 0) return;
+	await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+//#endregion
+export { defaultSleep };
+
+//# sourceMappingURL=sleep.mjs.map

package/dist/sleep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.mjs","names":[],"sources":["../src/sleep.ts"],"sourcesContent":["/**\n * Default delay implementation used by `BaseRetryPolicy.run` when no custom\n * `sleep` is provided.\n *\n * @module @zap-studio/retry/sleep\n */\n\n/**\n * Awaits a timer-based delay, unless `delayMs` is non-positive.\n *\n * @param delayMs - Milliseconds to wait before resolving.\n * @returns Promise that resolves when the delay completes.\n */\nexport async function defaultSleep(delayMs: number): Promise<void> {\n  if (delayMs <= 0) {\n    return;\n  }\n\n  await new Promise((resolve) => setTimeout(resolve, delayMs));\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,eAAsB,aAAa,SAAgC;AACjE,KAAI,WAAW,EACb;AAGF,OAAM,IAAI,SAAS,YAAY,WAAW,SAAS,QAAQ,CAAC"}

package/dist/throw-mode.d.mts

@@ -0,0 +1,26 @@
+import { r as RetryError } from "./errors-fWo_KyVO.mjs";
+import { RetryDecision, RetryDecisionInput, RetryExhaustedInput } from "./types.mjs";
+
+//#region src/throw-mode.d.ts
+/**
+* Runs the throw-mode retry loop: throws `RetryError` on exhaustion and
+* `AbortError` when `signal` aborts.
+*
+* @param policy - Object providing `next` and `onExhausted` (same contract as
+*   `BaseRetryPolicy`).
+* @param execute - Async work callback per attempt.
+* @param sleep - Delay function between retries.
+* @param signal - Optional cancel signal.
+* @returns Resolves to the first successful return value.
+* @throws {RetryError} When retries are exhausted and `onExhausted` returns
+*   the terminal error.
+* @throws {AbortError} When `signal` is already aborted or aborts while waiting.
+* @throws Any error thrown by `next`, `onExhausted`, or `sleep`.
+*/
+declare function runThrowMode<T, TError, TData>(policy: {
+  next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;
+  onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;
+}, execute: (attempt: number) => Promise<T>, sleep: (delayMs: number) => Promise<void>, signal?: AbortSignal): Promise<T>;
+//#endregion
+export { runThrowMode };
+//# sourceMappingURL=throw-mode.d.mts.map

package/dist/throw-mode.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-mode.d.mts","names":[],"sources":["../src/throw-mode.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;iBAAsB,YAAA,kBAAA,CACpB,MAAA;EACE,IAAA,GAAO,KAAA,EAAO,kBAAA,CAAmB,MAAA,EAAQ,KAAA,MAAW,aAAA;EACpD,WAAA,GAAc,KAAA,EAAO,mBAAA,CAAoB,MAAA,EAAQ,KAAA,MAAW,UAAA;AAAA,GAE9D,OAAA,GAAU,OAAA,aAAoB,OAAA,CAAQ,CAAA,GACtC,KAAA,GAAQ,OAAA,aAAoB,OAAA,QAC5B,MAAA,GAAS,WAAA,GACR,OAAA,CAAQ,CAAA"}

package/dist/throw-mode.mjs

@@ -0,0 +1,50 @@
+import { sleepWithAbortSignal, throwIfAborted } from "./abort.mjs";
+//#region src/throw-mode.ts
+/**
+* Throw-mode execution path for `BaseRetryPolicy.run` (default when
+* `throwOnExhausted` is not `false`).
+*
+* @module @zap-studio/retry/throw-mode
+*/
+/**
+* Runs the throw-mode retry loop: throws `RetryError` on exhaustion and
+* `AbortError` when `signal` aborts.
+*
+* @param policy - Object providing `next` and `onExhausted` (same contract as
+*   `BaseRetryPolicy`).
+* @param execute - Async work callback per attempt.
+* @param sleep - Delay function between retries.
+* @param signal - Optional cancel signal.
+* @returns Resolves to the first successful return value.
+* @throws {RetryError} When retries are exhausted and `onExhausted` returns
+*   the terminal error.
+* @throws {AbortError} When `signal` is already aborted or aborts while waiting.
+* @throws Any error thrown by `next`, `onExhausted`, or `sleep`.
+*/
+async function runThrowMode(policy, execute, sleep, signal) {
+	let attempt = 1;
+	while (true) {
+		throwIfAborted(signal);
+		try {
+			return await execute(attempt);
+		} catch (error) {
+			throwIfAborted(signal);
+			const typedError = error;
+			const decision = policy.next({
+				attempt,
+				error: typedError
+			});
+			if (!decision.shouldRetry) throw policy.onExhausted({
+				attempts: attempt,
+				error: typedError
+			});
+			if (decision.delayMs > 0) if (signal) await sleepWithAbortSignal(sleep, decision.delayMs, signal);
+			else await sleep(decision.delayMs);
+			attempt += 1;
+		}
+	}
+}
+//#endregion
+export { runThrowMode };
+
+//# sourceMappingURL=throw-mode.mjs.map

package/dist/throw-mode.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"throw-mode.mjs","names":[],"sources":["../src/throw-mode.ts"],"sourcesContent":["/**\n * Throw-mode execution path for `BaseRetryPolicy.run` (default when\n * `throwOnExhausted` is not `false`).\n *\n * @module @zap-studio/retry/throw-mode\n */\n\nimport { sleepWithAbortSignal, throwIfAborted } from \"./abort.js\";\nimport { RetryError } from \"./errors.js\";\nimport type { RetryDecision, RetryDecisionInput, RetryExhaustedInput } from \"./types.js\";\n\n/**\n * Runs the throw-mode retry loop: throws `RetryError` on exhaustion and\n * `AbortError` when `signal` aborts.\n *\n * @param policy - Object providing `next` and `onExhausted` (same contract as\n *   `BaseRetryPolicy`).\n * @param execute - Async work callback per attempt.\n * @param sleep - Delay function between retries.\n * @param signal - Optional cancel signal.\n * @returns Resolves to the first successful return value.\n * @throws {RetryError} When retries are exhausted and `onExhausted` returns\n *   the terminal error.\n * @throws {AbortError} When `signal` is already aborted or aborts while waiting.\n * @throws Any error thrown by `next`, `onExhausted`, or `sleep`.\n */\nexport async function runThrowMode<T, TError, TData>(\n  policy: {\n    next: (input: RetryDecisionInput<TError, TData>) => RetryDecision;\n    onExhausted: (input: RetryExhaustedInput<TError, TData>) => RetryError;\n  },\n  execute: (attempt: number) => Promise<T>,\n  sleep: (delayMs: number) => Promise<void>,\n  signal?: AbortSignal,\n): Promise<T> {\n  let attempt = 1;\n\n  while (true) {\n    throwIfAborted(signal);\n\n    try {\n      return await execute(attempt);\n    } catch (error) {\n      throwIfAborted(signal);\n\n      const typedError = error as TError;\n      const decision = policy.next({\n        attempt,\n        error: typedError,\n      });\n\n      if (!decision.shouldRetry) {\n        throw policy.onExhausted({\n          attempts: attempt,\n          error: typedError,\n        });\n      }\n\n      if (decision.delayMs > 0) {\n        if (signal) {\n          await sleepWithAbortSignal(sleep, decision.delayMs, signal);\n        } else {\n          await sleep(decision.delayMs);\n        }\n      }\n\n      attempt += 1;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,aACpB,QAIA,SACA,OACA,QACY;CACZ,IAAI,UAAU;AAEd,QAAO,MAAM;AACX,iBAAe,OAAO;AAEtB,MAAI;AACF,UAAO,MAAM,QAAQ,QAAQ;WACtB,OAAO;AACd,kBAAe,OAAO;GAEtB,MAAM,aAAa;GACnB,MAAM,WAAW,OAAO,KAAK;IAC3B;IACA,OAAO;IACR,CAAC;AAEF,OAAI,CAAC,SAAS,YACZ,OAAM,OAAO,YAAY;IACvB,UAAU;IACV,OAAO;IACR,CAAC;AAGJ,OAAI,SAAS,UAAU,EACrB,KAAI,OACF,OAAM,qBAAqB,OAAO,SAAS,SAAS,OAAO;OAE3D,OAAM,MAAM,SAAS,QAAQ;AAIjC,cAAW"}