vigor-fetch 4.0.5 → 4.0.7

package/dist/index.d.ts

@@ -8,6 +8,19 @@ type VigorApply<F extends VigorTypeLambda, In> = F extends {
     readonly In: In;
 })["Target"] : never;
 
+type VigorBrand<Branch extends string, Name extends string> = string & {
+    __brand: `@vigor-fetch:::${Branch} <- ${Name}`;
+};
+declare const VigorDefault: symbol & {
+    __brand: VigorBrand<"Core", "Symbol_Default">;
+};
+type VigorDefaultType = typeof VigorDefault;
+declare const VigorEmpty: symbol & {
+    __brand: VigorBrand<"Core", "Symbol_Empty">;
+};
+type VigorEmptyType = typeof VigorEmpty;
+type VigorExcludeEmpty<T> = Exclude<T, VigorEmptyType>;
+
 type VigorPrimitive = string | number | bigint | boolean | symbol | null | undefined;
 type VigorBuiltin = VigorPrimitive | Date | RegExp | Function | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any>;
 type VigorDeepPartial<T> = unknown extends T ? T : T extends VigorBuiltin ? T : T extends readonly (infer U)[] ? readonly VigorDeepPartial<U>[] : {
@@ -25,37 +38,23 @@ type VigorReplaceType<T, K extends keyof T, V> = VigorSimplify<{
 type VigorConcat<T extends readonly any[], U extends readonly any[]> = [...T, ...U];
 type VigorLastOf<T extends readonly any[]> = T extends [...infer _, infer L] ? L : never;
 type VigorReturnType<T> = T extends (...args: Array<any>) => any ? Awaited<ReturnType<T>> : never;
+/**
+ * Resolves the effective result type for a builder that supports `.cast<T>()`.
+ *
+ * If `Cast` is anything other than the `VigorEmpty` sentinel (i.e. `.cast<T>()`
+ * was called at least once), it always wins — regardless of how many times
+ * `target()`/`strategies()`/etc. were called before or after it. Otherwise the
+ * naturally-inferred `Natural` type (e.g. derived from the target function's
+ * return type through the middleware pipeline) is used.
+ */
+type VigorCastResult<Cast, Natural> = [
+    VigorExcludeEmpty<Cast>
+] extends [never] ? Natural : Cast;
 type VigorMergeMode = "merge" | "replace" | "concat";
 type VigorMergeStrategy<T> = T extends VigorBuiltin ? VigorMergeMode | undefined : T extends readonly any[] ? VigorMergeMode : {
     [K in keyof T]?: VigorMergeStrategy<T[K]> | VigorMergeMode;
 };
 
-type VigorBrand<Branch extends string, Name extends string> = string & {
-    __brand: `@vigor-fetch:::${Branch} <- ${Name}`;
-};
-declare const VigorDefault: symbol & {
-    __brand: VigorBrand<"Core", "Symbol_Default">;
-};
-type VigorDefaultType = typeof VigorDefault;
-declare const VigorEmpty: symbol & {
-    __brand: VigorBrand<"Core", "Symbol_Empty">;
-};
-type VigorEmptyType = typeof VigorEmpty;
-type VigorExcludeEmpty<T> = Exclude<T, VigorEmptyType>;
-
-type VigorParseContextSchema<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Context<Schema">;
-    result: unknown | VigorDefaultType;
-    error: unknown;
-    response: VigorParsePolicySchema<T>["target"];
-    flags: {
-        overrided: boolean;
-        restarted: boolean;
-    };
-    record: Record<string, any>;
-    policy: T["policy"];
-};
-
 /**
  * Base class for Vigor's immutable, chainable builder objects.
  *
@@ -101,347 +100,191 @@ declare abstract class VigorStatus<Base, Config extends Base, TL extends VigorTy
     get config(): Config;
 }
 
-type VigorParsePolicySettingsSchema<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-    raw: boolean;
-    default: ((ctx: T["context"]) => any | Promise<any>) | VigorEmptyType;
-    maxRestarts: number;
+type VigorAllPolicySettingsSchema<T extends VigorAllSchema<T>> = {
+    __brand: VigorBrand<"All", "Policy<Settings<Schema">;
+    concurrency: number;
+    onlySuccess: boolean;
 };
-declare const VigorParsePolicySettingsBase: {
-    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-    readonly raw: false;
-    readonly default: symbol & {
-        __brand: VigorBrand<"Core", "Symbol_Empty">;
-    };
-    readonly maxRestarts: 3;
+declare const VigorAllPolicySettingsBase: {
+    readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
+    readonly concurrency: 5;
+    readonly onlySuccess: false;
 };
-/** Immutable builder for a parse policy's general settings. */
-declare class VigorParsePolicySettings<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<any>, T, VigorParsePolicySettingsTypeLambda> {
+/** Immutable builder for an all-policy's general settings. */
+declare class VigorAllPolicySettings<T extends VigorAllSchema<T> = typeof VigorAllBase> extends VigorStatus<VigorAllSchema<any>, T, VigorAllPolicySettingsTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorParsePolicySettingsTypeLambda, C>;
-    /** When enabled, skips content-type based parsing and returns the raw response. */
-    raw<const N extends VigorParseSchema<any>["policy"]["settings"]["raw"]>(bool: N): VigorParsePolicySettings<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: {
-                readonly raw: N;
-            };
-        };
-    }>>>;
-    /** Sets the fallback value/factory used when parsing ultimately fails. */
-    default<const N extends VigorExcludeEmpty<VigorParseSchema<any>["policy"]["settings"]["default"]>>(func: N): VigorParsePolicySettings<VigorParseIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorAllPolicySettingsTypeLambda, C>;
+    /** Sets the maximum number of tasks run concurrently. */
+    concurrency<const N extends VigorAllSchema<any>["policy"]["settings"]["concurrency"]>(num: N): VigorAllPolicySettings<VigorAllIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly default: N;
+                readonly concurrency: N;
             };
         };
     }>>>;
-    /** Sets the maximum number of full restarts allowed. */
-    maxRestarts<const N extends VigorParseSchema<any>["policy"]["settings"]["maxRestarts"]>(num: N): VigorParsePolicySettings<VigorParseIn<VigorDeepMerge<T, {
+    /** When enabled, filters the final result down to only the tasks that succeeded. */
+    onlySuccess<const N extends VigorAllSchema<any>["policy"]["settings"]["onlySuccess"]>(bool: N): VigorAllPolicySettings<VigorAllIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly maxRestarts: N;
+                readonly onlySuccess: N;
             };
         };
     }>>>;
 }
 
-type VigorParsePolicyMiddlewaresSchema<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-    before: (VigorParsePolicyMiddlewaresFluent<T>["before"] | VigorParsePolicyMiddlewaresIntercept<T>["before"])[];
-    after: (VigorParsePolicyMiddlewaresFluent<T>["after"] | VigorParsePolicyMiddlewaresIntercept<T>["after"])[];
-    onResult: (VigorParsePolicyMiddlewaresFluent<T>["onResult"] | VigorParsePolicyMiddlewaresIntercept<T>["onResult"])[];
-    onError: (VigorParsePolicyMiddlewaresFluent<T>["onError"] | VigorParsePolicyMiddlewaresIntercept<T>["onError"])[];
-};
-declare const VigorParsePolicyMiddlewaresBase: {
-    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-    readonly before: [];
-    readonly after: [];
-    readonly onResult: [];
-    readonly onError: [];
+type VigorAllTask = () => unknown | Promise<unknown>;
+type VigorAllPolicySchema<T extends VigorAllSchema<T>> = {
+    __brand: VigorBrand<"All", "Policy<Schema">;
+    target: VigorAllTask[];
+    settings: VigorAllPolicySettingsSchema<T>;
+    middlewares: VigorAllPolicyMiddlewaresSchema<T>;
 };
-type VigorParsePolicyMiddlewaresFluent<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Policy<Middlewares<Fluent<Schema">;
-    before: {
-        _mode: "fluent";
-        func: (ctx: T["context"]) => void;
-    };
-    after: {
-        _mode: "fluent";
-        func: (ctx: T["context"]) => void;
-    };
-    onResult: {
-        _mode: "fluent";
-        func: (res: T["context"]["result"]) => VigorParseSchema<any>["context"]["result"];
+declare const VigorAllPolicyBase: {
+    readonly __brand: VigorBrand<"All", "Policy<Schema">;
+    readonly target: VigorAllTask[];
+    readonly settings: {
+        readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
+        readonly concurrency: 5;
+        readonly onlySuccess: false;
     };
-    onError: {
-        _mode: "fluent";
-        func: (err: T["context"]["error"]) => void;
+    readonly middlewares: {
+        readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
+        readonly before: VigorAllEachMiddlewareFn[];
+        readonly after: VigorAllEachMiddlewareFn[];
+        readonly onError: VigorAllEachOnErrorFn[];
     };
 };
-type VigorParsePolicyMiddlewaresApi<T extends VigorParseSchema<T>> = {
-    setResult: (res: VigorParseSchema<any>["context"]["result"]) => void;
-    throwError: (err: VigorParseSchema<any>["context"]["error"]) => void;
-    proceedRestart: () => void;
-    cancelRestart: () => void;
+
+type VigorAllContextSchema<T extends VigorAllSchema<T>> = {
+    __brand: VigorBrand<"All", "Context<Schema">;
+    result: unknown[] | VigorDefaultType;
+    policy: T["policy"];
+    record: Record<string, any>;
 };
-type VigorParsePolicyMiddlewaresIntercept<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Policy<Middlewares<Intercept<Schema">;
-    before: {
-        _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorParsePolicyMiddlewaresApi<T>, "throwError">) => VigorParseSchema<any>["context"] | Promise<VigorParseSchema<any>["context"]>;
-    };
-    after: {
-        _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorParsePolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorParseSchema<any>["context"] | Promise<VigorParseSchema<any>["context"]>;
-    };
-    onResult: {
-        _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorParsePolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorParseSchema<any>["context"] | Promise<VigorParseSchema<any>["context"]>;
-    };
-    onError: {
-        _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorParsePolicyMiddlewaresApi<T>, "setResult" | "throwError" | "proceedRestart" | "cancelRestart">) => VigorParseSchema<any>["context"] | Promise<VigorParseSchema<any>["context"]>;
+type VigorAllEachContextSchema<T extends VigorAllSchema<T>> = {
+    __brand: VigorBrand<"All", "EachContext<Schema">;
+    result: unknown | VigorDefaultType;
+    error: unknown;
+    flags: {
+        overrided: boolean;
     };
+    record: Record<string, any>;
 };
-/**
- * Immutable builder for a parse policy's middleware pipeline (`before`,
- * `after`, `onResult`, `onError`). Each stage accepts either "fluent"
- * middleware (returns a plain value merged into the context) or
- * "intercept" middleware (receives an explicit API to mutate control flow).
- */
-declare class VigorParsePolicyMiddlewares<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<any>, T, VigorParsePolicyMiddlewaresTypeLambda> {
+
+type VigorAllEachMiddlewareFn = (ctx: VigorAllEachContextSchema<any>) => void | Promise<void>;
+type VigorAllEachOnErrorFn = (ctx: VigorAllEachContextSchema<any>, api: {
+    setResult: (r: unknown) => void;
+}) => void | Promise<void>;
+type VigorAllPolicyMiddlewaresSchema<T extends VigorAllSchema<T>> = {
+    __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
+    before: VigorAllEachMiddlewareFn[];
+    after: VigorAllEachMiddlewareFn[];
+    onError: VigorAllEachOnErrorFn[];
+};
+declare const VigorAllPolicyMiddlewaresBase: {
+    readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
+    readonly before: VigorAllEachMiddlewareFn[];
+    readonly after: VigorAllEachMiddlewareFn[];
+    readonly onError: VigorAllEachOnErrorFn[];
+};
+/** Immutable builder for an all-policy's per-task middleware pipeline (`before`, `after`, `onError`). */
+declare class VigorAllPolicyMiddlewares<T extends VigorAllSchema<T> = typeof VigorAllBase> extends VigorStatus<VigorAllSchema<any>, T, VigorAllPolicyMiddlewaresTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, C>;
-    /** Registers a middleware that runs before the response is parsed. */
-    before<const N extends VigorParsePolicyMiddlewaresFluent<any>["before"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                before: [{
-                    _mode: "fluent";
-                    func: N;
-                }];
+    protected _create<C>(config: C): VigorApply<VigorAllPolicyMiddlewaresTypeLambda, C>;
+    /** Registers a middleware that runs before each task is invoked. */
+    before<const N extends VigorAllEachMiddlewareFn>(func: N): VigorAllPolicyMiddlewares<VigorAllIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly middlewares: {
+                readonly before: readonly [N];
             };
         };
-    }>>;
-    before<const N extends VigorParsePolicyMiddlewaresIntercept<any>["before"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                before: [{
-                    _mode: "intercept";
-                    func: N;
-                }];
+    }>>>;
+    /** Registers a middleware that runs after each task settles successfully. */
+    after<const N extends VigorAllEachMiddlewareFn>(func: N): VigorAllPolicyMiddlewares<VigorAllIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly middlewares: {
+                readonly after: readonly [N];
             };
         };
-    }>>;
-    /** Registers a middleware that runs after the response has been parsed. */
-    after<const N extends VigorParsePolicyMiddlewaresFluent<any>["after"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                after: [{
-                    _mode: "fluent";
-                    func: N;
-                }];
+    }>>>;
+    /** Registers a middleware that runs when an individual task fails. */
+    onError<const N extends VigorAllEachOnErrorFn>(func: N): VigorAllPolicyMiddlewares<VigorAllIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly middlewares: {
+                readonly onError: readonly [N];
             };
         };
-    }>>;
-    after<const N extends VigorParsePolicyMiddlewaresIntercept<any>["after"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                after: [{
-                    _mode: "intercept";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    /** Registers a middleware that transforms or validates the parsed result. */
-    onResult<const N extends VigorParsePolicyMiddlewaresFluent<any>["onResult"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                onResult: [{
-                    _mode: "fluent";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    onResult<const N extends VigorParsePolicyMiddlewaresIntercept<any>["onResult"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                onResult: [{
-                    _mode: "intercept";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    /** Registers a middleware that runs when parsing ultimately fails. */
-    onError<const N extends VigorParsePolicyMiddlewaresFluent<any>["onError"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                onError: [{
-                    _mode: "fluent";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    onError<const N extends VigorParsePolicyMiddlewaresIntercept<any>["onError"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                onError: [{
-                    _mode: "intercept";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-}
-
-type VigorParsePolicySchema<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Policy<Schema">;
-    target: Request | Response | VigorDefaultType;
-    settings: VigorParsePolicySettingsSchema<T>;
-    middlewares: VigorParsePolicyMiddlewaresSchema<T>;
-    strategies: VigorParsePolicyStrategiesSchema<T>;
-};
-declare const VigorParsePolicyBase: {
-    readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-    readonly target: symbol & {
-        __brand: VigorBrand<"Core", "Symbol_Default">;
-    };
-    readonly settings: {
-        readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-        readonly raw: false;
-        readonly default: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Empty">;
-        };
-        readonly maxRestarts: 3;
-    };
-    readonly middlewares: {
-        readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-        readonly before: [];
-        readonly after: [];
-        readonly onResult: [];
-        readonly onError: [];
-    };
-    readonly strategies: {
-        readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-        readonly funcs: VigorParseStrategyFunc[];
-    };
-};
-
-type VigorParseSchema<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Schema">;
-    policy: VigorParsePolicySchema<T>;
-    context: VigorParseContextSchema<T>;
-};
-declare const VigorParseBase: {
-    readonly __brand: VigorBrand<"Parse", "Schema">;
-    readonly policy: {
-        readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-        readonly target: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly settings: {
-            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-            readonly raw: false;
-            readonly default: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Empty">;
-            };
-            readonly maxRestarts: 3;
+    }>>>;
+}
+
+type VigorAllSchema<T extends VigorAllSchema<T>> = {
+    __brand: VigorBrand<"All", "Schema">;
+    policy: VigorAllPolicySchema<T>;
+    /** Type-level override for the resolved result type, set via `.cast<T>()`. */
+    cast: unknown;
+};
+declare const VigorAllBase: {
+    readonly __brand: VigorBrand<"All", "Schema">;
+    readonly policy: {
+        readonly __brand: VigorBrand<"All", "Policy<Schema">;
+        readonly target: VigorAllTask[];
+        readonly settings: {
+            readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
+            readonly concurrency: 5;
+            readonly onlySuccess: false;
         };
         readonly middlewares: {
-            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-            readonly before: [];
-            readonly after: [];
-            readonly onResult: [];
-            readonly onError: [];
-        };
-        readonly strategies: {
-            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-            readonly funcs: VigorParseStrategyFunc[];
+            readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
+            readonly before: VigorAllEachMiddlewareFn[];
+            readonly after: VigorAllEachMiddlewareFn[];
+            readonly onError: VigorAllEachOnErrorFn[];
         };
     };
-    readonly context: {
-        readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-        readonly result: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly error: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly response: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly flags: {
-            readonly overrided: false;
-            readonly restarted: false;
-        };
-        readonly record: {};
-        readonly policy: {
-            readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-            readonly target: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly settings: {
-                readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                readonly raw: false;
-                readonly default: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                };
-                readonly maxRestarts: 3;
-            };
-            readonly middlewares: {
-                readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                readonly before: [];
-                readonly after: [];
-                readonly onResult: [];
-                readonly onError: [];
-            };
-            readonly strategies: {
-                readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                readonly funcs: VigorParseStrategyFunc[];
-            };
-        };
+    readonly cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
     };
 };
 /**
- * Immutable builder that parses an HTTP response into a result value,
- * trying each configured strategy in sequence with an optional middleware
- * pipeline and restart-on-failure support.
+ * Immutable builder that runs a list of independent tasks with bounded
+ * concurrency, per-task middleware, and either an all-results or
+ * only-successes result mode.
  */
-declare class VigorParse<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<T>, T, VigorParseTypeLambda> {
+declare class VigorAll<T extends VigorAllSchema<T> = typeof VigorAllBase> extends VigorStatus<VigorAllSchema<T>, T, VigorAllTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorParseTypeLambda, C>;
-    /** Sets the `Response` object to parse. */
-    target<const N extends VigorParseSchema<T>["policy"]["target"]>(response: N): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorAllTypeLambda, C>;
+    /** Sets the list of tasks to run. */
+    target<const N extends VigorAllTask[]>(...funcs: N): VigorAll<VigorAllIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly target: N;
         };
     }>>>;
-    /** Configures the parse policy's general settings. */
-    settings<const N extends VigorDeepPartial<VigorParsePolicySettingsSchema<T>>, R extends VigorParseSchema<any>>(input: N | ((s: VigorParsePolicySettings<T>) => VigorParsePolicySettings<R>) | VigorParsePolicySettings<R>): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+    /** Configures the all-policy's general settings (concurrency, onlySuccess). */
+    settings<const N extends VigorDeepPartial<VigorAllPolicySettingsSchema<T>>, R extends VigorAllSchema<any>>(input: N | ((s: VigorAllPolicySettings<T>) => VigorAllPolicySettings<R>) | VigorAllPolicySettings<R>): VigorAll<VigorAllIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly settings: VigorParsePolicySettingsSchema<any>;
+            readonly settings: VigorAllPolicySettingsSchema<any>;
         };
     }>>>;
-    /** Configures the parse policy's middleware pipeline. */
-    middlewares<const N extends VigorDeepPartial<VigorParsePolicyMiddlewaresSchema<T>>, R extends VigorParseSchema<any>>(input: N | ((s: VigorParsePolicyMiddlewares<T>) => VigorParsePolicyMiddlewares<R>) | VigorParsePolicyMiddlewares<R>): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+    /** Configures the all-policy's per-task middleware pipeline. */
+    middlewares<const N extends VigorDeepPartial<VigorAllPolicyMiddlewaresSchema<T>>, R extends VigorAllSchema<any>>(input: N | ((s: VigorAllPolicyMiddlewares<T>) => VigorAllPolicyMiddlewares<R>) | VigorAllPolicyMiddlewares<R>): VigorAll<VigorAllIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly middlewares: VigorParsePolicyMiddlewaresSchema<any>;
+            readonly middlewares: VigorAllPolicyMiddlewaresSchema<any>;
         };
     }>>>;
-    /** Configures the parse policy's fallback chain of parsing strategies. */
-    strategies<const N extends VigorDeepPartial<VigorParsePolicyStrategiesSchema<T>>, R extends VigorParseSchema<any>>(input: N | ((s: VigorParsePolicyStrategies<T>) => VigorParsePolicyStrategies<R>) | VigorParsePolicyStrategies<R>): VigorParse<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly strategies: VigorParsePolicyStrategiesSchema<any>;
-        };
+    /** Runs a single task through the before/after/onError middleware pipeline. */
+    private _runTask;
+    /**
+     * Overrides the resolved result type with `T`, taking priority over the
+     * naturally-inferred `unknown[]`. Can be called before or after
+     * `target()` (or any other configuration method); whichever `.cast<T>()`
+     * call happens last wins.
+     */
+    cast<const C>(): VigorAll<VigorAllIn<VigorDeepMerge<T, {
+        cast: C;
     }>>>;
-    /** Runs parsing and returns the result directly, throwing on final failure. */
-    request<R = T["context"]["result"]>(): Promise<R>;
-    /** Runs parsing and returns a result/error envelope instead of throwing. */
-    requestVerbose<R = T["context"]["result"]>(): Promise<{
+    /** Runs all tasks and returns the results array directly, throwing on final failure. */
+    request<R = VigorCastResult<T["cast"], unknown[]>>(): Promise<R>;
+    /** Runs all tasks and returns a result/error envelope instead of throwing. */
+    requestVerbose<R = VigorCastResult<T["cast"], unknown[]>>(): Promise<{
         success: false;
         data: null;
         error: unknown;
@@ -450,218 +293,178 @@ declare class VigorParse<T extends VigorParseSchema<T> = typeof VigorParseBase>
         data: R;
         error: null;
     }>;
-    /** Internal execution loop implementing the strategy fallback and restart handling. */
+    /** Internal execution loop implementing the bounded-concurrency worker pool. */
     private requestRuntime;
 }
 
-type VigorParseIn<T> = T extends VigorParseSchema<any> ? T : never;
-interface VigorParseTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorParse<VigorParseIn<this["In"]>>;
-}
-interface VigorParsePolicySettingsTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorParsePolicySettings<VigorParseIn<this["In"]>>;
+type VigorAllIn<T> = T extends VigorAllSchema<any> ? T : never;
+interface VigorAllTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorAll<VigorAllIn<this["In"]>>;
 }
-interface VigorParsePolicyMiddlewaresTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorParsePolicyMiddlewares<VigorParseIn<this["In"]>>;
+interface VigorAllPolicySettingsTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorAllPolicySettings<VigorAllIn<this["In"]>>;
 }
-interface VigorParsePolicyStrategiesTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorParsePolicyStrategies<VigorParseIn<this["In"]>>;
+interface VigorAllPolicyMiddlewaresTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorAllPolicyMiddlewares<VigorAllIn<this["In"]>>;
 }
 
-type VigorParseStrategyFunc = (response: Response) => Promise<any>;
-type VigorParsePolicyStrategiesSchema<T extends VigorParseSchema<T>> = {
-    __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-    funcs: Array<VigorParseStrategyFunc>;
+type VigorFetchExtraOptions = Omit<RequestInit, "method" | "headers" | "body" | "signal">;
+type VigorFetchOptions = VigorFetchExtraOptions & {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "CONNECT" | "TRACE";
+    headers: Record<string, string>;
+    body?: BodyInit | null;
+    signal?: AbortSignal;
 };
-declare const VigorParsePolicyStrategiesBase: {
-    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-    readonly funcs: VigorParseStrategyFunc[];
+/**
+ * Base shape shared by every fetch context variant. `R` is the type of
+ * `result` at the point the context is observed — computed per pipeline
+ * stage instead of being fixed on the schema.
+ */
+type VigorFetchContextSchema<T extends VigorFetchSchema<T>, R = VigorCastResult<T["cast"], unknown> | VigorDefaultType> = {
+    __brand: VigorBrand<"Fetch", "Context<Schema">;
+    href: string;
+    response: Response | VigorDefaultType;
+    result: R;
+    error: unknown;
+    options: VigorFetchOptions | VigorDefaultType;
+    flags: {
+        overrided: boolean;
+        restarted: boolean;
+    };
+    record: Record<string, any>;
+    policy: T["policy"];
 };
-/** Parses a response by matching its `Content-Type` header against a known parser table. */
-declare const VigorParseContentTypeStrategy: VigorParseStrategyFunc;
-/** Parses a response by trying a sequence of body-reading methods until one succeeds. */
-declare const VigorParseSniffStrategy: VigorParseStrategyFunc;
-/** Immutable builder for a parse policy's fallback chain of parsing strategies. */
-declare class VigorParsePolicyStrategies<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<any>, T, VigorParsePolicyStrategiesTypeLambda> {
+/** Context shape seen by `before` middlewares — the request hasn't been sent yet. */
+type VigorFetchBeforeContextSchema<T extends VigorFetchSchema<T>> = VigorFetchContextSchema<T, VigorDefaultType>;
+/** Context shape seen by `after` / `onResult` middlewares — a response has been received/parsed. */
+type VigorFetchAfterContextSchema<T extends VigorFetchSchema<T>> = VigorFetchContextSchema<T, VigorCastResult<T["cast"], unknown> | VigorDefaultType>;
+
+type VigorFetchPolicySettingsSchema<T extends VigorFetchSchema<T>> = {
+    __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
+    retryHeaders: string[];
+    unretryStatus: number[];
+    maxRestarts: number;
+    default: ((ctx: VigorFetchContextSchema<T>) => any | Promise<any>) | VigorEmptyType;
+};
+declare const VigorFetchPolicySettingsBase: {
+    readonly __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
+    readonly retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
+    readonly unretryStatus: [400, 401, 403, 404, 405, 413, 422];
+    readonly maxRestarts: 3;
+    readonly default: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+};
+/** Immutable builder for a fetch policy's general settings. */
+declare class VigorFetchPolicySettings<T extends VigorFetchSchema<T> = typeof VigorFetchBase> extends VigorStatus<VigorFetchSchema<any>, T, VigorFetchPolicySettingsTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorParsePolicyStrategiesTypeLambda, C>;
-    /**
-     * Adds strategy functions to the fallback chain.
-     *
-     * @param replace - When `true`, replaces the existing chain instead of
-     *  appending to it (the default is to concat, since strategies are
-     *  tried in sequence as a fallback chain).
-     */
-    private _set;
-    /** Adds the content-type based parsing strategy. */
-    contentType(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorFetchPolicySettingsTypeLambda, C>;
+    /** Sets response headers consulted to compute a server-suggested retry delay. */
+    retryHeaders<const N extends VigorFetchSchema<any>["policy"]["settings"]["retryHeaders"]>(...strs: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
-            };
-        };
-    }>>>;
-    /** Adds the sniffing (try-each-method) parsing strategy. */
-    sniff(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
-            };
-        };
-    }>>>;
-    /** Adds a strategy that always parses the response as JSON. */
-    json(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
-            };
-        };
-    }>>>;
-    /** Adds a strategy that always parses the response as text. */
-    text(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
-            };
-        };
-    }>>>;
-    /** Adds a strategy that always parses the response as an `ArrayBuffer`. */
-    arrayBuffer(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
-            };
-        };
-    }>>>;
-    /** Adds a strategy that always parses the response as a `Blob`. */
-    blob(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
+            readonly settings: {
+                readonly retryHeaders: N;
             };
         };
     }>>>;
-    /** Adds a strategy that always parses the response as a `Uint8Array`. */
-    bytes(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+    /** Sets HTTP status codes that should never be retried. */
+    unretryStatus<const N extends VigorFetchSchema<any>["policy"]["settings"]["unretryStatus"]>(...nums: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
+            readonly settings: {
+                readonly unretryStatus: N;
             };
         };
     }>>>;
-    /** Adds a strategy that always parses the response as `FormData`. */
-    formData(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+    /** Sets the maximum number of full restarts allowed. */
+    maxRestarts<const N extends VigorFetchSchema<any>["policy"]["settings"]["maxRestarts"]>(num: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
+            readonly settings: {
+                readonly maxRestarts: N;
             };
         };
     }>>>;
-    /** Adds a user-supplied custom parsing strategy. */
-    custom<const N extends VigorParseStrategyFunc>(func: N, replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+    /** Sets the fallback value/factory used when the request ultimately fails. */
+    default<const N extends VigorExcludeEmpty<VigorFetchSchema<any>["policy"]["settings"]["default"]>>(func: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly strategies: {
-                readonly funcs: VigorParseStrategyFunc[];
+            readonly settings: {
+                readonly default: N;
             };
         };
     }>>>;
 }
 
-type VigorRetryPolicyMiddlewaresSchema<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-    before: (VigorRetryPolicyMiddlewaresFluent<T>["before"] | VigorRetryPolicyMiddlewaresIntercept<T>["before"])[];
-    after: (VigorRetryPolicyMiddlewaresFluent<T>["after"] | VigorRetryPolicyMiddlewaresIntercept<T>["after"])[];
-    onResult: (VigorRetryPolicyMiddlewaresFluent<T>["onResult"] | VigorRetryPolicyMiddlewaresIntercept<T>["onResult"])[];
-    retryIf: (VigorRetryPolicyMiddlewaresFluent<T>["retryIf"] | VigorRetryPolicyMiddlewaresIntercept<T>["retryIf"])[];
-    onRetry: (VigorRetryPolicyMiddlewaresFluent<T>["onRetry"] | VigorRetryPolicyMiddlewaresIntercept<T>["onRetry"])[];
-    onError: (VigorRetryPolicyMiddlewaresFluent<T>["onError"] | VigorRetryPolicyMiddlewaresIntercept<T>["onError"])[];
+type VigorFetchPolicyMiddlewaresSchema<T extends VigorFetchSchema<T>> = {
+    __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
+    before: (VigorFetchPolicyMiddlewaresFluent<T>["before"] | VigorFetchPolicyMiddlewaresIntercept<T>["before"])[];
+    after: (VigorFetchPolicyMiddlewaresFluent<T>["after"] | VigorFetchPolicyMiddlewaresIntercept<T>["after"])[];
+    onResult: (VigorFetchPolicyMiddlewaresFluent<T>["onResult"] | VigorFetchPolicyMiddlewaresIntercept<T>["onResult"])[];
+    onError: (VigorFetchPolicyMiddlewaresFluent<T>["onError"] | VigorFetchPolicyMiddlewaresIntercept<T>["onError"])[];
 };
-declare const VigorRetryPolicyMiddlewaresBase: {
-    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+declare const VigorFetchPolicyMiddlewaresBase: {
+    readonly __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
     readonly before: [];
     readonly after: [];
     readonly onResult: [];
-    readonly retryIf: [];
-    readonly onRetry: [];
     readonly onError: [];
 };
-type VigorRetryPolicyMiddlewaresFluent<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Policy<Middlewares<Fluent<Schema">;
+type VigorFetchPolicyMiddlewaresFluent<T extends VigorFetchSchema<T>> = {
+    __brand: VigorBrand<"Fetch", "Policy<Middlewares<Fluent<Schema">;
     before: {
         _mode: "fluent";
-        func: (ctx: T["context"]) => void;
+        func: (ctx: VigorFetchBeforeContextSchema<T>) => void;
     };
     after: {
         _mode: "fluent";
-        func: (ctx: T["context"]) => void;
+        func: (ctx: VigorFetchAfterContextSchema<T>) => void;
     };
     onResult: {
         _mode: "fluent";
-        func: (res: T["context"]["result"]) => VigorRetrySchema<any>["context"]["result"];
-    };
-    retryIf: {
-        _mode: "fluent";
-        func: (err: T["context"]["error"]) => VigorRetrySchema<any>["context"]["flags"]["doRetry"];
-    };
-    onRetry: {
-        _mode: "fluent";
-        func: (err: T["context"]["error"]) => void;
+        func: (res: VigorFetchAfterContextSchema<T>["result"]) => VigorFetchContextSchema<any>["result"];
     };
     onError: {
         _mode: "fluent";
-        func: (err: T["context"]["error"]) => void;
+        func: (err: VigorFetchContextSchema<T>["error"]) => void;
     };
 };
-type VigorRetryPolicyMiddlewaresApi<T extends VigorRetrySchema<T>> = {
-    setResult: (res: VigorRetrySchema<any>["context"]["result"]) => void;
-    throwError: (err: VigorRetrySchema<any>["context"]["error"]) => void;
-    abort: (err: VigorRetrySchema<any>["context"]["error"]) => void;
-    breakRetry: (err: VigorRetrySchema<any>["context"]["error"]) => void;
-    proceedRetry: () => void;
-    cancelRetry: () => void;
-    setDelay: (num: VigorRetrySchema<any>["context"]["system"]["delay"]) => void;
+type VigorFetchPolicyMiddlewaresApi<T extends VigorFetchSchema<T>> = {
+    setResult: (res: VigorFetchContextSchema<any>["result"]) => void;
+    throwError: (err: VigorFetchContextSchema<any>["error"]) => void;
+    setOptions: (opts: VigorFetchOptions) => void;
+    setHeaders: (headers: VigorFetchOptions["headers"]) => void;
+    setBody: (body: VigorFetchOptions["body"]) => void;
     proceedRestart: () => void;
     cancelRestart: () => void;
 };
-type VigorRetryPolicyMiddlewaresIntercept<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Policy<Middlewares<Intercept<Schema">;
+type VigorFetchPolicyMiddlewaresIntercept<T extends VigorFetchSchema<T>> = {
+    __brand: VigorBrand<"Fetch", "Policy<Middlewares<Intercept<Schema">;
     before: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "abort" | "throwError" | "breakRetry">) => VigorRetrySchema<any>["context"] | Promise<VigorRetrySchema<any>["context"]>;
+        func: (ctx: VigorFetchBeforeContextSchema<T>, api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "throwError" | "setOptions" | "setHeaders" | "setBody">) => VigorFetchContextSchema<any> | Promise<VigorFetchContextSchema<any>>;
     };
     after: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "throwError">) => VigorRetrySchema<any>["context"] | Promise<VigorRetrySchema<any>["context"]>;
+        func: (ctx: VigorFetchAfterContextSchema<T>, api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorFetchContextSchema<any> | Promise<VigorFetchContextSchema<any>>;
     };
     onResult: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorRetrySchema<any>["context"] | Promise<VigorRetrySchema<any>["context"]>;
-    };
-    retryIf: {
-        _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "proceedRetry" | "cancelRetry">) => VigorRetrySchema<any>["context"] | Promise<VigorRetrySchema<any>["context"]>;
-    };
-    onRetry: {
-        _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "throwError" | "setDelay">) => VigorRetrySchema<any>["context"] | Promise<VigorRetrySchema<any>["context"]>;
+        func: (ctx: VigorFetchAfterContextSchema<T>, api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorFetchContextSchema<any> | Promise<VigorFetchContextSchema<any>>;
     };
     onError: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "setResult" | "throwError" | "proceedRestart" | "cancelRestart">) => VigorRetrySchema<any>["context"] | Promise<VigorRetrySchema<any>["context"]>;
+        func: (ctx: VigorFetchContextSchema<T>, api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "setResult" | "throwError" | "proceedRestart" | "cancelRestart">) => VigorFetchContextSchema<any> | Promise<VigorFetchContextSchema<any>>;
     };
 };
 /**
- * Immutable builder for a retry policy's middleware pipeline (`before`,
- * `after`, `onResult`, `retryIf`, `onRetry`, `onError`). Each stage accepts
- * either "fluent" middleware (returns a plain value merged into the
- * context) or "intercept" middleware (receives an explicit API to mutate
- * control flow).
+ * Immutable builder for a fetch policy's middleware pipeline (`before`,
+ * `after`, `onResult`, `onError`). Each stage accepts either "fluent"
+ * middleware (returns a plain value merged into the context) or
+ * "intercept" middleware (receives an explicit API to mutate control flow).
  */
-declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof VigorRetryBase> extends VigorStatus<VigorRetrySchema<any>, T, VigorRetryPolicyMiddlewaresTypeLambda> {
+declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof VigorFetchBase> extends VigorStatus<VigorFetchSchema<any>, T, VigorFetchPolicyMiddlewaresTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, C>;
-    /** Registers a middleware that runs before the retried target is invoked. */
-    before<const N extends VigorRetryPolicyMiddlewaresFluent<any>["before"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, C>;
+    /** Registers a middleware that runs before the request is sent. */
+    before<const N extends VigorFetchPolicyMiddlewaresFluent<T>["before"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 before: [{
@@ -671,7 +474,7 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    before<const N extends VigorRetryPolicyMiddlewaresIntercept<any>["before"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    before<const N extends VigorFetchPolicyMiddlewaresIntercept<T>["before"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 before: [{
@@ -681,8 +484,8 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    /** Registers a middleware that runs after the retried target settles. */
-    after<const N extends VigorRetryPolicyMiddlewaresFluent<any>["after"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    /** Registers a middleware that runs after the response is received. */
+    after<const N extends VigorFetchPolicyMiddlewaresFluent<T>["after"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 after: [{
@@ -692,7 +495,7 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    after<const N extends VigorRetryPolicyMiddlewaresIntercept<any>["after"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    after<const N extends VigorFetchPolicyMiddlewaresIntercept<T>["after"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 after: [{
@@ -702,8 +505,8 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    /** Registers a middleware to transform or validate the retry's result. */
-    onResult<const N extends VigorRetryPolicyMiddlewaresFluent<any>["onResult"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    /** Registers a middleware that transforms or validates the parsed result. */
+    onResult<const N extends VigorFetchPolicyMiddlewaresFluent<T>["onResult"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onResult: [{
@@ -713,7 +516,7 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    onResult<const N extends VigorRetryPolicyMiddlewaresIntercept<any>["onResult"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    onResult<const N extends VigorFetchPolicyMiddlewaresIntercept<T>["onResult"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onResult: [{
@@ -723,50 +526,8 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    /** Registers a middleware that decides whether a failed attempt should be retried. */
-    retryIf<const N extends VigorRetryPolicyMiddlewaresFluent<any>["retryIf"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                retryIf: [{
-                    _mode: "fluent";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    retryIf<const N extends VigorRetryPolicyMiddlewaresIntercept<any>["retryIf"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                retryIf: [{
-                    _mode: "intercept";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    /** Registers a middleware invoked right before a retry attempt is scheduled. */
-    onRetry<const N extends VigorRetryPolicyMiddlewaresFluent<any>["onRetry"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                onRetry: [{
-                    _mode: "fluent";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    onRetry<const N extends VigorRetryPolicyMiddlewaresIntercept<any>["onRetry"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
-        policy: {
-            middlewares: {
-                onRetry: [{
-                    _mode: "intercept";
-                    func: N;
-                }];
-            };
-        };
-    }>>;
-    /** Registers a middleware invoked when retries/restarts are exhausted. */
-    onError<const N extends VigorRetryPolicyMiddlewaresFluent<any>["onError"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    /** Registers a middleware that runs when the request ultimately fails. */
+    onError<const N extends VigorFetchPolicyMiddlewaresFluent<T>["onError"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onError: [{
@@ -776,7 +537,7 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
             };
         };
     }>>;
-    onError<const N extends VigorRetryPolicyMiddlewaresIntercept<any>["onError"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    onError<const N extends VigorFetchPolicyMiddlewaresIntercept<T>["onError"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onError: [{
@@ -787,347 +548,25 @@ declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof
         };
     }>>;
 }
-type VigorRetryPipeInitialContext<T extends VigorRetrySchema<T>, R = VigorReturnType<T["policy"]["target"]>> = VigorDeepMerge<Omit<T["context"], "result">, {
-    result: R;
-}>;
-type VigorRetryPipeStepVoid<Ctx, Arr> = Arr extends [infer Head, ...infer Tail] ? Head extends {
-    _mode: "intercept";
-    func: (...args: any[]) => infer Ret;
-} ? VigorRetryPipeStepVoid<Ret, Tail> : VigorRetryPipeStepVoid<Ctx, Tail> : Ctx;
-type VigorRetryPipeStepResult<Ctx, Arr> = Arr extends [infer Head, ...infer Tail] ? Head extends {
-    _mode: "intercept";
-    func: (...args: any[]) => infer Ret;
-} ? VigorRetryPipeStepResult<Ret, Tail> : Head extends {
-    _mode: "fluent";
-    func: (...args: any[]) => infer FR;
-} ? VigorRetryPipeStepResult<VigorDeepMerge<Ctx, {
-    result: FR;
-}>, Tail> : VigorRetryPipeStepResult<Ctx, Tail> : Ctx;
-type VigorRetryPipeStepRetryIf<Ctx, Arr> = Arr extends [infer Head, ...infer Tail] ? Head extends {
-    _mode: "intercept";
-    func: (...args: any[]) => infer Ret;
-} ? VigorRetryPipeStepRetryIf<Ret, Tail> : Head extends {
-    _mode: "fluent";
-    func: (...args: any[]) => infer FR;
-} ? VigorRetryPipeStepRetryIf<VigorDeepMerge<Ctx, {
-    flags: {
-        doRetry: FR;
-    };
-}>, Tail> : VigorRetryPipeStepRetryIf<Ctx, Tail> : Ctx;
-type VigorRetryPolicyMiddlewaresPipe<T extends VigorRetrySchema<T>> = VigorRetryPipeStepVoid<VigorRetryPipeStepVoid<VigorRetryPipeStepRetryIf<VigorRetryPipeStepResult<VigorRetryPipeStepVoid<VigorRetryPipeStepVoid<VigorRetryPipeInitialContext<T>, T["policy"]["middlewares"]["before"]>, T["policy"]["middlewares"]["after"]>, T["policy"]["middlewares"]["onResult"]>, T["policy"]["middlewares"]["retryIf"]>, T["policy"]["middlewares"]["onRetry"]>, T["policy"]["middlewares"]["onError"]>;
-type VigorRetryPipeResult<T extends VigorRetrySchema<T>> = VigorRetryPolicyMiddlewaresPipe<T> extends {
-    result: infer R;
-} ? R : never;
-
-type VigorRetryContextSchema<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Context<Schema">;
-    result: VigorRetryPipeResult<T> | VigorDefaultType;
-    error: unknown;
-    system: {
-        delay: number | VigorDefaultType;
-        attempt: number;
-    };
-    flags: {
-        doRetry: boolean;
-        doRestart: boolean;
-        brokeRetry: boolean;
-        overridden: boolean;
-    };
-    record: Record<string, any>;
-    policy: T["policy"];
-};
 
-type VigorRetryPolicySettingsSchema<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-    default: ((ctx: T["context"]) => any | Promise<any>) | VigorEmptyType;
-    maxAttempts: number;
-    maxRestarts: number;
-    timeout: number;
+/** Returns a random offset in the range `[-jitter, +jitter]` to randomize a computed delay. */
+declare function VigorJitter(jitter: number): number;
+type VigorRetryPolicyAlgorithmsConstantSchema<T extends VigorRetryPolicyAlgorithmsConstantSchema<T>> = {
+    __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+    _tag: "constant";
+    jitter: number;
+    interval: number;
+    _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<T>) => number;
 };
-declare const VigorRetryPolicySettingsBase: {
-    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-    readonly default: symbol & {
-        __brand: VigorBrand<"Core", "Symbol_Empty">;
-    };
-    readonly maxAttempts: 5;
-    readonly maxRestarts: 3;
-    readonly timeout: 20000;
+declare const VigorRetryPolicyAlgorithmsConstantBase: {
+    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+    readonly _tag: "constant";
+    readonly jitter: 1000;
+    readonly interval: 2000;
+    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
 };
-/** Immutable builder for a retry policy's general settings. */
-declare class VigorRetryPolicySettings<T extends VigorRetrySchema<T> = typeof VigorRetryBase> extends VigorStatus<VigorRetrySchema<any>, T, VigorRetryPolicySettingsTypeLambda> {
-    constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorRetryPolicySettingsTypeLambda, C>;
-    /** Sets the fallback value/factory used when the target ultimately fails. */
-    default<const N extends VigorExcludeEmpty<VigorRetrySchema<any>["policy"]["settings"]["default"]>>(func: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: {
-                readonly default: N;
-            };
-        };
-    }>>>;
-    /** Sets the maximum number of retry attempts before giving up. */
-    maxAttempts<const N extends VigorRetrySchema<any>["policy"]["settings"]["maxAttempts"]>(num: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: {
-                readonly maxAttempts: N;
-            };
-        };
-    }>>>;
-    /** Sets the maximum number of full restarts allowed. */
-    maxRestarts<const N extends VigorRetrySchema<any>["policy"]["settings"]["maxRestarts"]>(num: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: {
-                readonly maxRestarts: N;
-            };
-        };
-    }>>>;
-    /** Sets the timeout, in milliseconds, for a single attempt. */
-    timeout<const N extends VigorRetrySchema<any>["policy"]["settings"]["timeout"]>(num: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: {
-                readonly timeout: N;
-            };
-        };
-    }>>>;
-}
-
-type VigorRetryPolicySchema<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Policy<Schema">;
-    target: ((signal: AbortSignal) => any | Promise<any>) | VigorEmptyType;
-    abortSignals: AbortSignal[];
-    settings: VigorRetryPolicySettingsSchema<T>;
-    middlewares: VigorRetryPolicyMiddlewaresSchema<T>;
-    algorithms: VigorRetryPolicyAlgorithmsSchema<T>;
-};
-declare const VigorRetryPolicyBase: {
-    readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-    readonly target: symbol & {
-        __brand: VigorBrand<"Core", "Symbol_Empty">;
-    };
-    readonly abortSignals: [];
-    readonly settings: {
-        readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-        readonly default: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Empty">;
-        };
-        readonly maxAttempts: 5;
-        readonly maxRestarts: 3;
-        readonly timeout: 20000;
-    };
-    readonly middlewares: {
-        readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-        readonly before: [];
-        readonly after: [];
-        readonly onResult: [];
-        readonly retryIf: [];
-        readonly onRetry: [];
-        readonly onError: [];
-    };
-    readonly algorithms: {
-        readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-        readonly _tag: "constant";
-        readonly jitter: 1000;
-        readonly interval: 2000;
-        readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-    };
-};
-
-type VigorRetrySchema<T extends VigorRetrySchema<T>> = {
-    __brand: VigorBrand<"Retry", "Schema">;
-    policy: VigorRetryPolicySchema<T>;
-    context: VigorRetryContextSchema<T>;
-};
-declare const VigorRetryBase: {
-    readonly __brand: VigorBrand<"Retry", "Schema">;
-    readonly policy: {
-        readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-        readonly target: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Empty">;
-        };
-        readonly abortSignals: [];
-        readonly settings: {
-            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-            readonly default: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Empty">;
-            };
-            readonly maxAttempts: 5;
-            readonly maxRestarts: 3;
-            readonly timeout: 20000;
-        };
-        readonly middlewares: {
-            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-            readonly before: [];
-            readonly after: [];
-            readonly onResult: [];
-            readonly retryIf: [];
-            readonly onRetry: [];
-            readonly onError: [];
-        };
-        readonly algorithms: {
-            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-            readonly _tag: "constant";
-            readonly jitter: 1000;
-            readonly interval: 2000;
-            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-        };
-    };
-    readonly context: {
-        readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-        readonly result: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly error: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly system: {
-            readonly delay: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly attempt: 0;
-        };
-        readonly flags: {
-            readonly doRetry: true;
-            readonly doRestart: false;
-            readonly brokeRetry: false;
-            readonly overridden: false;
-        };
-        readonly record: {};
-        readonly policy: {
-            readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-            readonly target: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Empty">;
-            };
-            readonly abortSignals: [];
-            readonly settings: {
-                readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                readonly default: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                };
-                readonly maxAttempts: 5;
-                readonly maxRestarts: 3;
-                readonly timeout: 20000;
-            };
-            readonly middlewares: {
-                readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                readonly before: [];
-                readonly after: [];
-                readonly onResult: [];
-                readonly retryIf: [];
-                readonly onRetry: [];
-                readonly onError: [];
-            };
-            readonly algorithms: {
-                readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                readonly _tag: "constant";
-                readonly jitter: 1000;
-                readonly interval: 2000;
-                readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-            };
-        };
-    };
-};
-/**
- * Immutable builder that executes a target function with retry, restart,
- * timeout, and abort support, driven by a configurable delay algorithm and
- * middleware pipeline.
- */
-declare class VigorRetry<T extends VigorRetrySchema<T> = typeof VigorRetryBase> extends VigorStatus<VigorRetrySchema<T>, T, VigorRetryTypeLambda> {
-    constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorRetryTypeLambda, C>;
-    /** Sets the target function to invoke, with retry/timeout applied. */
-    target<const N extends VigorExcludeEmpty<VigorRetrySchema<T>["policy"]["target"]>>(func: N): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly target: N;
-        };
-    }>>>;
-    /** Sets external abort signals that, when aborted, stop retrying. */
-    abortSignals<const N extends VigorRetrySchema<T>["policy"]["abortSignals"]>(...sig: N): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly abortSignals: N;
-        };
-    }>>>;
-    /** Configures the retry policy's general settings (max attempts, timeout, etc). */
-    settings<const N extends VigorDeepPartial<VigorRetryPolicySettingsSchema<T>>, R extends VigorRetrySchema<any>>(input: N | ((s: VigorRetryPolicySettings<T>) => VigorRetryPolicySettings<R>) | VigorRetryPolicySettings<R>): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: VigorRetryPolicySettingsSchema<any>;
-        };
-    }>>>;
-    /** Configures the retry policy's middleware pipeline. */
-    middlewares<const N extends VigorDeepPartial<VigorRetryPolicyMiddlewaresSchema<T>>, R extends VigorRetrySchema<any>>(input: N | ((s: VigorRetryPolicyMiddlewares<T>) => VigorRetryPolicyMiddlewares<R>) | VigorRetryPolicyMiddlewares<R>): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly middlewares: VigorRetryPolicyMiddlewaresSchema<any>;
-        };
-    }>>>;
-    /** Configures the retry policy's delay algorithm. */
-    algorithms<const N extends VigorDeepPartial<VigorRetryPolicyAlgorithmsSchema<T>>, R extends VigorRetrySchema<any>>(input: N | ((a: VigorRetryPolicyAlgorithms<T>) => VigorRetryPolicyAlgorithms<R> | VigorRetryPolicyAlgorithmsConstant<any>)): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly algorithms: any;
-        };
-    }>>>;
-    /** Runs the target and returns its result directly, throwing on final failure. */
-    request<R = T["context"]["result"]>(): Promise<R>;
-    /** Runs the target and returns a result/error envelope instead of throwing. */
-    requestVerbose<R = T["context"]["result"]>(): Promise<{
-        success: false;
-        data: null;
-        error: unknown;
-    } | {
-        success: true;
-        data: R;
-        error: null;
-    }>;
-    /** Internal execution loop implementing the attempt/retry/restart lifecycle. */
-    private requestRuntime;
-}
-
-type VigorRetryIn<T> = T extends VigorRetrySchema<any> ? T : never;
-type VigorRetryAlgorithmsConstantIn<T> = T extends VigorRetryPolicyAlgorithmsConstantSchema<any> ? T : never;
-type VigorRetryAlgorithmsLinearIn<T> = T extends VigorRetryPolicyAlgorithmsLinearSchema<any> ? T : never;
-type VigorRetryAlgorithmsBackoffIn<T> = T extends VigorRetryPolicyAlgorithmsBackoffSchema<any> ? T : never;
-type VigorRetryAlgorithmsCustomIn<T> = T extends VigorRetryPolicyAlgorithmsCustomSchema<any> ? T : never;
-interface VigorRetryTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetry<VigorRetryIn<this["In"]>>;
-}
-interface VigorRetryPolicySettingsTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicySettings<VigorRetryIn<this["In"]>>;
-}
-interface VigorRetryPolicyMiddlewaresTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicyMiddlewares<VigorRetryIn<this["In"]>>;
-}
-interface VigorRetryPolicyAlgorithmsTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicyAlgorithms<VigorRetryIn<this["In"]>>;
-}
-interface VigorRetryPolicyAlgorithmsConstantTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicyAlgorithmsConstant<VigorRetryAlgorithmsConstantIn<this["In"]>>;
-}
-interface VigorRetryPolicyAlgorithmsLinearTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicyAlgorithmsLinear<VigorRetryAlgorithmsLinearIn<this["In"]>>;
-}
-interface VigorRetryPolicyAlgorithmsBackoffTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicyAlgorithmsBackoff<VigorRetryAlgorithmsBackoffIn<this["In"]>>;
-}
-interface VigorRetryPolicyAlgorithmsCustomTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorRetryPolicyAlgorithmsCustom<VigorRetryAlgorithmsCustomIn<this["In"]>>;
-}
-
-/** Returns a random offset in the range `[-jitter, +jitter]` to randomize a computed delay. */
-declare function VigorJitter(jitter: number): number;
-type VigorRetryPolicyAlgorithmsConstantSchema<T extends VigorRetryPolicyAlgorithmsConstantSchema<T>> = {
-    __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-    _tag: "constant";
-    jitter: number;
-    interval: number;
-    _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<T>) => number;
-};
-declare const VigorRetryPolicyAlgorithmsConstantBase: {
-    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-    readonly _tag: "constant";
-    readonly jitter: 1000;
-    readonly interval: 2000;
-    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-};
-/** Immutable builder for the constant-interval retry delay algorithm. */
-declare class VigorRetryPolicyAlgorithmsConstant<T extends VigorRetryPolicyAlgorithmsConstantSchema<T> = typeof VigorRetryPolicyAlgorithmsConstantBase> extends VigorStatus<VigorRetryPolicyAlgorithmsConstantSchema<any>, T, VigorRetryPolicyAlgorithmsConstantTypeLambda> {
+/** Immutable builder for the constant-interval retry delay algorithm. */
+declare class VigorRetryPolicyAlgorithmsConstant<T extends VigorRetryPolicyAlgorithmsConstantSchema<T> = typeof VigorRetryPolicyAlgorithmsConstantBase> extends VigorStatus<VigorRetryPolicyAlgorithmsConstantSchema<any>, T, VigorRetryPolicyAlgorithmsConstantTypeLambda> {
     constructor(config?: T);
     protected _create<C>(config: C): VigorApply<VigorRetryPolicyAlgorithmsConstantTypeLambda, C>;
     /** Sets the amount of random jitter added to the computed delay. */
@@ -1358,154 +797,507 @@ declare class VigorRetryPolicyAlgorithms<T extends VigorRetrySchema<T> = typeof
     }>>>;
 }
 
-type VigorAllPolicySettingsSchema<T extends VigorAllSchema<T>> = {
-    __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-    concurrency: number;
-    onlySuccess: boolean;
-};
-declare const VigorAllPolicySettingsBase: {
-    readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-    readonly concurrency: 5;
-    readonly onlySuccess: false;
+type VigorRetryPolicyMiddlewaresSchema<T extends VigorRetrySchema<T>> = {
+    __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+    before: (VigorRetryPolicyMiddlewaresFluent<T>["before"] | VigorRetryPolicyMiddlewaresIntercept<T>["before"])[];
+    after: (VigorRetryPolicyMiddlewaresFluent<T>["after"] | VigorRetryPolicyMiddlewaresIntercept<T>["after"])[];
+    onResult: (VigorRetryPolicyMiddlewaresFluent<T>["onResult"] | VigorRetryPolicyMiddlewaresIntercept<T>["onResult"])[];
+    retryIf: (VigorRetryPolicyMiddlewaresFluent<T>["retryIf"] | VigorRetryPolicyMiddlewaresIntercept<T>["retryIf"])[];
+    onRetry: (VigorRetryPolicyMiddlewaresFluent<T>["onRetry"] | VigorRetryPolicyMiddlewaresIntercept<T>["onRetry"])[];
+    onError: (VigorRetryPolicyMiddlewaresFluent<T>["onError"] | VigorRetryPolicyMiddlewaresIntercept<T>["onError"])[];
 };
-/** Immutable builder for an all-policy's general settings. */
-declare class VigorAllPolicySettings<T extends VigorAllSchema<T> = typeof VigorAllBase> extends VigorStatus<VigorAllSchema<any>, T, VigorAllPolicySettingsTypeLambda> {
+declare const VigorRetryPolicyMiddlewaresBase: {
+    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+    readonly before: [];
+    readonly after: [];
+    readonly onResult: [];
+    readonly retryIf: [];
+    readonly onRetry: [];
+    readonly onError: [];
+};
+type VigorRetryPolicyMiddlewaresFluent<T extends VigorRetrySchema<T>> = {
+    __brand: VigorBrand<"Retry", "Policy<Middlewares<Fluent<Schema">;
+    before: {
+        _mode: "fluent";
+        func: (ctx: VigorRetryBeforeContextSchema<T>) => void;
+    };
+    after: {
+        _mode: "fluent";
+        func: (ctx: VigorRetryAfterContextSchema<T>) => void;
+    };
+    onResult: {
+        _mode: "fluent";
+        func: (res: VigorRetryAfterContextSchema<T>["result"]) => VigorRetryContextSchema<any>["result"];
+    };
+    retryIf: {
+        _mode: "fluent";
+        func: (err: VigorRetryContextSchema<T>["error"]) => VigorRetryContextSchema<any>["flags"]["doRetry"];
+    };
+    onRetry: {
+        _mode: "fluent";
+        func: (err: VigorRetryContextSchema<T>["error"]) => void;
+    };
+    onError: {
+        _mode: "fluent";
+        func: (err: VigorRetryContextSchema<T>["error"]) => void;
+    };
+};
+type VigorRetryPolicyMiddlewaresApi<T extends VigorRetrySchema<T>> = {
+    setResult: (res: VigorRetryContextSchema<any>["result"]) => void;
+    throwError: (err: VigorRetryContextSchema<any>["error"]) => void;
+    abort: (err: VigorRetryContextSchema<any>["error"]) => void;
+    breakRetry: (err: VigorRetryContextSchema<any>["error"]) => void;
+    proceedRetry: () => void;
+    cancelRetry: () => void;
+    setDelay: (num: VigorRetryContextSchema<any>["system"]["delay"]) => void;
+    proceedRestart: () => void;
+    cancelRestart: () => void;
+};
+type VigorRetryPolicyMiddlewaresIntercept<T extends VigorRetrySchema<T>> = {
+    __brand: VigorBrand<"Retry", "Policy<Middlewares<Intercept<Schema">;
+    before: {
+        _mode: "intercept";
+        func: (ctx: VigorRetryBeforeContextSchema<T>, api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "abort" | "throwError" | "breakRetry">) => VigorRetryContextSchema<any> | Promise<VigorRetryContextSchema<any>>;
+    };
+    after: {
+        _mode: "intercept";
+        func: (ctx: VigorRetryAfterContextSchema<T>, api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "throwError">) => VigorRetryContextSchema<any> | Promise<VigorRetryContextSchema<any>>;
+    };
+    onResult: {
+        _mode: "intercept";
+        func: (ctx: VigorRetryAfterContextSchema<T>, api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorRetryContextSchema<any> | Promise<VigorRetryContextSchema<any>>;
+    };
+    retryIf: {
+        _mode: "intercept";
+        func: (ctx: VigorRetryContextSchema<T>, api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "proceedRetry" | "cancelRetry">) => VigorRetryContextSchema<any> | Promise<VigorRetryContextSchema<any>>;
+    };
+    onRetry: {
+        _mode: "intercept";
+        func: (ctx: VigorRetryContextSchema<T>, api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "throwError" | "setDelay">) => VigorRetryContextSchema<any> | Promise<VigorRetryContextSchema<any>>;
+    };
+    onError: {
+        _mode: "intercept";
+        func: (ctx: VigorRetryContextSchema<T>, api: Pick<VigorRetryPolicyMiddlewaresApi<T>, "setResult" | "throwError" | "proceedRestart" | "cancelRestart">) => VigorRetryContextSchema<any> | Promise<VigorRetryContextSchema<any>>;
+    };
+};
+/**
+ * Immutable builder for a retry policy's middleware pipeline (`before`,
+ * `after`, `onResult`, `retryIf`, `onRetry`, `onError`). Each stage accepts
+ * either "fluent" middleware (returns a plain value merged into the
+ * context) or "intercept" middleware (receives an explicit API to mutate
+ * control flow).
+ */
+declare class VigorRetryPolicyMiddlewares<T extends VigorRetrySchema<T> = typeof VigorRetryBase> extends VigorStatus<VigorRetrySchema<any>, T, VigorRetryPolicyMiddlewaresTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorAllPolicySettingsTypeLambda, C>;
-    /** Sets the maximum number of tasks run concurrently. */
-    concurrency<const N extends VigorAllSchema<any>["policy"]["settings"]["concurrency"]>(num: N): VigorAllPolicySettings<VigorAllIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, C>;
+    /** Registers a middleware that runs before the retried target is invoked. */
+    before<const N extends VigorRetryPolicyMiddlewaresFluent<T>["before"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                before: [{
+                    _mode: "fluent";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    before<const N extends VigorRetryPolicyMiddlewaresIntercept<T>["before"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                before: [{
+                    _mode: "intercept";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    /** Registers a middleware that runs after the retried target settles. */
+    after<const N extends VigorRetryPolicyMiddlewaresFluent<T>["after"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                after: [{
+                    _mode: "fluent";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    after<const N extends VigorRetryPolicyMiddlewaresIntercept<T>["after"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                after: [{
+                    _mode: "intercept";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    /** Registers a middleware to transform or validate the retry's result. */
+    onResult<const N extends VigorRetryPolicyMiddlewaresFluent<T>["onResult"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                onResult: [{
+                    _mode: "fluent";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    onResult<const N extends VigorRetryPolicyMiddlewaresIntercept<T>["onResult"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                onResult: [{
+                    _mode: "intercept";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    /** Registers a middleware that decides whether a failed attempt should be retried. */
+    retryIf<const N extends VigorRetryPolicyMiddlewaresFluent<T>["retryIf"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                retryIf: [{
+                    _mode: "fluent";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    retryIf<const N extends VigorRetryPolicyMiddlewaresIntercept<T>["retryIf"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                retryIf: [{
+                    _mode: "intercept";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    /** Registers a middleware invoked right before a retry attempt is scheduled. */
+    onRetry<const N extends VigorRetryPolicyMiddlewaresFluent<T>["onRetry"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                onRetry: [{
+                    _mode: "fluent";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    onRetry<const N extends VigorRetryPolicyMiddlewaresIntercept<T>["onRetry"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                onRetry: [{
+                    _mode: "intercept";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    /** Registers a middleware invoked when retries/restarts are exhausted. */
+    onError<const N extends VigorRetryPolicyMiddlewaresFluent<T>["onError"]["func"]>(type: "fluent", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                onError: [{
+                    _mode: "fluent";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+    onError<const N extends VigorRetryPolicyMiddlewaresIntercept<T>["onError"]["func"]>(type: "intercept", func: N): VigorApply<VigorRetryPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+        policy: {
+            middlewares: {
+                onError: [{
+                    _mode: "intercept";
+                    func: N;
+                }];
+            };
+        };
+    }>>;
+}
+type VigorRetryPipeInitialContext<T extends VigorRetrySchema<T>, R = VigorCastResult<T["cast"], VigorReturnType<T["policy"]["target"]>>> = VigorDeepMerge<Omit<VigorRetryContextSchema<T, unknown>, "result">, {
+    result: R;
+}>;
+type VigorRetryPipeStepVoid<Ctx, Arr> = Arr extends [infer Head, ...infer Tail] ? Head extends {
+    _mode: "intercept";
+    func: (...args: any[]) => infer Ret;
+} ? VigorRetryPipeStepVoid<Ret, Tail> : VigorRetryPipeStepVoid<Ctx, Tail> : Ctx;
+type VigorRetryPipeStepResult<Ctx, Arr> = Arr extends [infer Head, ...infer Tail] ? Head extends {
+    _mode: "intercept";
+    func: (...args: any[]) => infer Ret;
+} ? VigorRetryPipeStepResult<Ret, Tail> : Head extends {
+    _mode: "fluent";
+    func: (...args: any[]) => infer FR;
+} ? VigorRetryPipeStepResult<VigorDeepMerge<Ctx, {
+    result: FR;
+}>, Tail> : VigorRetryPipeStepResult<Ctx, Tail> : Ctx;
+type VigorRetryPipeStepRetryIf<Ctx, Arr> = Arr extends [infer Head, ...infer Tail] ? Head extends {
+    _mode: "intercept";
+    func: (...args: any[]) => infer Ret;
+} ? VigorRetryPipeStepRetryIf<Ret, Tail> : Head extends {
+    _mode: "fluent";
+    func: (...args: any[]) => infer FR;
+} ? VigorRetryPipeStepRetryIf<VigorDeepMerge<Ctx, {
+    flags: {
+        doRetry: FR;
+    };
+}>, Tail> : VigorRetryPipeStepRetryIf<Ctx, Tail> : Ctx;
+type VigorRetryPolicyMiddlewaresPipe<T extends VigorRetrySchema<T>> = VigorRetryPipeStepVoid<VigorRetryPipeStepVoid<VigorRetryPipeStepRetryIf<VigorRetryPipeStepResult<VigorRetryPipeStepVoid<VigorRetryPipeStepVoid<VigorRetryPipeInitialContext<T>, T["policy"]["middlewares"]["before"]>, T["policy"]["middlewares"]["after"]>, T["policy"]["middlewares"]["onResult"]>, T["policy"]["middlewares"]["retryIf"]>, T["policy"]["middlewares"]["onRetry"]>, T["policy"]["middlewares"]["onError"]>;
+type VigorRetryPipeResult<T extends VigorRetrySchema<T>> = VigorRetryPolicyMiddlewaresPipe<T> extends {
+    result: infer R;
+} ? R : never;
+
+/**
+ * Base shape shared by every retry context variant. `R` is the type of
+ * `result` at the point the context is observed — it differs by pipeline
+ * stage (before / after / onResult / ...), so callers plug in whichever
+ * `R` matches where they are in the pipeline instead of this being fixed
+ * on the schema.
+ */
+type VigorRetryContextSchema<T extends VigorRetrySchema<T>, R = VigorRetryPipeResult<T> | VigorDefaultType> = {
+    __brand: VigorBrand<"Retry", "Context<Schema">;
+    result: R;
+    error: unknown;
+    system: {
+        delay: number | VigorDefaultType;
+        attempt: number;
+    };
+    flags: {
+        doRetry: boolean;
+        doRestart: boolean;
+        brokeRetry: boolean;
+        overridden: boolean;
+    };
+    record: Record<string, any>;
+    policy: T["policy"];
+};
+/** Context shape seen by `before` middlewares — the target hasn't run yet, so there's no result. */
+type VigorRetryBeforeContextSchema<T extends VigorRetrySchema<T>> = VigorRetryContextSchema<T, VigorDefaultType>;
+/** Context shape seen by `after` / `onResult` middlewares — the target has settled. */
+type VigorRetryAfterContextSchema<T extends VigorRetrySchema<T>> = VigorRetryContextSchema<T, VigorRetryPipeInitialContext<T>["result"]>;
+
+type VigorRetryPolicySettingsSchema<T extends VigorRetrySchema<T>> = {
+    __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+    default: ((ctx: VigorRetryContextSchema<T>) => any | Promise<any>) | VigorEmptyType;
+    maxAttempts: number;
+    maxRestarts: number;
+    timeout: number;
+};
+declare const VigorRetryPolicySettingsBase: {
+    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+    readonly default: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+    readonly maxAttempts: 5;
+    readonly maxRestarts: 3;
+    readonly timeout: 20000;
+};
+/** Immutable builder for a retry policy's general settings. */
+declare class VigorRetryPolicySettings<T extends VigorRetrySchema<T> = typeof VigorRetryBase> extends VigorStatus<VigorRetrySchema<any>, T, VigorRetryPolicySettingsTypeLambda> {
+    constructor(config?: T);
+    protected _create<C>(config: C): VigorApply<VigorRetryPolicySettingsTypeLambda, C>;
+    /** Sets the fallback value/factory used when the target ultimately fails. */
+    default<const N extends VigorExcludeEmpty<VigorRetrySchema<any>["policy"]["settings"]["default"]>>(func: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly concurrency: N;
+                readonly default: N;
             };
         };
     }>>>;
-    /** When enabled, filters the final result down to only the tasks that succeeded. */
-    onlySuccess<const N extends VigorAllSchema<any>["policy"]["settings"]["onlySuccess"]>(bool: N): VigorAllPolicySettings<VigorAllIn<VigorDeepMerge<T, {
+    /** Sets the maximum number of retry attempts before giving up. */
+    maxAttempts<const N extends VigorRetrySchema<any>["policy"]["settings"]["maxAttempts"]>(num: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly onlySuccess: N;
+                readonly maxAttempts: N;
+            };
+        };
+    }>>>;
+    /** Sets the maximum number of full restarts allowed. */
+    maxRestarts<const N extends VigorRetrySchema<any>["policy"]["settings"]["maxRestarts"]>(num: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly settings: {
+                readonly maxRestarts: N;
+            };
+        };
+    }>>>;
+    /** Sets the timeout, in milliseconds, for a single attempt. */
+    timeout<const N extends VigorRetrySchema<any>["policy"]["settings"]["timeout"]>(num: N): VigorRetryPolicySettings<VigorRetryIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly settings: {
+                readonly timeout: N;
             };
         };
     }>>>;
 }
 
-type VigorAllTask = () => unknown | Promise<unknown>;
-type VigorAllPolicySchema<T extends VigorAllSchema<T>> = {
-    __brand: VigorBrand<"All", "Policy<Schema">;
-    target: VigorAllTask[];
-    settings: VigorAllPolicySettingsSchema<T>;
-    middlewares: VigorAllPolicyMiddlewaresSchema<T>;
+type VigorRetryIn<T> = T extends VigorRetrySchema<any> ? T : never;
+type VigorRetryAlgorithmsConstantIn<T> = T extends VigorRetryPolicyAlgorithmsConstantSchema<any> ? T : never;
+type VigorRetryAlgorithmsLinearIn<T> = T extends VigorRetryPolicyAlgorithmsLinearSchema<any> ? T : never;
+type VigorRetryAlgorithmsBackoffIn<T> = T extends VigorRetryPolicyAlgorithmsBackoffSchema<any> ? T : never;
+type VigorRetryAlgorithmsCustomIn<T> = T extends VigorRetryPolicyAlgorithmsCustomSchema<any> ? T : never;
+interface VigorRetryTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetry<VigorRetryIn<this["In"]>>;
+}
+interface VigorRetryPolicySettingsTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicySettings<VigorRetryIn<this["In"]>>;
+}
+interface VigorRetryPolicyMiddlewaresTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicyMiddlewares<VigorRetryIn<this["In"]>>;
+}
+interface VigorRetryPolicyAlgorithmsTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicyAlgorithms<VigorRetryIn<this["In"]>>;
+}
+interface VigorRetryPolicyAlgorithmsConstantTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicyAlgorithmsConstant<VigorRetryAlgorithmsConstantIn<this["In"]>>;
+}
+interface VigorRetryPolicyAlgorithmsLinearTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicyAlgorithmsLinear<VigorRetryAlgorithmsLinearIn<this["In"]>>;
+}
+interface VigorRetryPolicyAlgorithmsBackoffTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicyAlgorithmsBackoff<VigorRetryAlgorithmsBackoffIn<this["In"]>>;
+}
+interface VigorRetryPolicyAlgorithmsCustomTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorRetryPolicyAlgorithmsCustom<VigorRetryAlgorithmsCustomIn<this["In"]>>;
+}
+
+type VigorRetryPolicySchema<T extends VigorRetrySchema<T>> = {
+    __brand: VigorBrand<"Retry", "Policy<Schema">;
+    target: ((signal: AbortSignal) => any | Promise<any>) | VigorEmptyType;
+    abortSignals: AbortSignal[];
+    settings: VigorRetryPolicySettingsSchema<T>;
+    middlewares: VigorRetryPolicyMiddlewaresSchema<T>;
+    algorithms: VigorRetryPolicyAlgorithmsSchema<T>;
 };
-declare const VigorAllPolicyBase: {
-    readonly __brand: VigorBrand<"All", "Policy<Schema">;
-    readonly target: VigorAllTask[];
+declare const VigorRetryPolicyBase: {
+    readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
+    readonly target: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+    readonly abortSignals: [];
     readonly settings: {
-        readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-        readonly concurrency: 5;
-        readonly onlySuccess: false;
+        readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+        readonly default: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
+        };
+        readonly maxAttempts: 5;
+        readonly maxRestarts: 3;
+        readonly timeout: 20000;
     };
     readonly middlewares: {
-        readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-        readonly before: VigorAllEachMiddlewareFn[];
-        readonly after: VigorAllEachMiddlewareFn[];
-        readonly onError: VigorAllEachOnErrorFn[];
+        readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+        readonly before: [];
+        readonly after: [];
+        readonly onResult: [];
+        readonly retryIf: [];
+        readonly onRetry: [];
+        readonly onError: [];
     };
-};
-
-type VigorAllContextSchema<T extends VigorAllSchema<T>> = {
-    __brand: VigorBrand<"All", "Context<Schema">;
-    result: unknown[] | VigorDefaultType;
-    policy: T["policy"];
-    record: Record<string, any>;
-};
-type VigorAllEachContextSchema<T extends VigorAllSchema<T>> = {
-    __brand: VigorBrand<"All", "EachContext<Schema">;
-    result: unknown | VigorDefaultType;
-    error: unknown;
-    flags: {
-        overrided: boolean;
+    readonly algorithms: {
+        readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+        readonly _tag: "constant";
+        readonly jitter: 1000;
+        readonly interval: 2000;
+        readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
     };
-    record: Record<string, any>;
 };
 
-type VigorAllSchema<T extends VigorAllSchema<T>> = {
-    __brand: VigorBrand<"All", "Schema">;
-    policy: VigorAllPolicySchema<T>;
-    context: VigorAllContextSchema<T>;
+type VigorRetrySchema<T extends VigorRetrySchema<T>> = {
+    __brand: VigorBrand<"Retry", "Schema">;
+    policy: VigorRetryPolicySchema<T>;
+    /** Type-level override for the resolved result type, set via `.cast<T>()`. */
+    cast: unknown;
 };
-declare const VigorAllBase: {
-    readonly __brand: VigorBrand<"All", "Schema">;
+declare const VigorRetryBase: {
+    readonly __brand: VigorBrand<"Retry", "Schema">;
     readonly policy: {
-        readonly __brand: VigorBrand<"All", "Policy<Schema">;
-        readonly target: VigorAllTask[];
-        readonly settings: {
-            readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-            readonly concurrency: 5;
-            readonly onlySuccess: false;
+        readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
+        readonly target: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
         };
-        readonly middlewares: {
-            readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-            readonly before: VigorAllEachMiddlewareFn[];
-            readonly after: VigorAllEachMiddlewareFn[];
-            readonly onError: VigorAllEachOnErrorFn[];
+        readonly abortSignals: [];
+        readonly settings: {
+            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+            readonly default: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
+            };
+            readonly maxAttempts: 5;
+            readonly maxRestarts: 3;
+            readonly timeout: 20000;
         };
-    };
-    readonly context: {
-        readonly __brand: VigorBrand<"All", "Context<Schema">;
-        readonly result: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
+        readonly middlewares: {
+            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+            readonly before: [];
+            readonly after: [];
+            readonly onResult: [];
+            readonly retryIf: [];
+            readonly onRetry: [];
+            readonly onError: [];
         };
-        readonly policy: {
-            readonly __brand: VigorBrand<"All", "Policy<Schema">;
-            readonly target: VigorAllTask[];
-            readonly settings: {
-                readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-                readonly concurrency: 5;
-                readonly onlySuccess: false;
-            };
-            readonly middlewares: {
-                readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-                readonly before: VigorAllEachMiddlewareFn[];
-                readonly after: VigorAllEachMiddlewareFn[];
-                readonly onError: VigorAllEachOnErrorFn[];
-            };
+        readonly algorithms: {
+            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+            readonly _tag: "constant";
+            readonly jitter: 1000;
+            readonly interval: 2000;
+            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
         };
-        readonly record: {};
+    };
+    readonly cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
     };
 };
 /**
- * Immutable builder that runs a list of independent tasks with bounded
- * concurrency, per-task middleware, and either an all-results or
- * only-successes result mode.
+ * Immutable builder that executes a target function with retry, restart,
+ * timeout, and abort support, driven by a configurable delay algorithm and
+ * middleware pipeline.
  */
-declare class VigorAll<T extends VigorAllSchema<T> = typeof VigorAllBase> extends VigorStatus<VigorAllSchema<T>, T, VigorAllTypeLambda> {
+declare class VigorRetry<T extends VigorRetrySchema<T> = typeof VigorRetryBase> extends VigorStatus<VigorRetrySchema<T>, T, VigorRetryTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorAllTypeLambda, C>;
-    /** Sets the list of tasks to run. */
-    target<const N extends VigorAllTask[]>(...funcs: N): VigorAll<VigorAllIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorRetryTypeLambda, C>;
+    /** Sets the target function to invoke, with retry/timeout applied. */
+    target<const N extends VigorExcludeEmpty<VigorRetrySchema<T>["policy"]["target"]>>(func: N): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly target: N;
         };
     }>>>;
-    /** Configures the all-policy's general settings (concurrency, onlySuccess). */
-    settings<const N extends VigorDeepPartial<VigorAllPolicySettingsSchema<T>>, R extends VigorAllSchema<any>>(input: N | ((s: VigorAllPolicySettings<T>) => VigorAllPolicySettings<R>) | VigorAllPolicySettings<R>): VigorAll<VigorAllIn<VigorDeepMerge<T, {
+    /** Sets external abort signals that, when aborted, stop retrying. */
+    abortSignals<const N extends VigorRetrySchema<T>["policy"]["abortSignals"]>(...sig: N): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly settings: VigorAllPolicySettingsSchema<any>;
+            readonly abortSignals: N;
         };
     }>>>;
-    /** Configures the all-policy's per-task middleware pipeline. */
-    middlewares<const N extends VigorDeepPartial<VigorAllPolicyMiddlewaresSchema<T>>, R extends VigorAllSchema<any>>(input: N | ((s: VigorAllPolicyMiddlewares<T>) => VigorAllPolicyMiddlewares<R>) | VigorAllPolicyMiddlewares<R>): VigorAll<VigorAllIn<VigorDeepMerge<T, {
+    /** Configures the retry policy's general settings (max attempts, timeout, etc). */
+    settings<const N extends VigorDeepPartial<VigorRetryPolicySettingsSchema<T>>, R extends VigorRetrySchema<any>>(input: N | ((s: VigorRetryPolicySettings<T>) => VigorRetryPolicySettings<R>) | VigorRetryPolicySettings<R>): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly middlewares: VigorAllPolicyMiddlewaresSchema<any>;
+            readonly settings: VigorRetryPolicySettingsSchema<any>;
         };
     }>>>;
-    /** Runs a single task through the before/after/onError middleware pipeline. */
-    private _runTask;
-    /** Runs all tasks and returns the results array directly, throwing on final failure. */
-    request<R extends unknown[] = unknown[]>(): Promise<R>;
-    /** Runs all tasks and returns a result/error envelope instead of throwing. */
-    requestVerbose<R extends unknown[] = unknown[]>(): Promise<{
+    /** Configures the retry policy's middleware pipeline. */
+    middlewares<const N extends VigorDeepPartial<VigorRetryPolicyMiddlewaresSchema<T>>, R extends VigorRetrySchema<any>>(input: N | ((s: VigorRetryPolicyMiddlewares<T>) => VigorRetryPolicyMiddlewares<R>) | VigorRetryPolicyMiddlewares<R>): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly middlewares: VigorRetryPolicyMiddlewaresSchema<any>;
+        };
+    }>>>;
+    /** Configures the retry policy's delay algorithm. */
+    algorithms<const N extends VigorDeepPartial<VigorRetryPolicyAlgorithmsSchema<T>>, R extends VigorRetrySchema<any>>(input: N | ((a: VigorRetryPolicyAlgorithms<T>) => VigorRetryPolicyAlgorithms<R> | VigorRetryPolicyAlgorithmsConstant<any>)): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly algorithms: any;
+        };
+    }>>>;
+    /**
+     * Overrides the resolved result type with `T`, taking priority over the
+     * type naturally inferred from `target()`. Can be called before or after
+     * `target()` (or any other configuration method); whichever `.cast<T>()`
+     * call happens last wins.
+     */
+    cast<const C>(): VigorRetry<VigorRetryIn<VigorDeepMerge<T, {
+        cast: C;
+    }>>>;
+    /** Runs the target and returns its result directly, throwing on final failure. */
+    request<R = VigorCastResult<T["cast"], VigorRetryContextSchema<T>["result"]>>(): Promise<R>;
+    /** Runs the target and returns a result/error envelope instead of throwing. */
+    requestVerbose<R = VigorCastResult<T["cast"], VigorRetryContextSchema<T>["result"]>>(): Promise<{
         success: false;
         data: null;
         error: unknown;
@@ -1514,215 +1306,244 @@ declare class VigorAll<T extends VigorAllSchema<T> = typeof VigorAllBase> extend
         data: R;
         error: null;
     }>;
-    /** Internal execution loop implementing the bounded-concurrency worker pool. */
+    /** Internal execution loop implementing the attempt/retry/restart lifecycle. */
     private requestRuntime;
 }
 
-type VigorAllIn<T> = T extends VigorAllSchema<any> ? T : never;
-interface VigorAllTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorAll<VigorAllIn<this["In"]>>;
-}
-interface VigorAllPolicySettingsTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorAllPolicySettings<VigorAllIn<this["In"]>>;
-}
-interface VigorAllPolicyMiddlewaresTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorAllPolicyMiddlewares<VigorAllIn<this["In"]>>;
-}
-
-type VigorAllEachMiddlewareFn = (ctx: VigorAllEachContextSchema<any>) => void | Promise<void>;
-type VigorAllEachOnErrorFn = (ctx: VigorAllEachContextSchema<any>, api: {
-    setResult: (r: unknown) => void;
-}) => void | Promise<void>;
-type VigorAllPolicyMiddlewaresSchema<T extends VigorAllSchema<T>> = {
-    __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-    before: VigorAllEachMiddlewareFn[];
-    after: VigorAllEachMiddlewareFn[];
-    onError: VigorAllEachOnErrorFn[];
+type VigorParseStrategyFunc = (response: Response) => Promise<any>;
+type VigorParsePolicyStrategiesSchema<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+    funcs: Array<VigorParseStrategyFunc>;
 };
-declare const VigorAllPolicyMiddlewaresBase: {
-    readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-    readonly before: VigorAllEachMiddlewareFn[];
-    readonly after: VigorAllEachMiddlewareFn[];
-    readonly onError: VigorAllEachOnErrorFn[];
+declare const VigorParsePolicyStrategiesBase: {
+    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+    readonly funcs: VigorParseStrategyFunc[];
 };
-/** Immutable builder for an all-policy's per-task middleware pipeline (`before`, `after`, `onError`). */
-declare class VigorAllPolicyMiddlewares<T extends VigorAllSchema<T> = typeof VigorAllBase> extends VigorStatus<VigorAllSchema<any>, T, VigorAllPolicyMiddlewaresTypeLambda> {
+/** Parses a response by matching its `Content-Type` header against a known parser table. */
+declare const VigorParseContentTypeStrategy: VigorParseStrategyFunc;
+/** Parses a response by trying a sequence of body-reading methods until one succeeds. */
+declare const VigorParseSniffStrategy: VigorParseStrategyFunc;
+/** Immutable builder for a parse policy's fallback chain of parsing strategies. */
+declare class VigorParsePolicyStrategies<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<any>, T, VigorParsePolicyStrategiesTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorAllPolicyMiddlewaresTypeLambda, C>;
-    /** Registers a middleware that runs before each task is invoked. */
-    before<const N extends VigorAllEachMiddlewareFn>(func: N): VigorAllPolicyMiddlewares<VigorAllIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorParsePolicyStrategiesTypeLambda, C>;
+    /**
+     * Adds strategy functions to the fallback chain.
+     *
+     * @param replace - When `true`, replaces the existing chain instead of
+     *  appending to it (the default is to concat, since strategies are
+     *  tried in sequence as a fallback chain).
+     */
+    private _set;
+    /** Adds the content-type based parsing strategy. */
+    contentType(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly middlewares: {
-                readonly before: readonly [N];
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
             };
         };
     }>>>;
-    /** Registers a middleware that runs after each task settles successfully. */
-    after<const N extends VigorAllEachMiddlewareFn>(func: N): VigorAllPolicyMiddlewares<VigorAllIn<VigorDeepMerge<T, {
+    /** Adds the sniffing (try-each-method) parsing strategy. */
+    sniff(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly middlewares: {
-                readonly after: readonly [N];
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
             };
         };
     }>>>;
-    /** Registers a middleware that runs when an individual task fails. */
-    onError<const N extends VigorAllEachOnErrorFn>(func: N): VigorAllPolicyMiddlewares<VigorAllIn<VigorDeepMerge<T, {
+    /** Adds a strategy that always parses the response as JSON. */
+    json(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
         readonly policy: {
-            readonly middlewares: {
-                readonly onError: readonly [N];
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
+            };
+        };
+    }>>>;
+    /** Adds a strategy that always parses the response as text. */
+    text(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
+            };
+        };
+    }>>>;
+    /** Adds a strategy that always parses the response as an `ArrayBuffer`. */
+    arrayBuffer(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
+            };
+        };
+    }>>>;
+    /** Adds a strategy that always parses the response as a `Blob`. */
+    blob(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
+            };
+        };
+    }>>>;
+    /** Adds a strategy that always parses the response as a `Uint8Array`. */
+    bytes(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
+            };
+        };
+    }>>>;
+    /** Adds a strategy that always parses the response as `FormData`. */
+    formData(replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
+            };
+        };
+    }>>>;
+    /** Adds a user-supplied custom parsing strategy. */
+    custom<const N extends VigorParseStrategyFunc>(func: N, replace?: boolean): VigorParsePolicyStrategies<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: {
+                readonly funcs: VigorParseStrategyFunc[];
             };
         };
     }>>>;
 }
 
-type VigorFetchPolicySettingsSchema<T extends VigorFetchSchema<T>> = {
-    __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
-    retryHeaders: string[];
-    unretryStatus: number[];
+/**
+ * Base shape shared by every parse context variant. `R` is the type of
+ * `result` at the point the context is observed — computed per pipeline
+ * stage instead of being fixed on the schema.
+ */
+type VigorParseContextSchema<T extends VigorParseSchema<T>, R = VigorCastResult<T["cast"], unknown> | VigorDefaultType> = {
+    __brand: VigorBrand<"Parse", "Context<Schema">;
+    result: R;
+    error: unknown;
+    response: VigorParsePolicySchema<T>["target"];
+    flags: {
+        overrided: boolean;
+        restarted: boolean;
+    };
+    record: Record<string, any>;
+    policy: T["policy"];
+};
+/** Context shape seen by `before` middlewares — parsing hasn't run yet. */
+type VigorParseBeforeContextSchema<T extends VigorParseSchema<T>> = VigorParseContextSchema<T, VigorDefaultType>;
+/** Context shape seen by `after` / `onResult` middlewares — a result has been produced. */
+type VigorParseAfterContextSchema<T extends VigorParseSchema<T>> = VigorParseContextSchema<T, VigorCastResult<T["cast"], unknown> | VigorDefaultType>;
+
+type VigorParsePolicySettingsSchema<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+    raw: boolean;
+    default: ((ctx: VigorParseContextSchema<T>) => any | Promise<any>) | VigorEmptyType;
     maxRestarts: number;
-    default: ((ctx: T["context"]) => any | Promise<any>) | VigorEmptyType;
 };
-declare const VigorFetchPolicySettingsBase: {
-    readonly __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
-    readonly retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
-    readonly unretryStatus: [400, 401, 403, 404, 405, 413, 422];
-    readonly maxRestarts: 3;
+declare const VigorParsePolicySettingsBase: {
+    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+    readonly raw: false;
     readonly default: symbol & {
         __brand: VigorBrand<"Core", "Symbol_Empty">;
     };
+    readonly maxRestarts: 3;
 };
-/** Immutable builder for a fetch policy's general settings. */
-declare class VigorFetchPolicySettings<T extends VigorFetchSchema<T> = typeof VigorFetchBase> extends VigorStatus<VigorFetchSchema<any>, T, VigorFetchPolicySettingsTypeLambda> {
+/** Immutable builder for a parse policy's general settings. */
+declare class VigorParsePolicySettings<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<any>, T, VigorParsePolicySettingsTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorFetchPolicySettingsTypeLambda, C>;
-    /** Sets response headers consulted to compute a server-suggested retry delay. */
-    retryHeaders<const N extends VigorFetchSchema<any>["policy"]["settings"]["retryHeaders"]>(...strs: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
-        readonly policy: {
-            readonly settings: {
-                readonly retryHeaders: N;
-            };
-        };
-    }>>>;
-    /** Sets HTTP status codes that should never be retried. */
-    unretryStatus<const N extends VigorFetchSchema<any>["policy"]["settings"]["unretryStatus"]>(...nums: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorParsePolicySettingsTypeLambda, C>;
+    /** When enabled, skips content-type based parsing and returns the raw response. */
+    raw<const N extends VigorParseSchema<any>["policy"]["settings"]["raw"]>(bool: N): VigorParsePolicySettings<VigorParseIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly unretryStatus: N;
+                readonly raw: N;
             };
         };
     }>>>;
-    /** Sets the maximum number of full restarts allowed. */
-    maxRestarts<const N extends VigorFetchSchema<any>["policy"]["settings"]["maxRestarts"]>(num: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
+    /** Sets the fallback value/factory used when parsing ultimately fails. */
+    default<const N extends VigorExcludeEmpty<VigorParseSchema<any>["policy"]["settings"]["default"]>>(func: N): VigorParsePolicySettings<VigorParseIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly maxRestarts: N;
+                readonly default: N;
             };
         };
-    }>>>;
-    /** Sets the fallback value/factory used when the request ultimately fails. */
-    default<const N extends VigorExcludeEmpty<VigorFetchSchema<any>["policy"]["settings"]["default"]>>(func: N): VigorFetchPolicySettings<VigorFetchIn<VigorDeepMerge<T, {
+    }>>>;
+    /** Sets the maximum number of full restarts allowed. */
+    maxRestarts<const N extends VigorParseSchema<any>["policy"]["settings"]["maxRestarts"]>(num: N): VigorParsePolicySettings<VigorParseIn<VigorDeepMerge<T, {
         readonly policy: {
             readonly settings: {
-                readonly default: N;
+                readonly maxRestarts: N;
             };
         };
     }>>>;
 }
 
-type VigorFetchExtraOptions = Omit<RequestInit, "method" | "headers" | "body" | "signal">;
-type VigorFetchOptions = VigorFetchExtraOptions & {
-    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS" | "CONNECT" | "TRACE";
-    headers: Record<string, string>;
-    body?: BodyInit | null;
-    signal?: AbortSignal;
-};
-type VigorFetchContextSchema<T extends VigorFetchSchema<T>> = {
-    __brand: VigorBrand<"Fetch", "Context<Schema">;
-    href: string;
-    response: Response | VigorDefaultType;
-    result: unknown | VigorDefaultType;
-    error: unknown;
-    options: VigorFetchOptions | VigorDefaultType;
-    flags: {
-        overrided: boolean;
-        restarted: boolean;
-    };
-    record: Record<string, any>;
-    policy: T["policy"];
-};
-
-type VigorFetchPolicyMiddlewaresSchema<T extends VigorFetchSchema<T>> = {
-    __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
-    before: (VigorFetchPolicyMiddlewaresFluent<T>["before"] | VigorFetchPolicyMiddlewaresIntercept<T>["before"])[];
-    after: (VigorFetchPolicyMiddlewaresFluent<T>["after"] | VigorFetchPolicyMiddlewaresIntercept<T>["after"])[];
-    onResult: (VigorFetchPolicyMiddlewaresFluent<T>["onResult"] | VigorFetchPolicyMiddlewaresIntercept<T>["onResult"])[];
-    onError: (VigorFetchPolicyMiddlewaresFluent<T>["onError"] | VigorFetchPolicyMiddlewaresIntercept<T>["onError"])[];
+type VigorParsePolicyMiddlewaresSchema<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
+    before: (VigorParsePolicyMiddlewaresFluent<T>["before"] | VigorParsePolicyMiddlewaresIntercept<T>["before"])[];
+    after: (VigorParsePolicyMiddlewaresFluent<T>["after"] | VigorParsePolicyMiddlewaresIntercept<T>["after"])[];
+    onResult: (VigorParsePolicyMiddlewaresFluent<T>["onResult"] | VigorParsePolicyMiddlewaresIntercept<T>["onResult"])[];
+    onError: (VigorParsePolicyMiddlewaresFluent<T>["onError"] | VigorParsePolicyMiddlewaresIntercept<T>["onError"])[];
 };
-declare const VigorFetchPolicyMiddlewaresBase: {
-    readonly __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
+declare const VigorParsePolicyMiddlewaresBase: {
+    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
     readonly before: [];
     readonly after: [];
     readonly onResult: [];
     readonly onError: [];
 };
-type VigorFetchPolicyMiddlewaresFluent<T extends VigorFetchSchema<T>> = {
-    __brand: VigorBrand<"Fetch", "Policy<Middlewares<Fluent<Schema">;
+type VigorParsePolicyMiddlewaresFluent<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Policy<Middlewares<Fluent<Schema">;
     before: {
         _mode: "fluent";
-        func: (ctx: T["context"]) => void;
+        func: (ctx: VigorParseBeforeContextSchema<T>) => void;
     };
     after: {
         _mode: "fluent";
-        func: (ctx: T["context"]) => void;
+        func: (ctx: VigorParseAfterContextSchema<T>) => void;
     };
     onResult: {
         _mode: "fluent";
-        func: (res: T["context"]["result"]) => VigorFetchSchema<any>["context"]["result"];
+        func: (res: VigorParseAfterContextSchema<T>["result"]) => VigorParseContextSchema<any>["result"];
     };
     onError: {
         _mode: "fluent";
-        func: (err: T["context"]["error"]) => void;
+        func: (err: VigorParseContextSchema<T>["error"]) => void;
     };
 };
-type VigorFetchPolicyMiddlewaresApi<T extends VigorFetchSchema<T>> = {
-    setResult: (res: VigorFetchSchema<any>["context"]["result"]) => void;
-    throwError: (err: VigorFetchSchema<any>["context"]["error"]) => void;
-    setOptions: (opts: VigorFetchOptions) => void;
-    setHeaders: (headers: VigorFetchOptions["headers"]) => void;
-    setBody: (body: VigorFetchOptions["body"]) => void;
+type VigorParsePolicyMiddlewaresApi<T extends VigorParseSchema<T>> = {
+    setResult: (res: VigorParseContextSchema<any>["result"]) => void;
+    throwError: (err: VigorParseContextSchema<any>["error"]) => void;
     proceedRestart: () => void;
     cancelRestart: () => void;
 };
-type VigorFetchPolicyMiddlewaresIntercept<T extends VigorFetchSchema<T>> = {
-    __brand: VigorBrand<"Fetch", "Policy<Middlewares<Intercept<Schema">;
+type VigorParsePolicyMiddlewaresIntercept<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Policy<Middlewares<Intercept<Schema">;
     before: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "throwError" | "setOptions" | "setHeaders" | "setBody">) => VigorFetchSchema<any>["context"] | Promise<VigorFetchSchema<any>["context"]>;
+        func: (ctx: VigorParseBeforeContextSchema<T>, api: Pick<VigorParsePolicyMiddlewaresApi<T>, "throwError">) => VigorParseContextSchema<any> | Promise<VigorParseContextSchema<any>>;
     };
     after: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorFetchSchema<any>["context"] | Promise<VigorFetchSchema<any>["context"]>;
+        func: (ctx: VigorParseAfterContextSchema<T>, api: Pick<VigorParsePolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorParseContextSchema<any> | Promise<VigorParseContextSchema<any>>;
     };
     onResult: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorFetchSchema<any>["context"] | Promise<VigorFetchSchema<any>["context"]>;
+        func: (ctx: VigorParseAfterContextSchema<T>, api: Pick<VigorParsePolicyMiddlewaresApi<T>, "setResult" | "throwError">) => VigorParseContextSchema<any> | Promise<VigorParseContextSchema<any>>;
     };
     onError: {
         _mode: "intercept";
-        func: (ctx: T["context"], api: Pick<VigorFetchPolicyMiddlewaresApi<T>, "setResult" | "throwError" | "proceedRestart" | "cancelRestart">) => VigorFetchSchema<any>["context"] | Promise<VigorFetchSchema<any>["context"]>;
+        func: (ctx: VigorParseContextSchema<T>, api: Pick<VigorParsePolicyMiddlewaresApi<T>, "setResult" | "throwError" | "proceedRestart" | "cancelRestart">) => VigorParseContextSchema<any> | Promise<VigorParseContextSchema<any>>;
     };
 };
 /**
- * Immutable builder for a fetch policy's middleware pipeline (`before`,
+ * Immutable builder for a parse policy's middleware pipeline (`before`,
  * `after`, `onResult`, `onError`). Each stage accepts either "fluent"
  * middleware (returns a plain value merged into the context) or
  * "intercept" middleware (receives an explicit API to mutate control flow).
  */
-declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof VigorFetchBase> extends VigorStatus<VigorFetchSchema<any>, T, VigorFetchPolicyMiddlewaresTypeLambda> {
+declare class VigorParsePolicyMiddlewares<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<any>, T, VigorParsePolicyMiddlewaresTypeLambda> {
     constructor(config?: T);
-    protected _create<C>(config: C): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, C>;
-    /** Registers a middleware that runs before the request is sent. */
-    before<const N extends VigorFetchPolicyMiddlewaresFluent<any>["before"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    protected _create<C>(config: C): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, C>;
+    /** Registers a middleware that runs before the response is parsed. */
+    before<const N extends VigorParsePolicyMiddlewaresFluent<T>["before"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 before: [{
@@ -1732,7 +1553,7 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
             };
         };
     }>>;
-    before<const N extends VigorFetchPolicyMiddlewaresIntercept<any>["before"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    before<const N extends VigorParsePolicyMiddlewaresIntercept<T>["before"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 before: [{
@@ -1742,8 +1563,8 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
             };
         };
     }>>;
-    /** Registers a middleware that runs after the response is received. */
-    after<const N extends VigorFetchPolicyMiddlewaresFluent<any>["after"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    /** Registers a middleware that runs after the response has been parsed. */
+    after<const N extends VigorParsePolicyMiddlewaresFluent<T>["after"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 after: [{
@@ -1753,7 +1574,7 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
             };
         };
     }>>;
-    after<const N extends VigorFetchPolicyMiddlewaresIntercept<any>["after"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    after<const N extends VigorParsePolicyMiddlewaresIntercept<T>["after"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 after: [{
@@ -1764,7 +1585,7 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
         };
     }>>;
     /** Registers a middleware that transforms or validates the parsed result. */
-    onResult<const N extends VigorFetchPolicyMiddlewaresFluent<any>["onResult"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    onResult<const N extends VigorParsePolicyMiddlewaresFluent<T>["onResult"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onResult: [{
@@ -1774,7 +1595,7 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
             };
         };
     }>>;
-    onResult<const N extends VigorFetchPolicyMiddlewaresIntercept<any>["onResult"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    onResult<const N extends VigorParsePolicyMiddlewaresIntercept<T>["onResult"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onResult: [{
@@ -1784,8 +1605,8 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
             };
         };
     }>>;
-    /** Registers a middleware that runs when the request ultimately fails. */
-    onError<const N extends VigorFetchPolicyMiddlewaresFluent<any>["onError"]["func"]>(type: "fluent", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    /** Registers a middleware that runs when parsing ultimately fails. */
+    onError<const N extends VigorParsePolicyMiddlewaresFluent<T>["onError"]["func"]>(type: "fluent", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onError: [{
@@ -1795,7 +1616,7 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
             };
         };
     }>>;
-    onError<const N extends VigorFetchPolicyMiddlewaresIntercept<any>["onError"]["func"]>(type: "intercept", func: N): VigorApply<VigorFetchPolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
+    onError<const N extends VigorParsePolicyMiddlewaresIntercept<T>["onError"]["func"]>(type: "intercept", func: N): VigorApply<VigorParsePolicyMiddlewaresTypeLambda, VigorDeepMerge<T, {
         policy: {
             middlewares: {
                 onError: [{
@@ -1807,15 +1628,145 @@ declare class VigorFetchPolicyMiddlewares<T extends VigorFetchSchema<T> = typeof
     }>>;
 }
 
-type VigorFetchIn<T> = T extends VigorFetchSchema<any> ? T : never;
-interface VigorFetchTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorFetch<VigorFetchIn<this["In"]>>;
+type VigorParseIn<T> = T extends VigorParseSchema<any> ? T : never;
+interface VigorParseTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorParse<VigorParseIn<this["In"]>>;
 }
-interface VigorFetchPolicySettingsTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorFetchPolicySettings<VigorFetchIn<this["In"]>>;
+interface VigorParsePolicySettingsTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorParsePolicySettings<VigorParseIn<this["In"]>>;
 }
-interface VigorFetchPolicyMiddlewaresTypeLambda extends VigorTypeLambda {
-    readonly Target: VigorFetchPolicyMiddlewares<VigorFetchIn<this["In"]>>;
+interface VigorParsePolicyMiddlewaresTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorParsePolicyMiddlewares<VigorParseIn<this["In"]>>;
+}
+interface VigorParsePolicyStrategiesTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorParsePolicyStrategies<VigorParseIn<this["In"]>>;
+}
+
+type VigorParsePolicySchema<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Policy<Schema">;
+    target: Request | Response | VigorDefaultType;
+    settings: VigorParsePolicySettingsSchema<T>;
+    middlewares: VigorParsePolicyMiddlewaresSchema<T>;
+    strategies: VigorParsePolicyStrategiesSchema<T>;
+};
+declare const VigorParsePolicyBase: {
+    readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
+    readonly target: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Default">;
+    };
+    readonly settings: {
+        readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+        readonly raw: false;
+        readonly default: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
+        };
+        readonly maxRestarts: 3;
+    };
+    readonly middlewares: {
+        readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
+        readonly before: [];
+        readonly after: [];
+        readonly onResult: [];
+        readonly onError: [];
+    };
+    readonly strategies: {
+        readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+        readonly funcs: VigorParseStrategyFunc[];
+    };
+};
+
+type VigorParseSchema<T extends VigorParseSchema<T>> = {
+    __brand: VigorBrand<"Parse", "Schema">;
+    policy: VigorParsePolicySchema<T>;
+    /** Type-level override for the resolved result type, set via `.cast<T>()`. */
+    cast: unknown;
+};
+declare const VigorParseBase: {
+    readonly __brand: VigorBrand<"Parse", "Schema">;
+    readonly policy: {
+        readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
+        readonly target: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Default">;
+        };
+        readonly settings: {
+            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+            readonly raw: false;
+            readonly default: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
+            };
+            readonly maxRestarts: 3;
+        };
+        readonly middlewares: {
+            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
+            readonly before: [];
+            readonly after: [];
+            readonly onResult: [];
+            readonly onError: [];
+        };
+        readonly strategies: {
+            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+            readonly funcs: VigorParseStrategyFunc[];
+        };
+    };
+    readonly cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+};
+/**
+ * Immutable builder that parses an HTTP response into a result value,
+ * trying each configured strategy in sequence with an optional middleware
+ * pipeline and restart-on-failure support.
+ */
+declare class VigorParse<T extends VigorParseSchema<T> = typeof VigorParseBase> extends VigorStatus<VigorParseSchema<T>, T, VigorParseTypeLambda> {
+    constructor(config?: T);
+    protected _create<C>(config: C): VigorApply<VigorParseTypeLambda, C>;
+    /** Sets the `Response` object to parse. */
+    target<const N extends VigorParseSchema<T>["policy"]["target"]>(response: N): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly target: N;
+        };
+    }>>>;
+    /** Configures the parse policy's general settings. */
+    settings<const N extends VigorDeepPartial<VigorParsePolicySettingsSchema<T>>, R extends VigorParseSchema<any>>(input: N | ((s: VigorParsePolicySettings<T>) => VigorParsePolicySettings<R>) | VigorParsePolicySettings<R>): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly settings: VigorParsePolicySettingsSchema<any>;
+        };
+    }>>>;
+    /** Configures the parse policy's middleware pipeline. */
+    middlewares<const N extends VigorDeepPartial<VigorParsePolicyMiddlewaresSchema<T>>, R extends VigorParseSchema<any>>(input: N | ((s: VigorParsePolicyMiddlewares<T>) => VigorParsePolicyMiddlewares<R>) | VigorParsePolicyMiddlewares<R>): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly middlewares: VigorParsePolicyMiddlewaresSchema<any>;
+        };
+    }>>>;
+    /** Configures the parse policy's fallback chain of parsing strategies. */
+    strategies<const N extends VigorDeepPartial<VigorParsePolicyStrategiesSchema<T>>, R extends VigorParseSchema<any>>(input: N | ((s: VigorParsePolicyStrategies<T>) => VigorParsePolicyStrategies<R>) | VigorParsePolicyStrategies<R>): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+        readonly policy: {
+            readonly strategies: VigorParsePolicyStrategiesSchema<any>;
+        };
+    }>>>;
+    /**
+     * Overrides the resolved result type with `T`, taking priority over the
+     * default `unknown` result. Can be called before or after `strategies()`
+     * (or any other configuration method); whichever `.cast<T>()` call
+     * happens last wins.
+     */
+    cast<const C>(): VigorParse<VigorParseIn<VigorDeepMerge<T, {
+        cast: C;
+    }>>>;
+    /** Runs parsing and returns the result directly, throwing on final failure. */
+    request<R = VigorCastResult<T["cast"], VigorParseContextSchema<T>["result"]>>(): Promise<R>;
+    /** Runs parsing and returns a result/error envelope instead of throwing. */
+    requestVerbose<R = VigorCastResult<T["cast"], VigorParseContextSchema<T>["result"]>>(): Promise<{
+        success: false;
+        data: null;
+        error: unknown;
+    } | {
+        success: true;
+        data: R;
+        error: null;
+    }>;
+    /** Internal execution loop implementing the strategy fallback and restart handling. */
+    private requestRuntime;
 }
 
 type VigorStringable = string | number | boolean | null | undefined | Date;
@@ -1883,76 +1834,25 @@ declare const VigorFetchPolicyBase: {
                 readonly maxRestarts: 3;
                 readonly timeout: 20000;
             };
-            readonly middlewares: {
-                readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                readonly before: [];
-                readonly after: [];
-                readonly onResult: [];
-                readonly retryIf: [];
-                readonly onRetry: [];
-                readonly onError: [];
-            };
-            readonly algorithms: {
-                readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                readonly _tag: "constant";
-                readonly jitter: 1000;
-                readonly interval: 2000;
-                readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-            };
-        };
-        readonly context: {
-            readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-            readonly result: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly error: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly system: {
-                readonly delay: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly attempt: 0;
-            };
-            readonly flags: {
-                readonly doRetry: true;
-                readonly doRestart: false;
-                readonly brokeRetry: false;
-                readonly overridden: false;
-            };
-            readonly record: {};
-            readonly policy: {
-                readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                readonly target: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                };
-                readonly abortSignals: [];
-                readonly settings: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                    readonly default: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                    };
-                    readonly maxAttempts: 5;
-                    readonly maxRestarts: 3;
-                    readonly timeout: 20000;
-                };
-                readonly middlewares: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                    readonly before: [];
-                    readonly after: [];
-                    readonly onResult: [];
-                    readonly retryIf: [];
-                    readonly onRetry: [];
-                    readonly onError: [];
-                };
-                readonly algorithms: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                    readonly _tag: "constant";
-                    readonly jitter: 1000;
-                    readonly interval: 2000;
-                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                };
+            readonly middlewares: {
+                readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+                readonly before: [];
+                readonly after: [];
+                readonly onResult: [];
+                readonly retryIf: [];
+                readonly onRetry: [];
+                readonly onError: [];
             };
+            readonly algorithms: {
+                readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+                readonly _tag: "constant";
+                readonly jitter: 1000;
+                readonly interval: 2000;
+                readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
+            };
+        };
+        readonly cast: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
         };
     };
     readonly parse: {
@@ -1982,47 +1882,8 @@ declare const VigorFetchPolicyBase: {
                 readonly funcs: VigorParseStrategyFunc[];
             };
         };
-        readonly context: {
-            readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-            readonly result: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly error: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly response: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
-            };
-            readonly flags: {
-                readonly overrided: false;
-                readonly restarted: false;
-            };
-            readonly record: {};
-            readonly policy: {
-                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                readonly target: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly settings: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                    readonly raw: false;
-                    readonly default: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                    };
-                    readonly maxRestarts: 3;
-                };
-                readonly middlewares: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                    readonly before: [];
-                    readonly after: [];
-                    readonly onResult: [];
-                    readonly onError: [];
-                };
-                readonly strategies: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                    readonly funcs: VigorParseStrategyFunc[];
-                };
-            };
+        readonly cast: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
         };
     };
 };
@@ -2030,7 +1891,8 @@ declare const VigorFetchPolicyBase: {
 type VigorFetchSchema<T extends VigorFetchSchema<T>> = {
     __brand: VigorBrand<"Fetch", "Schema">;
     policy: VigorFetchPolicySchema<T>;
-    context: VigorFetchContextSchema<T>;
+    /** Type-level override for the resolved result type, set via `.cast<T>()`. */
+    cast: unknown;
 };
 declare const VigorFetchBase: {
     readonly __brand: VigorBrand<"Fetch", "Schema">;
@@ -2073,372 +1935,72 @@ declare const VigorFetchBase: {
                 readonly target: symbol & {
                     __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
-                readonly abortSignals: [];
-                readonly settings: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                    readonly default: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                    };
-                    readonly maxAttempts: 5;
-                    readonly maxRestarts: 3;
-                    readonly timeout: 20000;
-                };
-                readonly middlewares: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                    readonly before: [];
-                    readonly after: [];
-                    readonly onResult: [];
-                    readonly retryIf: [];
-                    readonly onRetry: [];
-                    readonly onError: [];
-                };
-                readonly algorithms: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                    readonly _tag: "constant";
-                    readonly jitter: 1000;
-                    readonly interval: 2000;
-                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                };
-            };
-            readonly context: {
-                readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                readonly result: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly error: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly system: {
-                    readonly delay: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly attempt: 0;
-                };
-                readonly flags: {
-                    readonly doRetry: true;
-                    readonly doRestart: false;
-                    readonly brokeRetry: false;
-                    readonly overridden: false;
-                };
-                readonly record: {};
-                readonly policy: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                    readonly target: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                    };
-                    readonly abortSignals: [];
-                    readonly settings: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                        readonly default: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly maxAttempts: 5;
-                        readonly maxRestarts: 3;
-                        readonly timeout: 20000;
-                    };
-                    readonly middlewares: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                        readonly before: [];
-                        readonly after: [];
-                        readonly onResult: [];
-                        readonly retryIf: [];
-                        readonly onRetry: [];
-                        readonly onError: [];
-                    };
-                    readonly algorithms: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                        readonly _tag: "constant";
-                        readonly jitter: 1000;
-                        readonly interval: 2000;
-                        readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                    };
-                };
-            };
-        };
-        readonly parse: {
-            readonly __brand: VigorBrand<"Parse", "Schema">;
-            readonly policy: {
-                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                readonly target: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly settings: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                    readonly raw: false;
-                    readonly default: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                    };
-                    readonly maxRestarts: 3;
-                };
-                readonly middlewares: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                    readonly before: [];
-                    readonly after: [];
-                    readonly onResult: [];
-                    readonly onError: [];
-                };
-                readonly strategies: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                    readonly funcs: VigorParseStrategyFunc[];
-                };
-            };
-            readonly context: {
-                readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                readonly result: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly error: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly response: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                };
-                readonly flags: {
-                    readonly overrided: false;
-                    readonly restarted: false;
-                };
-                readonly record: {};
-                readonly policy: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                    readonly target: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly settings: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                        readonly raw: false;
-                        readonly default: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly maxRestarts: 3;
-                    };
-                    readonly middlewares: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                        readonly before: [];
-                        readonly after: [];
-                        readonly onResult: [];
-                        readonly onError: [];
-                    };
-                    readonly strategies: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                        readonly funcs: VigorParseStrategyFunc[];
-                    };
-                };
-            };
-        };
-    };
-    readonly context: {
-        readonly __brand: VigorBrand<"Fetch", "Context<Schema">;
-        readonly href: "";
-        readonly response: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly result: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly error: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly options: symbol & {
-            __brand: VigorBrand<"Core", "Symbol_Default">;
-        };
-        readonly flags: {
-            readonly overrided: false;
-            readonly restarted: false;
-        };
-        readonly record: {};
-        readonly policy: {
-            readonly __brand: VigorBrand<"Fetch", "Policy<Schema">;
-            readonly method: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Empty">;
-            };
-            readonly origin: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Empty">;
-            };
-            readonly path: [];
-            readonly query: [];
-            readonly hash: "";
-            readonly headers: {};
-            readonly body: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Empty">;
-            };
-            readonly extra: {};
-            readonly settings: {
-                readonly __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
-                readonly retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
-                readonly unretryStatus: [400, 401, 403, 404, 405, 413, 422];
-                readonly maxRestarts: 3;
-                readonly default: symbol & {
-                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                };
-            };
-            readonly middlewares: {
-                readonly __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
-                readonly before: [];
-                readonly after: [];
-                readonly onResult: [];
-                readonly onError: [];
-            };
-            readonly retry: {
-                readonly __brand: VigorBrand<"Retry", "Schema">;
-                readonly policy: {
-                    readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                    readonly target: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                    };
-                    readonly abortSignals: [];
-                    readonly settings: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                        readonly default: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly maxAttempts: 5;
-                        readonly maxRestarts: 3;
-                        readonly timeout: 20000;
-                    };
-                    readonly middlewares: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                        readonly before: [];
-                        readonly after: [];
-                        readonly onResult: [];
-                        readonly retryIf: [];
-                        readonly onRetry: [];
-                        readonly onError: [];
-                    };
-                    readonly algorithms: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                        readonly _tag: "constant";
-                        readonly jitter: 1000;
-                        readonly interval: 2000;
-                        readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                    };
-                };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly system: {
-                        readonly delay: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly attempt: 0;
-                    };
-                    readonly flags: {
-                        readonly doRetry: true;
-                        readonly doRestart: false;
-                        readonly brokeRetry: false;
-                        readonly overridden: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly abortSignals: [];
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxAttempts: 5;
-                            readonly maxRestarts: 3;
-                            readonly timeout: 20000;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly retryIf: [];
-                            readonly onRetry: [];
-                            readonly onError: [];
-                        };
-                        readonly algorithms: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                            readonly _tag: "constant";
-                            readonly jitter: 1000;
-                            readonly interval: 2000;
-                            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                        };
+                readonly abortSignals: [];
+                readonly settings: {
+                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+                    readonly default: symbol & {
+                        __brand: VigorBrand<"Core", "Symbol_Empty">;
                     };
+                    readonly maxAttempts: 5;
+                    readonly maxRestarts: 3;
+                    readonly timeout: 20000;
+                };
+                readonly middlewares: {
+                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+                    readonly before: [];
+                    readonly after: [];
+                    readonly onResult: [];
+                    readonly retryIf: [];
+                    readonly onRetry: [];
+                    readonly onError: [];
+                };
+                readonly algorithms: {
+                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+                    readonly _tag: "constant";
+                    readonly jitter: 1000;
+                    readonly interval: 2000;
+                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
                 };
             };
-            readonly parse: {
-                readonly __brand: VigorBrand<"Parse", "Schema">;
-                readonly policy: {
-                    readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                    readonly target: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly settings: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                        readonly raw: false;
-                        readonly default: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly maxRestarts: 3;
-                    };
-                    readonly middlewares: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                        readonly before: [];
-                        readonly after: [];
-                        readonly onResult: [];
-                        readonly onError: [];
-                    };
-                    readonly strategies: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                        readonly funcs: VigorParseStrategyFunc[];
-                    };
+            readonly cast: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
+            };
+        };
+        readonly parse: {
+            readonly __brand: VigorBrand<"Parse", "Schema">;
+            readonly policy: {
+                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
+                readonly target: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Default">;
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly response: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly flags: {
-                        readonly overrided: false;
-                        readonly restarted: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                            readonly raw: false;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxRestarts: 3;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly onError: [];
-                        };
-                        readonly strategies: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                            readonly funcs: VigorParseStrategyFunc[];
-                        };
+                readonly settings: {
+                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+                    readonly raw: false;
+                    readonly default: symbol & {
+                        __brand: VigorBrand<"Core", "Symbol_Empty">;
                     };
+                    readonly maxRestarts: 3;
+                };
+                readonly middlewares: {
+                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
+                    readonly before: [];
+                    readonly after: [];
+                    readonly onResult: [];
+                    readonly onError: [];
+                };
+                readonly strategies: {
+                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+                    readonly funcs: VigorParseStrategyFunc[];
                 };
             };
+            readonly cast: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
+            };
         };
     };
+    readonly cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
 };
 /**
  * Immutable builder that performs an HTTP request, composing an internal
@@ -2565,10 +2127,19 @@ declare class VigorFetch<T extends VigorFetchSchema<T> = typeof VigorFetchBase>
         headers: Record<string, string>;
         body: BodyInit | null | undefined;
     };
+    /**
+     * Overrides the resolved result type with `T`, taking priority over the
+     * default `unknown` result. Can be called before or after `parse()` (or
+     * any other configuration method); whichever `.cast<T>()` call happens
+     * last wins.
+     */
+    cast<const C>(): VigorFetch<VigorFetchIn<VigorDeepMerge<T, {
+        cast: C;
+    }>>>;
     /** Runs the request and returns its parsed result directly, throwing on final failure. */
-    request<R = T["context"]["result"]>(): Promise<R>;
+    request<R = VigorCastResult<T["cast"], VigorFetchContextSchema<T>["result"]>>(): Promise<R>;
     /** Runs the request and returns a result/error envelope instead of throwing. */
-    requestVerbose<R = T["context"]["result"]>(): Promise<{
+    requestVerbose<R = VigorCastResult<T["cast"], VigorFetchContextSchema<T>["result"]>>(): Promise<{
         success: false;
         data: null;
         error: unknown;
@@ -2581,53 +2152,244 @@ declare class VigorFetch<T extends VigorFetchSchema<T> = typeof VigorFetchBase>
     private requestRuntime;
 }
 
-/** Everything `vigor` exposes except `use` — kept separate so `VigorInstance` (below) can self-reference without a circular-inference error. */
-declare const vigorBase: {
-    retry: (task?: ((signal: AbortSignal) => any | Promise<any>) | undefined) => VigorRetry<any>;
-    parse: (response?: (symbol & {
-        __brand: VigorBrand<"Core", "Symbol_Default">;
-    }) | Request | Response | undefined) => VigorParse<any>;
-    fetch: (origin?: string | undefined) => VigorFetch<any>;
-    all: (...tasks: Parameters<VigorAll["target"]>) => VigorAll<{
-        readonly __brand: VigorBrand<"All", "Schema">;
-        readonly policy: {
-            readonly __brand: VigorBrand<"All", "Policy<Schema">;
-            readonly target: VigorAllTask[];
-            readonly settings: {
-                readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-                readonly concurrency: 5;
-                readonly onlySuccess: false;
+type VigorFetchIn<T> = T extends VigorFetchSchema<any> ? T : never;
+interface VigorFetchTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorFetch<VigorFetchIn<this["In"]>>;
+}
+interface VigorFetchPolicySettingsTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorFetchPolicySettings<VigorFetchIn<this["In"]>>;
+}
+interface VigorFetchPolicyMiddlewaresTypeLambda extends VigorTypeLambda {
+    readonly Target: VigorFetchPolicyMiddlewares<VigorFetchIn<this["In"]>>;
+}
+
+/**
+ * Small named helpers that actually *call* the target/origin method with the
+ * generic argument `F`. These exist purely so `ReturnType<typeof xWithY<F>>`
+ * can forward `F` into the real merged config type — referencing the method
+ * type directly (e.g. `VigorRetry["target"]`) would leave `F` unapplied and
+ * collapse back to the method's own parameter type.
+ */
+declare function retryWithTarget<const F extends Parameters<VigorRetry["target"]>[0]>(task: F): VigorRetry<VigorRetryIn<{
+    policy: {
+        target: F;
+        __brand: VigorBrand<"Retry", "Policy<Schema">;
+        abortSignals: [];
+        settings: {
+            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+            readonly default: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
             };
-            readonly middlewares: {
-                readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-                readonly before: VigorAllEachMiddlewareFn[];
-                readonly after: VigorAllEachMiddlewareFn[];
-                readonly onError: VigorAllEachOnErrorFn[];
+            readonly maxAttempts: 5;
+            readonly maxRestarts: 3;
+            readonly timeout: 20000;
+        };
+        middlewares: {
+            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+            readonly before: [];
+            readonly after: [];
+            readonly onResult: [];
+            readonly retryIf: [];
+            readonly onRetry: [];
+            readonly onError: [];
+        };
+        algorithms: {
+            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+            readonly _tag: "constant";
+            readonly jitter: 1000;
+            readonly interval: 2000;
+            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
+        };
+    };
+    __brand: VigorBrand<"Retry", "Schema">;
+    cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+}>>;
+declare function parseWithTarget<const F extends Parameters<VigorParse["target"]>[0]>(response: F): VigorParse<VigorParseIn<{
+    policy: {
+        target: F;
+        __brand: VigorBrand<"Parse", "Policy<Schema">;
+        settings: {
+            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+            readonly raw: false;
+            readonly default: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
             };
+            readonly maxRestarts: 3;
         };
-        readonly context: {
-            readonly __brand: VigorBrand<"All", "Context<Schema">;
-            readonly result: symbol & {
-                __brand: VigorBrand<"Core", "Symbol_Default">;
+        middlewares: {
+            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
+            readonly before: [];
+            readonly after: [];
+            readonly onResult: [];
+            readonly onError: [];
+        };
+        strategies: {
+            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+            readonly funcs: VigorParseStrategyFunc[];
+        };
+    };
+    __brand: VigorBrand<"Parse", "Schema">;
+    cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+}>>;
+declare function fetchWithOrigin<const F extends Parameters<VigorFetch["origin"]>[0]>(origin: F): VigorFetch<VigorFetchIn<{
+    policy: {
+        __brand: VigorBrand<"Fetch", "Policy<Schema">;
+        settings: {
+            readonly __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
+            readonly retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
+            readonly unretryStatus: [400, 401, 403, 404, 405, 413, 422];
+            readonly maxRestarts: 3;
+            readonly default: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
+            };
+        };
+        middlewares: {
+            readonly __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
+            readonly before: [];
+            readonly after: [];
+            readonly onResult: [];
+            readonly onError: [];
+        };
+        headers: {};
+        method: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
+        };
+        body: symbol & {
+            __brand: VigorBrand<"Core", "Symbol_Empty">;
+        };
+        origin: F;
+        path: [];
+        query: [];
+        hash: "";
+        extra: {};
+        retry: {
+            readonly __brand: VigorBrand<"Retry", "Schema">;
+            readonly policy: {
+                readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
+                readonly target: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
+                };
+                readonly abortSignals: [];
+                readonly settings: {
+                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
+                    readonly default: symbol & {
+                        __brand: VigorBrand<"Core", "Symbol_Empty">;
+                    };
+                    readonly maxAttempts: 5;
+                    readonly maxRestarts: 3;
+                    readonly timeout: 20000;
+                };
+                readonly middlewares: {
+                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
+                    readonly before: [];
+                    readonly after: [];
+                    readonly onResult: [];
+                    readonly retryIf: [];
+                    readonly onRetry: [];
+                    readonly onError: [];
+                };
+                readonly algorithms: {
+                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
+                    readonly _tag: "constant";
+                    readonly jitter: 1000;
+                    readonly interval: 2000;
+                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
+                };
+            };
+            readonly cast: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
             };
+        };
+        parse: {
+            readonly __brand: VigorBrand<"Parse", "Schema">;
             readonly policy: {
-                readonly __brand: VigorBrand<"All", "Policy<Schema">;
-                readonly target: VigorAllTask[];
+                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
+                readonly target: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Default">;
+                };
                 readonly settings: {
-                    readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-                    readonly concurrency: 5;
-                    readonly onlySuccess: false;
+                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
+                    readonly raw: false;
+                    readonly default: symbol & {
+                        __brand: VigorBrand<"Core", "Symbol_Empty">;
+                    };
+                    readonly maxRestarts: 3;
                 };
                 readonly middlewares: {
-                    readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-                    readonly before: VigorAllEachMiddlewareFn[];
-                    readonly after: VigorAllEachMiddlewareFn[];
-                    readonly onError: VigorAllEachOnErrorFn[];
+                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
+                    readonly before: [];
+                    readonly after: [];
+                    readonly onResult: [];
+                    readonly onError: [];
+                };
+                readonly strategies: {
+                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
+                    readonly funcs: VigorParseStrategyFunc[];
                 };
             };
-            readonly record: {};
+            readonly cast: symbol & {
+                __brand: VigorBrand<"Core", "Symbol_Empty">;
+            };
         };
-    }>;
+    };
+    __brand: VigorBrand<"Fetch", "Schema">;
+    cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+}>>;
+declare function allWithTargets<const F extends VigorAllTask[]>(tasks: F): VigorAll<VigorAllIn<{
+    policy: {
+        target: F extends VigorBuiltin ? F : F extends readonly any[] ? [...VigorAllTask[], ...F] : F;
+        __brand: VigorBrand<"All", "Policy<Schema">;
+        settings: {
+            readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
+            readonly concurrency: 5;
+            readonly onlySuccess: false;
+        };
+        middlewares: {
+            readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
+            readonly before: VigorAllEachMiddlewareFn[];
+            readonly after: VigorAllEachMiddlewareFn[];
+            readonly onError: VigorAllEachOnErrorFn[];
+        };
+    };
+    __brand: VigorBrand<"All", "Schema">;
+    cast: symbol & {
+        __brand: VigorBrand<"Core", "Symbol_Empty">;
+    };
+}>>;
+/**
+ * Overload types for each entry helper. Object literals can't declare
+ * overloaded method shorthand directly (`foo(): A; foo(x: B): C { ... }` is a
+ * syntax error inside `{ ... }`), so each helper is typed here and the
+ * implementation is cast to it below.
+ */
+type RetryFn = {
+    (): VigorRetry;
+    <const F extends Parameters<VigorRetry["target"]>[0]>(task: F): ReturnType<typeof retryWithTarget<F>>;
+};
+type ParseFn = {
+    (): VigorParse;
+    <const F extends Parameters<VigorParse["target"]>[0]>(response: F): ReturnType<typeof parseWithTarget<F>>;
+};
+type FetchFn = {
+    (): VigorFetch;
+    <const F extends Parameters<VigorFetch["origin"]>[0]>(origin: F): ReturnType<typeof fetchWithOrigin<F>>;
+};
+type AllFn = {
+    (): VigorAll;
+    <const F extends VigorAllTask[]>(...tasks: F): ReturnType<typeof allWithTargets<F>>;
+};
+/** Everything `vigor` exposes except `use` — kept separate so `VigorInstance` (below) can self-reference without a circular-inference error. */
+declare const vigorBase: {
+    retry: RetryFn;
+    parse: ParseFn;
+    fetch: FetchFn;
+    all: AllFn;
     builders: {
         fetch: {
             settings: () => VigorFetchPolicySettings<{
@@ -2698,59 +2460,8 @@ declare const vigorBase: {
                                 readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
                             };
                         };
-                        readonly context: {
-                            readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                            readonly result: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly error: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly system: {
-                                readonly delay: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly attempt: 0;
-                            };
-                            readonly flags: {
-                                readonly doRetry: true;
-                                readonly doRestart: false;
-                                readonly brokeRetry: false;
-                                readonly overridden: false;
-                            };
-                            readonly record: {};
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                };
-                                readonly abortSignals: [];
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxAttempts: 5;
-                                    readonly maxRestarts: 3;
-                                    readonly timeout: 20000;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly retryIf: [];
-                                    readonly onRetry: [];
-                                    readonly onError: [];
-                                };
-                                readonly algorithms: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                                    readonly _tag: "constant";
-                                    readonly jitter: 1000;
-                                    readonly interval: 2000;
-                                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                                };
-                            };
+                        readonly cast: symbol & {
+                            __brand: VigorBrand<"Core", "Symbol_Empty">;
                         };
                     };
                     readonly parse: {
@@ -2780,263 +2491,14 @@ declare const vigorBase: {
                                 readonly funcs: VigorParseStrategyFunc[];
                             };
                         };
-                        readonly context: {
-                            readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                            readonly result: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly error: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly response: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly flags: {
-                                readonly overrided: false;
-                                readonly restarted: false;
-                            };
-                            readonly record: {};
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                                    readonly raw: false;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxRestarts: 3;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly onError: [];
-                                };
-                                readonly strategies: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                                    readonly funcs: VigorParseStrategyFunc[];
-                                };
-                            };
-                        };
-                    };
-                };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Fetch", "Context<Schema">;
-                    readonly href: "";
-                    readonly response: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly options: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly flags: {
-                        readonly overrided: false;
-                        readonly restarted: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Fetch", "Policy<Schema">;
-                        readonly method: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly origin: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly path: [];
-                        readonly query: [];
-                        readonly hash: "";
-                        readonly headers: {};
-                        readonly body: symbol & {
+                        readonly cast: symbol & {
                             __brand: VigorBrand<"Core", "Symbol_Empty">;
                         };
-                        readonly extra: {};
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
-                            readonly retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
-                            readonly unretryStatus: [400, 401, 403, 404, 405, 413, 422];
-                            readonly maxRestarts: 3;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly onError: [];
-                        };
-                        readonly retry: {
-                            readonly __brand: VigorBrand<"Retry", "Schema">;
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                };
-                                readonly abortSignals: [];
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxAttempts: 5;
-                                    readonly maxRestarts: 3;
-                                    readonly timeout: 20000;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly retryIf: [];
-                                    readonly onRetry: [];
-                                    readonly onError: [];
-                                };
-                                readonly algorithms: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                                    readonly _tag: "constant";
-                                    readonly jitter: 1000;
-                                    readonly interval: 2000;
-                                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                                };
-                            };
-                            readonly context: {
-                                readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                                readonly result: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly error: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly system: {
-                                    readonly delay: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                                    };
-                                    readonly attempt: 0;
-                                };
-                                readonly flags: {
-                                    readonly doRetry: true;
-                                    readonly doRestart: false;
-                                    readonly brokeRetry: false;
-                                    readonly overridden: false;
-                                };
-                                readonly record: {};
-                                readonly policy: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                                    readonly target: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly abortSignals: [];
-                                    readonly settings: {
-                                        readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                                        readonly default: symbol & {
-                                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                        };
-                                        readonly maxAttempts: 5;
-                                        readonly maxRestarts: 3;
-                                        readonly timeout: 20000;
-                                    };
-                                    readonly middlewares: {
-                                        readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                                        readonly before: [];
-                                        readonly after: [];
-                                        readonly onResult: [];
-                                        readonly retryIf: [];
-                                        readonly onRetry: [];
-                                        readonly onError: [];
-                                    };
-                                    readonly algorithms: {
-                                        readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                                        readonly _tag: "constant";
-                                        readonly jitter: 1000;
-                                        readonly interval: 2000;
-                                        readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                                    };
-                                };
-                            };
-                        };
-                        readonly parse: {
-                            readonly __brand: VigorBrand<"Parse", "Schema">;
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                                    readonly raw: false;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxRestarts: 3;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly onError: [];
-                                };
-                                readonly strategies: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                                    readonly funcs: VigorParseStrategyFunc[];
-                                };
-                            };
-                            readonly context: {
-                                readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                                readonly result: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly error: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly response: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly flags: {
-                                    readonly overrided: false;
-                                    readonly restarted: false;
-                                };
-                                readonly record: {};
-                                readonly policy: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                                    readonly target: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                                    };
-                                    readonly settings: {
-                                        readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                                        readonly raw: false;
-                                        readonly default: symbol & {
-                                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                        };
-                                        readonly maxRestarts: 3;
-                                    };
-                                    readonly middlewares: {
-                                        readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                                        readonly before: [];
-                                        readonly after: [];
-                                        readonly onResult: [];
-                                        readonly onError: [];
-                                    };
-                                    readonly strategies: {
-                                        readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                                        readonly funcs: VigorParseStrategyFunc[];
-                                    };
-                                };
-                            };
-                        };
                     };
                 };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
+                };
             }>;
             middlewares: () => VigorFetchPolicyMiddlewares<{
                 readonly __brand: VigorBrand<"Fetch", "Schema">;
@@ -3106,59 +2568,8 @@ declare const vigorBase: {
                                 readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
                             };
                         };
-                        readonly context: {
-                            readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                            readonly result: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly error: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly system: {
-                                readonly delay: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly attempt: 0;
-                            };
-                            readonly flags: {
-                                readonly doRetry: true;
-                                readonly doRestart: false;
-                                readonly brokeRetry: false;
-                                readonly overridden: false;
-                            };
-                            readonly record: {};
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                };
-                                readonly abortSignals: [];
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxAttempts: 5;
-                                    readonly maxRestarts: 3;
-                                    readonly timeout: 20000;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly retryIf: [];
-                                    readonly onRetry: [];
-                                    readonly onError: [];
-                                };
-                                readonly algorithms: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                                    readonly _tag: "constant";
-                                    readonly jitter: 1000;
-                                    readonly interval: 2000;
-                                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                                };
-                            };
+                        readonly cast: symbol & {
+                            __brand: VigorBrand<"Core", "Symbol_Empty">;
                         };
                     };
                     readonly parse: {
@@ -3188,263 +2599,14 @@ declare const vigorBase: {
                                 readonly funcs: VigorParseStrategyFunc[];
                             };
                         };
-                        readonly context: {
-                            readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                            readonly result: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly error: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly response: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Default">;
-                            };
-                            readonly flags: {
-                                readonly overrided: false;
-                                readonly restarted: false;
-                            };
-                            readonly record: {};
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                                    readonly raw: false;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxRestarts: 3;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly onError: [];
-                                };
-                                readonly strategies: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                                    readonly funcs: VigorParseStrategyFunc[];
-                                };
-                            };
-                        };
-                    };
-                };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Fetch", "Context<Schema">;
-                    readonly href: "";
-                    readonly response: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly options: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly flags: {
-                        readonly overrided: false;
-                        readonly restarted: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Fetch", "Policy<Schema">;
-                        readonly method: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly origin: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly path: [];
-                        readonly query: [];
-                        readonly hash: "";
-                        readonly headers: {};
-                        readonly body: symbol & {
+                        readonly cast: symbol & {
                             __brand: VigorBrand<"Core", "Symbol_Empty">;
                         };
-                        readonly extra: {};
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Fetch", "Policy<Settings<Schema">;
-                            readonly retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"];
-                            readonly unretryStatus: [400, 401, 403, 404, 405, 413, 422];
-                            readonly maxRestarts: 3;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Fetch", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly onError: [];
-                        };
-                        readonly retry: {
-                            readonly __brand: VigorBrand<"Retry", "Schema">;
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                };
-                                readonly abortSignals: [];
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxAttempts: 5;
-                                    readonly maxRestarts: 3;
-                                    readonly timeout: 20000;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly retryIf: [];
-                                    readonly onRetry: [];
-                                    readonly onError: [];
-                                };
-                                readonly algorithms: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                                    readonly _tag: "constant";
-                                    readonly jitter: 1000;
-                                    readonly interval: 2000;
-                                    readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                                };
-                            };
-                            readonly context: {
-                                readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                                readonly result: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly error: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly system: {
-                                    readonly delay: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                                    };
-                                    readonly attempt: 0;
-                                };
-                                readonly flags: {
-                                    readonly doRetry: true;
-                                    readonly doRestart: false;
-                                    readonly brokeRetry: false;
-                                    readonly overridden: false;
-                                };
-                                readonly record: {};
-                                readonly policy: {
-                                    readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                                    readonly target: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly abortSignals: [];
-                                    readonly settings: {
-                                        readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                                        readonly default: symbol & {
-                                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                        };
-                                        readonly maxAttempts: 5;
-                                        readonly maxRestarts: 3;
-                                        readonly timeout: 20000;
-                                    };
-                                    readonly middlewares: {
-                                        readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                                        readonly before: [];
-                                        readonly after: [];
-                                        readonly onResult: [];
-                                        readonly retryIf: [];
-                                        readonly onRetry: [];
-                                        readonly onError: [];
-                                    };
-                                    readonly algorithms: {
-                                        readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                                        readonly _tag: "constant";
-                                        readonly jitter: 1000;
-                                        readonly interval: 2000;
-                                        readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                                    };
-                                };
-                            };
-                        };
-                        readonly parse: {
-                            readonly __brand: VigorBrand<"Parse", "Schema">;
-                            readonly policy: {
-                                readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                                readonly target: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly settings: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                                    readonly raw: false;
-                                    readonly default: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                    };
-                                    readonly maxRestarts: 3;
-                                };
-                                readonly middlewares: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                                    readonly before: [];
-                                    readonly after: [];
-                                    readonly onResult: [];
-                                    readonly onError: [];
-                                };
-                                readonly strategies: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                                    readonly funcs: VigorParseStrategyFunc[];
-                                };
-                            };
-                            readonly context: {
-                                readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                                readonly result: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly error: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly response: symbol & {
-                                    __brand: VigorBrand<"Core", "Symbol_Default">;
-                                };
-                                readonly flags: {
-                                    readonly overrided: false;
-                                    readonly restarted: false;
-                                };
-                                readonly record: {};
-                                readonly policy: {
-                                    readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                                    readonly target: symbol & {
-                                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                                    };
-                                    readonly settings: {
-                                        readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                                        readonly raw: false;
-                                        readonly default: symbol & {
-                                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                                        };
-                                        readonly maxRestarts: 3;
-                                    };
-                                    readonly middlewares: {
-                                        readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                                        readonly before: [];
-                                        readonly after: [];
-                                        readonly onResult: [];
-                                        readonly onError: [];
-                                    };
-                                    readonly strategies: {
-                                        readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                                        readonly funcs: VigorParseStrategyFunc[];
-                                    };
-                                };
-                            };
-                        };
                     };
                 };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
+                };
             }>;
         };
         retry: {
@@ -3482,59 +2644,8 @@ declare const vigorBase: {
                         readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly system: {
-                        readonly delay: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly attempt: 0;
-                    };
-                    readonly flags: {
-                        readonly doRetry: true;
-                        readonly doRestart: false;
-                        readonly brokeRetry: false;
-                        readonly overridden: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly abortSignals: [];
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxAttempts: 5;
-                            readonly maxRestarts: 3;
-                            readonly timeout: 20000;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly retryIf: [];
-                            readonly onRetry: [];
-                            readonly onError: [];
-                        };
-                        readonly algorithms: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                            readonly _tag: "constant";
-                            readonly jitter: 1000;
-                            readonly interval: 2000;
-                            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                        };
-                    };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
             middlewares: () => VigorRetryPolicyMiddlewares<{
@@ -3571,59 +2682,8 @@ declare const vigorBase: {
                         readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly system: {
-                        readonly delay: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly attempt: 0;
-                    };
-                    readonly flags: {
-                        readonly doRetry: true;
-                        readonly doRestart: false;
-                        readonly brokeRetry: false;
-                        readonly overridden: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly abortSignals: [];
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxAttempts: 5;
-                            readonly maxRestarts: 3;
-                            readonly timeout: 20000;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly retryIf: [];
-                            readonly onRetry: [];
-                            readonly onError: [];
-                        };
-                        readonly algorithms: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                            readonly _tag: "constant";
-                            readonly jitter: 1000;
-                            readonly interval: 2000;
-                            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                        };
-                    };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
             algorithms: () => VigorRetryPolicyAlgorithms<{
@@ -3660,59 +2720,8 @@ declare const vigorBase: {
                         readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Retry", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly system: {
-                        readonly delay: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly attempt: 0;
-                    };
-                    readonly flags: {
-                        readonly doRetry: true;
-                        readonly doRestart: false;
-                        readonly brokeRetry: false;
-                        readonly overridden: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Retry", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Empty">;
-                        };
-                        readonly abortSignals: [];
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Settings<Schema">;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxAttempts: 5;
-                            readonly maxRestarts: 3;
-                            readonly timeout: 20000;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly retryIf: [];
-                            readonly onRetry: [];
-                            readonly onError: [];
-                        };
-                        readonly algorithms: {
-                            readonly __brand: VigorBrand<"Retry", "Policy<Algorithms<Constant<Schema">;
-                            readonly _tag: "constant";
-                            readonly jitter: 1000;
-                            readonly interval: 2000;
-                            readonly _calculateDelay: (att: number, config: VigorRetryPolicyAlgorithmsConstantSchema<any>) => number;
-                        };
-                    };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
             algorithm: {
@@ -3785,47 +2794,8 @@ declare const vigorBase: {
                         readonly funcs: VigorParseStrategyFunc[];
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly response: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly flags: {
-                        readonly overrided: false;
-                        readonly restarted: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                            readonly raw: false;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxRestarts: 3;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly onError: [];
-                        };
-                        readonly strategies: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                            readonly funcs: VigorParseStrategyFunc[];
-                        };
-                    };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
             middlewares: () => VigorParsePolicyMiddlewares<{
@@ -3855,47 +2825,8 @@ declare const vigorBase: {
                         readonly funcs: VigorParseStrategyFunc[];
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly response: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly flags: {
-                        readonly overrided: false;
-                        readonly restarted: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                            readonly raw: false;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxRestarts: 3;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly onError: [];
-                        };
-                        readonly strategies: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                            readonly funcs: VigorParseStrategyFunc[];
-                        };
-                    };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
             strategies: () => VigorParsePolicyStrategies<{
@@ -3925,47 +2856,8 @@ declare const vigorBase: {
                         readonly funcs: VigorParseStrategyFunc[];
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"Parse", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly error: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly response: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly flags: {
-                        readonly overrided: false;
-                        readonly restarted: false;
-                    };
-                    readonly record: {};
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"Parse", "Policy<Schema">;
-                        readonly target: symbol & {
-                            __brand: VigorBrand<"Core", "Symbol_Default">;
-                        };
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Settings<Schema">;
-                            readonly raw: false;
-                            readonly default: symbol & {
-                                __brand: VigorBrand<"Core", "Symbol_Empty">;
-                            };
-                            readonly maxRestarts: 3;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Middlewares<Schema">;
-                            readonly before: [];
-                            readonly after: [];
-                            readonly onResult: [];
-                            readonly onError: [];
-                        };
-                        readonly strategies: {
-                            readonly __brand: VigorBrand<"Parse", "Policy<Strategies<Schema">;
-                            readonly funcs: VigorParseStrategyFunc[];
-                        };
-                    };
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
         };
@@ -3987,27 +2879,8 @@ declare const vigorBase: {
                         readonly onError: VigorAllEachOnErrorFn[];
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"All", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"All", "Policy<Schema">;
-                        readonly target: VigorAllTask[];
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-                            readonly concurrency: 5;
-                            readonly onlySuccess: false;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-                            readonly before: VigorAllEachMiddlewareFn[];
-                            readonly after: VigorAllEachMiddlewareFn[];
-                            readonly onError: VigorAllEachOnErrorFn[];
-                        };
-                    };
-                    readonly record: {};
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
             middlewares: () => VigorAllPolicyMiddlewares<{
@@ -4027,27 +2900,8 @@ declare const vigorBase: {
                         readonly onError: VigorAllEachOnErrorFn[];
                     };
                 };
-                readonly context: {
-                    readonly __brand: VigorBrand<"All", "Context<Schema">;
-                    readonly result: symbol & {
-                        __brand: VigorBrand<"Core", "Symbol_Default">;
-                    };
-                    readonly policy: {
-                        readonly __brand: VigorBrand<"All", "Policy<Schema">;
-                        readonly target: VigorAllTask[];
-                        readonly settings: {
-                            readonly __brand: VigorBrand<"All", "Policy<Settings<Schema">;
-                            readonly concurrency: 5;
-                            readonly onlySuccess: false;
-                        };
-                        readonly middlewares: {
-                            readonly __brand: VigorBrand<"All", "Policy<Middlewares<Schema">;
-                            readonly before: VigorAllEachMiddlewareFn[];
-                            readonly after: VigorAllEachMiddlewareFn[];
-                            readonly onError: VigorAllEachOnErrorFn[];
-                        };
-                    };
-                    readonly record: {};
+                readonly cast: symbol & {
+                    __brand: VigorBrand<"Core", "Symbol_Empty">;
                 };
             }>;
         };
@@ -4119,12 +2973,12 @@ declare const VigorRetryErrorMessageFuncs: {
 type VigorRetryErrorCodes = keyof typeof VigorRetryErrorMessageFuncs;
 type VigorRetryErrorDatas<C extends VigorRetryErrorCodes> = Parameters<typeof VigorRetryErrorMessageFuncs[C]> extends [infer A] ? A : undefined;
 /** Error type thrown by the retry module. */
-declare class VigorRetryError<C extends VigorRetryErrorCodes, T extends VigorRetrySchema<T>> extends VigorError<C, VigorRetryErrorDatas<C>, T["context"]> {
+declare class VigorRetryError<C extends VigorRetryErrorCodes, T extends VigorRetrySchema<T>> extends VigorError<C, VigorRetryErrorDatas<C>, VigorRetryContextSchema<T>> {
     /**
      * @param code - One of the retry module's error codes.
      * @param options - Error metadata, including the `data` payload for `code`.
      */
-    constructor(code: C, options: VigorErrorOptions<VigorRetryErrorDatas<C>, T["context"]>);
+    constructor(code: C, options: VigorErrorOptions<VigorRetryErrorDatas<C>, VigorRetryContextSchema<T>>);
 }
 
 declare const VigorParseErrorMessageFuncs: {
@@ -4149,12 +3003,12 @@ declare const VigorParseErrorMessageFuncs: {
 type VigorParseErrorCodes = keyof typeof VigorParseErrorMessageFuncs;
 type VigorParseErrorDatas<C extends VigorParseErrorCodes> = Parameters<typeof VigorParseErrorMessageFuncs[C]> extends [infer A] ? A : undefined;
 /** Error type thrown by the parse module. */
-declare class VigorParseError<C extends VigorParseErrorCodes, T extends VigorParseSchema<T>> extends VigorError<C, VigorParseErrorDatas<C>, T["context"]> {
+declare class VigorParseError<C extends VigorParseErrorCodes, T extends VigorParseSchema<T>> extends VigorError<C, VigorParseErrorDatas<C>, VigorParseContextSchema<T>> {
     /**
      * @param code - One of the parse module's error codes.
      * @param options - Error metadata, including the `data` payload for `code`.
      */
-    constructor(code: C, options: VigorErrorOptions<VigorParseErrorDatas<C>, T["context"]>);
+    constructor(code: C, options: VigorErrorOptions<VigorParseErrorDatas<C>, VigorParseContextSchema<T>>);
 }
 
 declare const VigorFetchErrorMessageFuncs: {
@@ -4183,12 +3037,12 @@ declare const VigorFetchErrorMessageFuncs: {
 type VigorFetchErrorCodes = keyof typeof VigorFetchErrorMessageFuncs;
 type VigorFetchErrorDatas<C extends VigorFetchErrorCodes> = Parameters<typeof VigorFetchErrorMessageFuncs[C]> extends [infer A] ? A : undefined;
 /** Error type thrown by the fetch module. */
-declare class VigorFetchError<C extends VigorFetchErrorCodes, T extends VigorFetchSchema<T>> extends VigorError<C, VigorFetchErrorDatas<C>, T["context"]> {
+declare class VigorFetchError<C extends VigorFetchErrorCodes, T extends VigorFetchSchema<T>> extends VigorError<C, VigorFetchErrorDatas<C>, VigorFetchContextSchema<T>> {
     /**
      * @param code - One of the fetch module's error codes.
      * @param options - Error metadata, including the `data` payload for `code`.
      */
-    constructor(code: C, options: VigorErrorOptions<VigorFetchErrorDatas<C>, T["context"]>);
+    constructor(code: C, options: VigorErrorOptions<VigorFetchErrorDatas<C>, VigorFetchContextSchema<T>>);
 }
 
 declare const VigorAllErrorMessageFuncs: {
@@ -4197,12 +3051,12 @@ declare const VigorAllErrorMessageFuncs: {
 type VigorAllErrorCodes = keyof typeof VigorAllErrorMessageFuncs;
 type VigorAllErrorDatas<C extends VigorAllErrorCodes> = Parameters<typeof VigorAllErrorMessageFuncs[C]> extends [infer A] ? A : undefined;
 /** Error type thrown by the all module. */
-declare class VigorAllError<C extends VigorAllErrorCodes, T extends VigorAllSchema<T>> extends VigorError<C, VigorAllErrorDatas<C>, T["context"]> {
+declare class VigorAllError<C extends VigorAllErrorCodes, T extends VigorAllSchema<T>> extends VigorError<C, VigorAllErrorDatas<C>, VigorAllContextSchema<T>> {
     /**
      * @param code - One of the all module's error codes.
      * @param options - Error metadata, including the `data` payload for `code`.
      */
-    constructor(code: C, options: VigorErrorOptions<VigorAllErrorDatas<C>, T["context"]>);
+    constructor(code: C, options: VigorErrorOptions<VigorAllErrorDatas<C>, VigorAllContextSchema<T>>);
 }
 
-export { VigorAll, VigorAllBase, type VigorAllEachMiddlewareFn, type VigorAllEachOnErrorFn, VigorAllError, type VigorAllErrorCodes, type VigorAllErrorDatas, VigorAllErrorMessageFuncs, VigorAllPolicyBase, VigorAllPolicyMiddlewares, VigorAllPolicyMiddlewaresBase, type VigorAllPolicyMiddlewaresSchema, type VigorAllPolicySchema, VigorAllPolicySettings, VigorAllPolicySettingsBase, type VigorAllPolicySettingsSchema, type VigorAllSchema, type VigorAllTask, type VigorBuiltin, type VigorConcat, type VigorDeepMerge, type VigorDeepPartial, VigorError, type VigorErrorOptions, VigorFetch, VigorFetchBase, VigorFetchError, type VigorFetchErrorCodes, type VigorFetchErrorDatas, VigorFetchErrorMessageFuncs, VigorFetchPolicyBase, VigorFetchPolicyMiddlewares, type VigorFetchPolicyMiddlewaresApi, VigorFetchPolicyMiddlewaresBase, type VigorFetchPolicyMiddlewaresFluent, type VigorFetchPolicyMiddlewaresIntercept, type VigorFetchPolicyMiddlewaresSchema, type VigorFetchPolicySchema, VigorFetchPolicySettings, VigorFetchPolicySettingsBase, type VigorFetchPolicySettingsSchema, type VigorFetchSchema, type VigorInstance, VigorJitter, type VigorLastOf, type VigorMergeMode, type VigorMergeStrategy, VigorParse, VigorParseBase, VigorParseContentTypeStrategy, VigorParseError, type VigorParseErrorCodes, type VigorParseErrorDatas, VigorParseErrorMessageFuncs, VigorParsePolicyBase, VigorParsePolicyMiddlewares, type VigorParsePolicyMiddlewaresApi, VigorParsePolicyMiddlewaresBase, type VigorParsePolicyMiddlewaresFluent, type VigorParsePolicyMiddlewaresIntercept, type VigorParsePolicyMiddlewaresSchema, type VigorParsePolicySchema, VigorParsePolicySettings, VigorParsePolicySettingsBase, type VigorParsePolicySettingsSchema, VigorParsePolicyStrategies, VigorParsePolicyStrategiesBase, type VigorParsePolicyStrategiesSchema, type VigorParseSchema, VigorParseSniffStrategy, type VigorParseStrategyFunc, type VigorPlugin, type VigorPrimitive, type VigorReplaceType, VigorRetry, VigorRetryBase, VigorRetryError, type VigorRetryErrorCodes, type VigorRetryErrorDatas, VigorRetryErrorMessageFuncs, type VigorRetryPipeInitialContext, type VigorRetryPipeResult, type VigorRetryPipeStepResult, type VigorRetryPipeStepRetryIf, type VigorRetryPipeStepVoid, VigorRetryPolicyAlgorithms, VigorRetryPolicyAlgorithmsBackoff, VigorRetryPolicyAlgorithmsBackoffBase, type VigorRetryPolicyAlgorithmsBackoffSchema, VigorRetryPolicyAlgorithmsBase, VigorRetryPolicyAlgorithmsConstant, VigorRetryPolicyAlgorithmsConstantBase, type VigorRetryPolicyAlgorithmsConstantSchema, VigorRetryPolicyAlgorithmsCustom, VigorRetryPolicyAlgorithmsCustomBase, type VigorRetryPolicyAlgorithmsCustomSchema, VigorRetryPolicyAlgorithmsLinear, VigorRetryPolicyAlgorithmsLinearBase, type VigorRetryPolicyAlgorithmsLinearSchema, type VigorRetryPolicyAlgorithmsSchema, VigorRetryPolicyBase, VigorRetryPolicyMiddlewares, type VigorRetryPolicyMiddlewaresApi, VigorRetryPolicyMiddlewaresBase, type VigorRetryPolicyMiddlewaresFluent, type VigorRetryPolicyMiddlewaresIntercept, type VigorRetryPolicyMiddlewaresPipe, type VigorRetryPolicyMiddlewaresSchema, type VigorRetryPolicySchema, VigorRetryPolicySettings, VigorRetryPolicySettingsBase, type VigorRetryPolicySettingsSchema, type VigorRetrySchema, type VigorReturnType, type VigorSimplify, VigorStatus, type VigorStringable, vigor as default, vigor };
+export { VigorAll, VigorAllBase, type VigorAllEachMiddlewareFn, type VigorAllEachOnErrorFn, VigorAllError, type VigorAllErrorCodes, type VigorAllErrorDatas, VigorAllErrorMessageFuncs, VigorAllPolicyBase, VigorAllPolicyMiddlewares, VigorAllPolicyMiddlewaresBase, type VigorAllPolicyMiddlewaresSchema, type VigorAllPolicySchema, VigorAllPolicySettings, VigorAllPolicySettingsBase, type VigorAllPolicySettingsSchema, type VigorAllSchema, type VigorAllTask, type VigorBuiltin, type VigorCastResult, type VigorConcat, type VigorDeepMerge, type VigorDeepPartial, VigorError, type VigorErrorOptions, VigorFetch, VigorFetchBase, VigorFetchError, type VigorFetchErrorCodes, type VigorFetchErrorDatas, VigorFetchErrorMessageFuncs, VigorFetchPolicyBase, VigorFetchPolicyMiddlewares, type VigorFetchPolicyMiddlewaresApi, VigorFetchPolicyMiddlewaresBase, type VigorFetchPolicyMiddlewaresFluent, type VigorFetchPolicyMiddlewaresIntercept, type VigorFetchPolicyMiddlewaresSchema, type VigorFetchPolicySchema, VigorFetchPolicySettings, VigorFetchPolicySettingsBase, type VigorFetchPolicySettingsSchema, type VigorFetchSchema, type VigorInstance, VigorJitter, type VigorLastOf, type VigorMergeMode, type VigorMergeStrategy, VigorParse, VigorParseBase, VigorParseContentTypeStrategy, VigorParseError, type VigorParseErrorCodes, type VigorParseErrorDatas, VigorParseErrorMessageFuncs, VigorParsePolicyBase, VigorParsePolicyMiddlewares, type VigorParsePolicyMiddlewaresApi, VigorParsePolicyMiddlewaresBase, type VigorParsePolicyMiddlewaresFluent, type VigorParsePolicyMiddlewaresIntercept, type VigorParsePolicyMiddlewaresSchema, type VigorParsePolicySchema, VigorParsePolicySettings, VigorParsePolicySettingsBase, type VigorParsePolicySettingsSchema, VigorParsePolicyStrategies, VigorParsePolicyStrategiesBase, type VigorParsePolicyStrategiesSchema, type VigorParseSchema, VigorParseSniffStrategy, type VigorParseStrategyFunc, type VigorPlugin, type VigorPrimitive, type VigorReplaceType, VigorRetry, VigorRetryBase, VigorRetryError, type VigorRetryErrorCodes, type VigorRetryErrorDatas, VigorRetryErrorMessageFuncs, type VigorRetryPipeInitialContext, type VigorRetryPipeResult, type VigorRetryPipeStepResult, type VigorRetryPipeStepRetryIf, type VigorRetryPipeStepVoid, VigorRetryPolicyAlgorithms, VigorRetryPolicyAlgorithmsBackoff, VigorRetryPolicyAlgorithmsBackoffBase, type VigorRetryPolicyAlgorithmsBackoffSchema, VigorRetryPolicyAlgorithmsBase, VigorRetryPolicyAlgorithmsConstant, VigorRetryPolicyAlgorithmsConstantBase, type VigorRetryPolicyAlgorithmsConstantSchema, VigorRetryPolicyAlgorithmsCustom, VigorRetryPolicyAlgorithmsCustomBase, type VigorRetryPolicyAlgorithmsCustomSchema, VigorRetryPolicyAlgorithmsLinear, VigorRetryPolicyAlgorithmsLinearBase, type VigorRetryPolicyAlgorithmsLinearSchema, type VigorRetryPolicyAlgorithmsSchema, VigorRetryPolicyBase, VigorRetryPolicyMiddlewares, type VigorRetryPolicyMiddlewaresApi, VigorRetryPolicyMiddlewaresBase, type VigorRetryPolicyMiddlewaresFluent, type VigorRetryPolicyMiddlewaresIntercept, type VigorRetryPolicyMiddlewaresPipe, type VigorRetryPolicyMiddlewaresSchema, type VigorRetryPolicySchema, VigorRetryPolicySettings, VigorRetryPolicySettingsBase, type VigorRetryPolicySettingsSchema, type VigorRetrySchema, type VigorReturnType, type VigorSimplify, VigorStatus, type VigorStringable, vigor as default, vigor };