vigor-fetch 3.1.9 → 4.0.0

package/dist/index.js

@@ -2,791 +2,1357 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const VigorErrorMessageFuncs = {
-    INVALID_TARGET: ({ expected, received }) => `Invalid Task: ${typeof received} (expected: ${expected.join(', ')})`,
-    EXHAUSTED: ({ maxAttempts }) => `Retry exhausted, (max ${maxAttempts})`,
-    TIMED_OUT: ({ limit, attempt }) => `Timeout: exceeded ${limit}ms (attempt: ${attempt})`,
-    INVALID_CONTENT_TYPE: ({ expected, received, response }) => `Invalid Content Type Header: ${typeof received} (expected: ${expected.join(', ')})`,
-    PARSER_NOT_FOUND: ({ expected, received, response }) => `Parser Not Found For Header: ${typeof received} (expected: ${expected.join(', ')})`,
-    PARSER_ALL_FAILED: ({ tried, response }) => `All Parser Failed, Tried: ${tried.join(', ')}`,
-    INVALID_PROTOCOL: ({ expected, received }) => `Invalid Protocol: ${typeof received} (expected: ${expected.join(', ')})`,
-    INVALID_BODY: ({ expected, received }) => `Invalid Body: ${typeof received} (expected: ${expected.join(', ')})`,
-    FETCH_FAILED: ({ status, response, url, headers, body, statusText }) => `Fetch Failed: ${status}`,
-    EMPTY_TARGET: ({}) => `Empty Body`
+/**
+ * Builds the literal brand string used by {@link VigorBrand}, preserving the
+ * `Branch`/`Name` literal types for use as a `__brand` value.
+ */
+function createBrand(b, n) {
+    return `@vigor-fetch:::${b} <- ${n}`;
+}
+const VigorDefault = Symbol("VigorDefault");
+/** Type guard checking whether a value is the {@link VigorDefault} sentinel. */
+const isVigorDefault = (v) => v === VigorDefault;
+const VigorEmpty = Symbol("VigorEmpty");
+/** Type guard checking whether a value is the {@link VigorEmpty} sentinel. */
+const isVigorEmpty = (v) => v === VigorEmpty;
+
+/**
+ * Base class for Vigor's immutable, chainable builder objects.
+ *
+ * Each subclass holds a `base` config and a current `config`, and exposes
+ * `_next()` to derive a new instance with a patch merged in. Subclasses
+ * implement `_create()` to construct the concrete instance type, and the
+ * return type of `_next()` is computed through the `TL` type lambda so
+ * chained calls stay precisely typed.
+ *
+ * @typeParam Base - Shape of the full config for this builder.
+ * @typeParam Config - Concrete config type held by this instance (extends `Base`).
+ * @typeParam TL - Type lambda mapping a config type to the concrete instance type.
+ */
+class VigorStatus {
+    _base;
+    _config;
+    /**
+     * @param base - The default/base config for this builder.
+     * @param config - The (possibly partial) config to merge onto `base`.
+     */
+    constructor(base, config) {
+        this._base = base;
+        this._config = this._merge(base, config);
+    }
+    /**
+     * Derives a new instance by merging `patch` onto the current config.
+     *
+     * @param patch - Values to overwrite/merge in for this step.
+     * @param strategy - Optional tree mirroring the shape of `patch`, whose
+     *  leaves may be `"replace" | "concat" | "merge"` to force the merge
+     *  behavior at that path. Paths without a strategy fall back to the
+     *  default behavior (deep merge for objects, concat for arrays).
+     */
+    _next(patch, strategy) {
+        const merged = this._merge(this._config, patch, strategy);
+        return this._create(merged);
+    }
+    /**
+     * Deep-merges `target` onto `source`, honoring an optional per-path
+     * `strategy` tree. Objects merge key by key, arrays concatenate (unless
+     * `"replace"` is specified), and any other value is overwritten.
+     */
+    _merge(source, target, strategy) {
+        const isObj = (v) => v !== null &&
+            typeof v === "object" &&
+            Object.getPrototypeOf(v) === Object.prototype;
+        const merge = (a, b, s) => {
+            if (b === undefined || b === null)
+                return a;
+            if (s === "replace")
+                return b;
+            if (Array.isArray(a) && Array.isArray(b)) {
+                return s === "replace" ? b : [...a, ...b];
+            }
+            if (isObj(a) && isObj(b)) {
+                const r = { ...a };
+                const sObj = isObj(s) ? s : undefined;
+                for (const k of Object.keys(b)) {
+                    r[k] = merge(a[k], b[k], sObj?.[k]);
+                }
+                return r;
+            }
+            return b;
+        };
+        return merge(source, target, strategy);
+    }
+    /** The default/base config this builder was constructed with. */
+    get base() {
+        return this._base;
+    }
+    /** The current, merged config for this builder instance. */
+    get config() {
+        return this._config;
+    }
+}
+
+const VigorAllPolicySettingsBase = {
+    __brand: createBrand("All", "Policy<Settings<Schema"),
+    concurrency: 5,
+    onlySuccess: false
 };
+/** Immutable builder for an all-policy's general settings. */
+class VigorAllPolicySettings extends VigorStatus {
+    constructor(config = VigorAllBase) {
+        super(VigorAllBase, config);
+    }
+    _create(config) {
+        return new VigorAllPolicySettings(config);
+    }
+    /** Sets the maximum number of tasks run concurrently. */
+    concurrency(num) {
+        return this._next({ policy: { settings: { concurrency: num } } });
+    }
+    /** When enabled, filters the final result down to only the tasks that succeeded. */
+    onlySuccess(bool) {
+        return this._next({ policy: { settings: { onlySuccess: bool } } });
+    }
+}
+
+const VigorAllPolicyMiddlewaresBase = {
+    __brand: createBrand("All", "Policy<Middlewares<Schema"),
+    before: [],
+    after: [],
+    onError: []
+};
+/** Immutable builder for an all-policy's per-task middleware pipeline (`before`, `after`, `onError`). */
+class VigorAllPolicyMiddlewares extends VigorStatus {
+    constructor(config = VigorAllBase) {
+        super(VigorAllBase, config);
+    }
+    _create(config) {
+        return new VigorAllPolicyMiddlewares(config);
+    }
+    /** Registers a middleware that runs before each task is invoked. */
+    before(func) {
+        return this._next({ policy: { middlewares: { before: [func] } } });
+    }
+    /** Registers a middleware that runs after each task settles successfully. */
+    after(func) {
+        return this._next({ policy: { middlewares: { after: [func] } } });
+    }
+    /** Registers a middleware that runs when an individual task fails. */
+    onError(func) {
+        return this._next({ policy: { middlewares: { onError: [func] } } });
+    }
+}
+
+const VigorAllPolicyBase = {
+    __brand: createBrand("All", "Policy<Schema"),
+    target: [],
+    settings: VigorAllPolicySettingsBase,
+    middlewares: VigorAllPolicyMiddlewaresBase
+};
+
+const VigorAllContextBase = {
+    __brand: createBrand("All", "Context<Schema"),
+    result: VigorDefault,
+    policy: VigorAllPolicyBase,
+    record: {}
+};
+const VigorAllEachContextBase = {
+    __brand: createBrand("All", "EachContext<Schema"),
+    result: VigorDefault,
+    error: VigorDefault,
+    flags: { overrided: false },
+    record: {}
+};
+
+/**
+ * Base class for all Vigor error types. Subclasses (`VigorRetryError`,
+ * `VigorFetchError`, `VigorParseError`, `VigorAllError`) fix `C`, `D`, and
+ * `T` to their own error-code union, data shape, and context shape.
+ *
+ * @typeParam C - Union of error codes for the subclass.
+ * @typeParam D - Shape of the structured error data.
+ * @typeParam T - Shape of the domain context.
+ */
 class VigorError extends Error {
     timestamp = new Date();
     cause;
     code;
     data;
     method;
-    stats;
     context;
-    constructor(code, options) {
-        const messageFn = VigorErrorMessageFuncs[code];
-        const message = `[${code}] ${messageFn(options?.data)}`;
-        super(message, { cause: options?.cause });
+    /**
+     * @param code - Machine-readable error code.
+     * @param message - Human-readable message (rendered after the `[code]` prefix).
+     * @param options - Additional error metadata (cause, data, method, context).
+     */
+    constructor(code, message, options) {
+        super(`[${code}] ${message}`);
         this.name = new.target.name;
         this.code = code;
         this.cause = options.cause;
         this.data = options.data;
         this.method = options.method;
-        this.stats = options.stats;
         this.context = options.context;
         Object.setPrototypeOf(this, new.target.prototype);
         Error.captureStackTrace?.(this, new.target);
     }
 }
-class VigorRetryError extends VigorError {
+
+const VigorAllErrorMessageFuncs = {
+    EMPTY_TARGET: (_) => `Empty target list`,
+};
+/** Error type thrown by the all module. */
+class VigorAllError extends VigorError {
+    /**
+     * @param code - One of the all module's error codes.
+     * @param options - Error metadata, including the `data` payload for `code`.
+     */
     constructor(code, options) {
-        super(code, options);
+        const messageFn = VigorAllErrorMessageFuncs[code];
+        super(code, messageFn(options.data), options);
     }
 }
-class VigorParseError extends VigorError {
-    constructor(code, options) {
-        super(code, options);
+
+const VigorAllBase = {
+    __brand: createBrand("All", "Schema"),
+    policy: VigorAllPolicyBase,
+    context: VigorAllContextBase
+};
+/**
+ * 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.
+ */
+class VigorAll extends VigorStatus {
+    constructor(config = VigorAllBase) {
+        super(VigorAllBase, config);
     }
-}
-class VigorFetchError extends VigorError {
-    constructor(code, options) {
-        super(code, options);
+    _create(config) {
+        return new VigorAll(config);
     }
-}
-class VigorAllError extends VigorError {
-    constructor(code, options) {
-        super(code, options);
+    /** Sets the list of tasks to run. */
+    target(...funcs) {
+        return this._next({ policy: { target: funcs } });
     }
-}
-class VigorStatus {
-    _base;
-    ctor;
-    _config;
-    constructor(config = {}, _base, ctor) {
-        this._base = _base;
-        this.ctor = ctor;
-        this._config = { ...this._base, ...(config || {}) };
-    }
-    _mergeConfig(source, target) {
-        const isPlainObject = (val) => val !== null && typeof val === 'object' && Object.getPrototypeOf(val) === Object.prototype;
-        if (target === undefined || target === null) {
-            return source;
+    /** Configures the all-policy's general settings (concurrency, onlySuccess). */
+    settings(input) {
+        if (typeof input === 'function' || input instanceof VigorAllPolicySettings) {
+            const result = typeof input === 'function'
+                ? input(new VigorAllPolicySettings())
+                : input;
+            return this._next(result.config);
         }
-        if (isPlainObject(source) && isPlainObject(target)) {
-            const result = { ...source };
-            Object.keys(target).forEach((key) => {
-                result[key] = this._mergeConfig(result[key], target[key]);
-            });
-            return result;
+        return this._next({ policy: { settings: input } });
+    }
+    /** Configures the all-policy's per-task middleware pipeline. */
+    middlewares(input) {
+        if (typeof input === 'function' || input instanceof VigorAllPolicyMiddlewares) {
+            const result = typeof input === 'function'
+                ? input(new VigorAllPolicyMiddlewares())
+                : input;
+            return this._next(result.config);
         }
-        if (Array.isArray(source) && Array.isArray(target)) {
-            return [...source, ...target];
+        return this._next({ policy: { middlewares: input } });
+    }
+    /** Runs a single task through the before/after/onError middleware pipeline. */
+    async _runTask(task, policy) {
+        let ctx = { ...VigorAllEachContextBase };
+        try {
+            for (const before of policy.middlewares.before)
+                await before(ctx);
+            ctx.result = await task();
+            for (const after of policy.middlewares.after)
+                await after(ctx);
+            return { success: true, value: ctx.result };
+        }
+        catch (error) {
+            ctx.error = error;
+            const setResult = (r) => { ctx.flags.overrided = true; ctx.result = r; };
+            for (const onError of policy.middlewares.onError)
+                await onError(ctx, { setResult });
+            if (ctx.flags.overrided)
+                return { success: true, value: ctx.result };
+            return { success: false, value: error };
+        }
+    }
+    /** Runs all tasks and returns the results array directly, throwing on final failure. */
+    async request() {
+        const res = await this.requestVerbose();
+        if (res.success)
+            return res.data;
+        throw res.error;
+    }
+    /** Runs all tasks and returns a result/error envelope instead of throwing. */
+    async requestVerbose() {
+        return await this.requestRuntime();
+    }
+    /** Internal execution loop implementing the bounded-concurrency worker pool. */
+    async requestRuntime(restartAttempt = 1) {
+        const config = this._merge(this.config, {});
+        const policy = config.policy;
+        try {
+            if (policy.target.length === 0)
+                throw new VigorAllError("EMPTY_TARGET", {
+                    method: "request",
+                    data: {}
+                });
+            const concurrency = Math.max(1, policy.settings.concurrency);
+            const results = new Array(policy.target.length);
+            let cursor = 0;
+            const worker = async () => {
+                while (true) {
+                    const i = cursor++;
+                    if (i >= policy.target.length)
+                        return;
+                    results[i] = await this._runTask(policy.target[i], policy);
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(concurrency, policy.target.length) }, () => worker()));
+            const result = policy.settings.onlySuccess
+                ? results.filter(r => r.success).map(r => r.value)
+                : results.map(r => r.value);
+            return {
+                success: true,
+                data: result,
+                error: null
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                data: null,
+                error
+            };
         }
-        return target;
     }
-    _next(config) { return this.ctor(this._mergeConfig(this._config, config)); }
-    _getConfig() { return this._config; }
-    _getBase() { return this._base; }
 }
-const VigorDefault = Symbol("DEFAULT");
-class VigorRetrySettings extends VigorStatus {
-    constructor(config) {
-        const base = {
-            default: VigorDefault,
-            timeout: 20 * 1000,
-            attempt: 5,
-            jitter: 1000
-        };
-        super(config, base, (c) => new VigorRetrySettings(c));
+
+const VigorFetchPolicySettingsBase = {
+    __brand: createBrand("Fetch", "Policy<Settings<Schema"),
+    retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
+    unretryStatus: [400, 401, 403, 404, 405, 413, 422],
+    maxRestarts: 3,
+    default: VigorEmpty
+};
+/** Immutable builder for a fetch policy's general settings. */
+class VigorFetchPolicySettings extends VigorStatus {
+    constructor(config = VigorFetchBase) {
+        super(VigorFetchBase, config);
+    }
+    _create(config) {
+        return new VigorFetchPolicySettings(config);
+    }
+    /** Sets response headers consulted to compute a server-suggested retry delay. */
+    retryHeaders(...strs) {
+        return this._next({ policy: { settings: { retryHeaders: strs } } });
+    }
+    /** Sets HTTP status codes that should never be retried. */
+    unretryStatus(...nums) {
+        return this._next({ policy: { settings: { unretryStatus: nums } } });
+    }
+    /** Sets the maximum number of full restarts allowed. */
+    maxRestarts(num) {
+        return this._next({ policy: { settings: { maxRestarts: num } } });
+    }
+    /** Sets the fallback value/factory used when the request ultimately fails. */
+    default(func) {
+        return this._next({ policy: { settings: { default: func } } });
     }
-    default(unk) { return this._next({ default: unk }); }
-    timeout(num) { return this._next({ timeout: num }); }
-    attempt(num) { return this._next({ attempt: num }); }
-    jitter(num) { return this._next({ jitter: num }); }
 }
-class VigorRetryInterceptors extends VigorStatus {
-    constructor(config) {
-        const base = {
-            before: [],
-            after: [],
-            result: [],
-            retryIf: [],
-            onRetry: [],
-            onError: []
-        };
-        super(config, base, (c) => new VigorRetryInterceptors(c));
-    }
-    before(...funcs) { return this._next({ before: funcs.flat() }); }
-    after(...funcs) { return this._next({ after: funcs.flat() }); }
-    result(...funcs) { return this._next({ result: funcs.flat() }); }
-    retryIf(...funcs) { return this._next({ retryIf: funcs.flat() }); }
-    onRetry(...funcs) { return this._next({ onRetry: funcs.flat() }); }
-    onError(...funcs) { return this._next({ onError: funcs.flat() }); }
+
+const VigorFetchPolicyMiddlewaresBase = {
+    __brand: createBrand("Fetch", "Policy<Middlewares<Schema"),
+    before: [],
+    after: [],
+    onResult: [],
+    onError: []
+};
+/**
+ * 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).
+ */
+class VigorFetchPolicyMiddlewares extends VigorStatus {
+    constructor(config = VigorFetchBase) {
+        super(VigorFetchBase, config);
+    }
+    _create(config) {
+        return new VigorFetchPolicyMiddlewares(config);
+    }
+    before(type, func) {
+        return this._next({ policy: { middlewares: { before: [{ _mode: type, func }] } } });
+    }
+    after(type, func) {
+        return this._next({ policy: { middlewares: { after: [{ _mode: type, func }] } } });
+    }
+    onResult(type, func) {
+        return this._next({ policy: { middlewares: { onResult: [{ _mode: type, func }] } } });
+    }
+    onError(type, func) {
+        return this._next({ policy: { middlewares: { onError: [{ _mode: type, func }] } } });
+    }
 }
-class VigorRetryAlgorithmsConstant extends VigorStatus {
-    constructor(config) {
-        const base = {
-            interval: 2000
-        };
-        super(config, base, (c) => new VigorRetryAlgorithmsConstant(c));
+
+const VigorRetryPolicySettingsBase = {
+    __brand: createBrand("Retry", "Policy<Settings<Schema"),
+    default: VigorEmpty,
+    maxAttempts: 5,
+    maxRestarts: 3,
+    timeout: 20000
+};
+/** Immutable builder for a retry policy's general settings. */
+class VigorRetryPolicySettings extends VigorStatus {
+    constructor(config = VigorRetryBase) {
+        super(VigorRetryBase, config);
     }
-    interval(num) { return this._next({ interval: num }); }
-    _calculateDelay(attempt) {
-        return this._config.interval;
+    _create(config) {
+        return new VigorRetryPolicySettings(config);
+    }
+    /** Sets the fallback value/factory used when the target ultimately fails. */
+    default(func) {
+        return this._next({
+            policy: { settings: { default: func } }
+        });
+    }
+    /** Sets the maximum number of retry attempts before giving up. */
+    maxAttempts(num) {
+        return this._next({
+            policy: { settings: { maxAttempts: num } }
+        });
+    }
+    /** Sets the maximum number of full restarts allowed. */
+    maxRestarts(num) {
+        return this._next({
+            policy: { settings: { maxRestarts: num } }
+        });
+    }
+    /** Sets the timeout, in milliseconds, for a single attempt. */
+    timeout(num) {
+        return this._next({
+            policy: { settings: { timeout: num } }
+        });
     }
 }
-class VigorRetryAlgorithmsLinear extends VigorStatus {
-    constructor(config) {
-        const base = {
-            initial: 1000,
-            increment: 1000,
-            minDelay: 500,
-            maxDelay: 20 * 1000
-        };
-        super(config, base, (c) => new VigorRetryAlgorithmsLinear(c));
+
+const VigorRetryPolicyMiddlewaresBase = {
+    __brand: createBrand("Retry", "Policy<Middlewares<Schema"),
+    before: [],
+    after: [],
+    onResult: [],
+    retryIf: [],
+    onRetry: [],
+    onError: []
+};
+/**
+ * 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).
+ */
+class VigorRetryPolicyMiddlewares extends VigorStatus {
+    constructor(config = VigorRetryBase) {
+        super(VigorRetryBase, config);
+    }
+    _create(config) {
+        return new VigorRetryPolicyMiddlewares(config);
+    }
+    before(type, func) {
+        return this._next({
+            policy: { middlewares: { before: [{ _mode: type, func }] } }
+        });
+    }
+    after(type, func) {
+        return this._next({
+            policy: { middlewares: { after: [{ _mode: type, func }] } }
+        });
+    }
+    onResult(type, func) {
+        return this._next({
+            policy: { middlewares: { onResult: [{ _mode: type, func }] } }
+        });
+    }
+    retryIf(type, func) {
+        return this._next({
+            policy: { middlewares: { retryIf: [{ _mode: type, func }] } }
+        });
+    }
+    onRetry(type, func) {
+        return this._next({
+            policy: { middlewares: { onRetry: [{ _mode: type, func }] } }
+        });
     }
-    initial(num) { return this._next({ initial: num }); }
-    increment(num) { return this._next({ increment: num }); }
-    minDelay(num) { return this._next({ minDelay: num }); }
-    maxDelay(num) { return this._next({ maxDelay: num }); }
-    _calculateDelay(attempt) {
-        const { initial, increment, minDelay, maxDelay } = this._config;
-        return Math.max(minDelay, Math.min(maxDelay, initial + increment * attempt));
+    onError(type, func) {
+        return this._next({
+            policy: { middlewares: { onError: [{ _mode: type, func }] } }
+        });
     }
 }
-class VigorRetryAlgorithmsBackoff extends VigorStatus {
-    constructor(config) {
-        const base = {
-            initial: 1000,
-            multiplier: 1.7,
-            unit: 1000,
-            minDelay: 500,
-            maxDelay: 20 * 1000
-        };
-        super(config, base, (c) => new VigorRetryAlgorithmsBackoff(c));
+
+const VigorRetryErrorMessageFuncs = {
+    VALUE_REQUIRED: ({ key }) => `Value Required (missing ${key})`,
+    RETRY_EXHAUSTED: ({ maxAttempts }) => `Retry exhausted, (max ${maxAttempts})`,
+    RESTART_EXHAUSTED: ({ maxAttempts }) => `Restart exhausted, (max ${maxAttempts})`,
+    TIMED_OUT: ({ limit }) => `Timeout: exceeded ${limit}ms`,
+};
+/** Error type thrown by the retry module. */
+class VigorRetryError extends VigorError {
+    /**
+     * @param code - One of the retry module's error codes.
+     * @param options - Error metadata, including the `data` payload for `code`.
+     */
+    constructor(code, options) {
+        const messageFn = VigorRetryErrorMessageFuncs[code];
+        super(code, messageFn(options.data), options);
+    }
+}
+
+/** Returns a random offset in the range `[-jitter, +jitter]` to randomize a computed delay. */
+function VigorJitter(jitter) {
+    return (Math.random() * 2 - 1) * jitter;
+}
+const VigorRetryPolicyAlgorithmsConstantBase = {
+    __brand: createBrand("Retry", "Policy<Algorithms<Constant<Schema"),
+    _tag: "constant",
+    jitter: 1000,
+    interval: 2000,
+    _calculateDelay: (att, config) => {
+        const { interval, jitter } = config;
+        const min = jitter;
+        let delay = Math.max(min, interval);
+        delay += VigorJitter(jitter);
+        return delay;
     }
-    initial(num) { return this._next({ initial: num }); }
-    multiplier(num) { return this._next({ multiplier: num }); }
-    unit(num) { return this._next({ unit: num }); }
-    minDelay(num) { return this._next({ minDelay: num }); }
-    maxDelay(num) { return this._next({ maxDelay: num }); }
-    _calculateDelay(attempt) {
-        const { initial, multiplier, unit, minDelay, maxDelay } = this._config;
-        return Math.max(minDelay, Math.min(maxDelay, initial + unit * Math.pow(multiplier, attempt)));
+};
+/** Immutable builder for the constant-interval retry delay algorithm. */
+class VigorRetryPolicyAlgorithmsConstant extends VigorStatus {
+    constructor(config = VigorRetryPolicyAlgorithmsConstantBase) {
+        super(VigorRetryPolicyAlgorithmsConstantBase, config);
+    }
+    _create(config) {
+        return new VigorRetryPolicyAlgorithmsConstant(config);
+    }
+    /** Sets the amount of random jitter added to the computed delay. */
+    jitter(num) {
+        return this._next({ jitter: num });
+    }
+    /** Sets the fixed delay interval, in milliseconds. */
+    interval(num) {
+        return this._next({ interval: num });
     }
 }
-class VigorRetryAlgorithmsCustom extends VigorStatus {
-    constructor(config) {
-        const base = {
-            func: (attempt) => attempt * 1000,
-            minDelay: 500,
-            maxDelay: 20 * 1000
-        };
-        super(config, base, (c) => new VigorRetryAlgorithmsCustom(c));
+const VigorRetryPolicyAlgorithmsLinearBase = {
+    __brand: createBrand("Retry", "Policy<Algorithms<Linear<Schema"),
+    _tag: "linear",
+    jitter: 1000,
+    initial: 500,
+    increment: 1000,
+    minDelay: 0,
+    maxDelay: 10000,
+    _calculateDelay: (att, config) => {
+        const { initial, jitter, increment, minDelay, maxDelay } = config;
+        const range = maxDelay - minDelay;
+        const j = Math.min(jitter, range / 2);
+        const min = minDelay + j;
+        const max = maxDelay - j;
+        let delay = initial + increment * att;
+        delay = Math.max(min, Math.min(max, delay));
+        delay += VigorJitter(j);
+        return delay;
+    }
+};
+/** Immutable builder for the linearly-increasing retry delay algorithm. */
+class VigorRetryPolicyAlgorithmsLinear extends VigorStatus {
+    constructor(config = VigorRetryPolicyAlgorithmsLinearBase) {
+        super(VigorRetryPolicyAlgorithmsLinearBase, config);
+    }
+    _create(config) {
+        return new VigorRetryPolicyAlgorithmsLinear(config);
+    }
+    /** Sets the amount of random jitter added to the computed delay. */
+    jitter(num) {
+        return this._next({ jitter: num });
+    }
+    /** Sets the initial delay, in milliseconds, before the first retry. */
+    initial(num) {
+        return this._next({ initial: num });
     }
-    func(num) { return this._next({ func: num }); }
-    _calculateDelay(attempt) {
-        const { func, minDelay, maxDelay } = this._config;
-        return Math.max(minDelay, Math.min(maxDelay, func(attempt)));
+    /** Sets how much the delay grows, in milliseconds, per attempt. */
+    increment(num) {
+        return this._next({ increment: num });
+    }
+    /** Sets the minimum allowed delay, in milliseconds. */
+    minDelay(num) {
+        return this._next({ minDelay: num });
+    }
+    /** Sets the maximum allowed delay, in milliseconds. */
+    maxDelay(num) {
+        return this._next({ maxDelay: num });
     }
 }
-class VigorRetry extends VigorStatus {
-    constructor(config) {
-        const base = {
-            target: VigorDefault,
-            settings: new VigorRetrySettings()._getBase(),
-            interceptors: new VigorRetryInterceptors()._getBase(),
-            algorithm: (attempt) => new VigorRetryAlgorithmsBackoff()._calculateDelay(attempt),
-            abortSignals: []
-        };
-        super(config, base, (c) => new VigorRetry(c));
-    }
-    RetryAlgorithms = {
-        constant: (config) => new VigorRetryAlgorithmsConstant(config),
-        linear: (config) => new VigorRetryAlgorithmsLinear(config),
-        backoff: (config) => new VigorRetryAlgorithmsBackoff(config),
-        custom: (config) => new VigorRetryAlgorithmsCustom(config)
-    };
-    _createTimelineHandler(timeline) {
-        return (action, content) => {
-            timeline.push({
-                action: action,
-                content: content,
-                time: Date.now()
-            });
-        };
+const VigorRetryPolicyAlgorithmsBackoffBase = {
+    __brand: createBrand("Retry", "Policy<Algorithms<Backoff<Schema"),
+    _tag: "backoff",
+    jitter: 800,
+    initial: 0,
+    multiplier: 1.7,
+    unit: 1000,
+    minDelay: 500,
+    maxDelay: 10000,
+    _calculateDelay: (att, config) => {
+        const { jitter, initial, multiplier, unit, minDelay, maxDelay } = config;
+        const range = maxDelay - minDelay;
+        const j = Math.min(jitter, range / 2);
+        const min = minDelay + j;
+        const max = maxDelay - j;
+        let delay = initial + unit * Math.pow(multiplier, att);
+        delay = Math.max(min, Math.min(max, delay));
+        delay += VigorJitter(j);
+        return delay;
     }
-    _createInterceptorHandler(ctx, addTimeline) {
-        return async (interceptorType, api) => {
-            const interceptorsConfig = ctx["stats"]["interceptors"];
-            const interceptors = interceptorsConfig[interceptorType];
-            addTimeline("INTERCEPTOR_LOOP_STARTED", {
-                interceptorType: interceptorType,
-                interceptors,
-            });
-            const startTime = performance.now();
-            for (const func of interceptors) {
-                const scopedApi = api(interceptorType, func);
-                await func(ctx, scopedApi);
-            }
-            const endTime = performance.now();
-            addTimeline("INTERCEPTOR_LOOP_ENDED", {
-                interceptorType: interceptorType,
-                interceptors,
-                took: endTime - startTime
+};
+/** Immutable builder for the exponential-backoff retry delay algorithm. */
+class VigorRetryPolicyAlgorithmsBackoff extends VigorStatus {
+    constructor(config = VigorRetryPolicyAlgorithmsBackoffBase) {
+        super(VigorRetryPolicyAlgorithmsBackoffBase, config);
+    }
+    _create(config) {
+        return new VigorRetryPolicyAlgorithmsBackoff(config);
+    }
+    /** Sets the amount of random jitter added to the computed delay. */
+    jitter(num) {
+        return this._next({ jitter: num });
+    }
+    /** Sets the initial delay, in milliseconds, before backoff growth is applied. */
+    initial(num) {
+        return this._next({ initial: num });
+    }
+    /** Sets the exponential growth factor applied per attempt. */
+    multiplier(num) {
+        return this._next({ multiplier: num });
+    }
+    /** Sets the base unit, in milliseconds, the multiplier is scaled by. */
+    unit(num) {
+        return this._next({ unit: num });
+    }
+    /** Sets the minimum allowed delay, in milliseconds. */
+    minDelay(num) {
+        return this._next({ minDelay: num });
+    }
+    /** Sets the maximum allowed delay, in milliseconds. */
+    maxDelay(num) {
+        return this._next({ maxDelay: num });
+    }
+}
+const VigorRetryPolicyAlgorithmsCustomBase = {
+    __brand: createBrand("Retry", "Policy<Algorithms<Custom<Schema"),
+    _tag: "custom",
+    jitter: 800,
+    minDelay: 500,
+    maxDelay: 10000,
+    target: VigorEmpty,
+    _calculateDelay: (att, config) => {
+        const { jitter, minDelay, maxDelay, target } = config;
+        if (isVigorEmpty(target))
+            throw new VigorRetryError("VALUE_REQUIRED", {
+                method: "_calculateDelay",
+                data: {
+                    key: "target"
+                }
             });
-        };
+        const range = maxDelay - minDelay;
+        const j = Math.min(jitter, range / 2);
+        const min = minDelay + j;
+        const max = maxDelay - j;
+        let delay = target(att);
+        delay = Math.max(min, Math.min(max, delay));
+        delay += VigorJitter(j);
+        return delay;
     }
-    target(func) { return this._next({ target: func }); }
-    settings(func) {
-        if (func instanceof VigorRetrySettings) {
-            return this._next({ settings: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ settings: func(new VigorRetrySettings(this._config.settings))._getConfig() });
+};
+/** Immutable builder for a user-supplied custom retry delay algorithm. */
+class VigorRetryPolicyAlgorithmsCustom extends VigorStatus {
+    constructor(config = VigorRetryPolicyAlgorithmsCustomBase) {
+        super(VigorRetryPolicyAlgorithmsCustomBase, config);
+    }
+    _create(config) {
+        return new VigorRetryPolicyAlgorithmsCustom(config);
+    }
+    /** Sets the amount of random jitter added to the computed delay. */
+    jitter(num) {
+        return this._next({ jitter: num });
+    }
+    /** Sets the minimum allowed delay, in milliseconds. */
+    minDelay(num) {
+        return this._next({ minDelay: num });
+    }
+    /** Sets the maximum allowed delay, in milliseconds. */
+    maxDelay(num) {
+        return this._next({ maxDelay: num });
+    }
+    /** Sets the user-supplied function computing the raw delay for an attempt. */
+    target(func) {
+        return this._next({ target: func });
+    }
+}
+const VigorRetryPolicyAlgorithmsBase = VigorRetryPolicyAlgorithmsConstantBase;
+/**
+ * Immutable builder for selecting a retry policy's delay algorithm.
+ *
+ * Switching algorithms (`constant`/`linear`/`backoff`/`custom`) always
+ * replaces the previous algorithm's config wholesale via the `"replace"`
+ * merge strategy, since the different algorithms' fields are not
+ * compatible with one another.
+ */
+class VigorRetryPolicyAlgorithms extends VigorStatus {
+    constructor(config = VigorRetryBase) {
+        super(VigorRetryBase, config);
+    }
+    _create(config) {
+        return new VigorRetryPolicyAlgorithms(config);
+    }
+    /** Switches to the constant-interval delay algorithm. */
+    constant(input) {
+        const leaf = this._merge(VigorRetryPolicyAlgorithmsConstantBase, input ?? {});
+        return this._next({
+            policy: { algorithms: leaf }
+        }, { policy: { algorithms: "replace" } });
+    }
+    /** Switches to the linearly-increasing delay algorithm. */
+    linear(input) {
+        const leaf = this._merge(VigorRetryPolicyAlgorithmsLinearBase, input ?? {});
+        return this._next({
+            policy: { algorithms: leaf }
+        }, { policy: { algorithms: "replace" } });
+    }
+    /** Switches to the exponential-backoff delay algorithm. */
+    backoff(input) {
+        const leaf = this._merge(VigorRetryPolicyAlgorithmsBackoffBase, input ?? {});
+        return this._next({
+            policy: { algorithms: leaf }
+        }, { policy: { algorithms: "replace" } });
+    }
+    /** Switches to a user-supplied custom delay algorithm. */
+    custom(input) {
+        const leaf = this._merge(VigorRetryPolicyAlgorithmsCustomBase, input ?? {});
+        return this._next({
+            policy: { algorithms: leaf }
+        }, { policy: { algorithms: "replace" } });
+    }
+}
+
+const VigorRetryPolicyBase = {
+    __brand: createBrand("Retry", "Policy<Schema"),
+    target: VigorEmpty,
+    abortSignals: [],
+    settings: VigorRetryPolicySettingsBase,
+    middlewares: VigorRetryPolicyMiddlewaresBase,
+    algorithms: VigorRetryPolicyAlgorithmsBase
+};
+
+const VigorRetryContextBase = {
+    __brand: createBrand("Retry", "Context<Schema"),
+    result: VigorDefault,
+    error: VigorDefault,
+    system: {
+        delay: VigorDefault,
+        attempt: 0
+    },
+    flags: {
+        doRetry: true,
+        doRestart: false,
+        brokeRetry: false,
+        overridden: false
+    },
+    record: {},
+    policy: VigorRetryPolicyBase
+};
+
+const VigorRetryBase = {
+    __brand: createBrand("Retry", "Schema"),
+    policy: VigorRetryPolicyBase,
+    context: VigorRetryContextBase
+};
+/**
+ * Immutable builder that executes a target function with retry, restart,
+ * timeout, and abort support, driven by a configurable delay algorithm and
+ * middleware pipeline.
+ */
+class VigorRetry extends VigorStatus {
+    constructor(config = VigorRetryBase) {
+        super(VigorRetryBase, config);
+    }
+    _create(config) {
+        return new VigorRetry(config);
+    }
+    /** Sets the target function to invoke, with retry/timeout applied. */
+    target(func) {
+        return this._next({
+            policy: { target: func }
+        });
+    }
+    /** Sets external abort signals that, when aborted, stop retrying. */
+    abortSignals(...sig) {
+        return this._next({
+            policy: { abortSignals: sig }
+        });
+    }
+    /** Configures the retry policy's general settings (max attempts, timeout, etc). */
+    settings(input) {
+        if (typeof input === 'function' || input instanceof VigorRetryPolicySettings) {
+            const result = typeof input === 'function'
+                ? input(new VigorRetryPolicySettings())
+                : input;
+            return this._next(result.config);
         }
-        return this._next({ settings: func });
+        return this._next({
+            policy: { settings: input }
+        });
     }
-    interceptors(func) {
-        if (func instanceof VigorRetryInterceptors) {
-            return this._next({ interceptors: func._getConfig() });
+    /** Configures the retry policy's middleware pipeline. */
+    middlewares(input) {
+        if (typeof input === 'function' || input instanceof VigorRetryPolicyMiddlewares) {
+            const result = typeof input === 'function'
+                ? input(new VigorRetryPolicyMiddlewares())
+                : input;
+            return this._next(result.config);
         }
-        if (typeof func === 'function') {
-            return this._next({ interceptors: func(new VigorRetryInterceptors(this._config.interceptors))._getConfig() });
+        return this._next({
+            policy: { middlewares: input }
+        });
+    }
+    /** Configures the retry policy's delay algorithm. */
+    algorithms(input) {
+        if (typeof input === 'function') {
+            const result = input(new VigorRetryPolicyAlgorithms());
+            const algoSlice = result.config.policy.algorithms;
+            return this._next({
+                policy: { algorithms: algoSlice }
+            }, { policy: { algorithms: "replace" } });
         }
-        return this._next({ interceptors: func });
+        return this._next({
+            policy: { algorithms: input }
+        }, { policy: { algorithms: "replace" } });
     }
-    algorithms(func) {
-        const instance = func(this.RetryAlgorithms);
-        return this._next({ algorithm: (attempt) => instance._calculateDelay(attempt) });
+    /** Runs the target and returns its result directly, throwing on final failure. */
+    async request() {
+        const res = await this.requestVerbose();
+        if (res.success)
+            return res.data;
+        throw res.error;
     }
-    abortSignals(...abortSignals) {
-        return this._next({ abortSignals: abortSignals.flat() });
+    /** Runs the target and returns a result/error envelope instead of throwing. */
+    async requestVerbose() {
+        return await this.requestRuntime();
     }
-    async request(config, timeline = []) {
-        const stats = this._mergeConfig(this._config, config);
+    /** Internal execution loop implementing the attempt/retry/restart lifecycle. */
+    async requestRuntime(restartAttempt = 1) {
+        const config = this._merge(this.config, {});
         let ctx = {
-            result: VigorDefault,
-            error: VigorDefault,
-            attempt: 0,
-            delay: 0,
-            controller: VigorDefault,
-            timeline: timeline,
-            stats,
-            flag: {
-                broke: false,
-                overwritten: false,
-                restarted: false
-            }
+            ...config.context,
+            policy: config.policy
+        };
+        if (isVigorEmpty(ctx.policy.target))
+            throw new VigorRetryError("VALUE_REQUIRED", {
+                method: "request",
+                data: {
+                    key: "target"
+                },
+                context: ctx
+            });
+        const target = ctx.policy.target;
+        const throwError = (err) => {
+            throw err;
         };
-        const addTimeline = this._createTimelineHandler(ctx.timeline);
-        const handleInterceptor = this._createInterceptorHandler(ctx, addTimeline);
-        addTimeline("PROCESS_HANDLING", {
-            type: "REQUEST_START",
-            data: {}
-        });
         try {
-            if (typeof stats.target !== 'function')
-                throw new VigorRetryError("INVALID_TARGET", {
-                    method: "request",
-                    data: {
-                        expected: ["function"],
-                        received: stats.target
-                    },
-                    stats: stats,
-                    context: ctx
-                });
-            while (ctx.attempt < stats.settings.attempt) {
-                ctx.attempt++;
-                addTimeline("ATTEMPT_INCREASED", {
-                    attempt: ctx.attempt
-                });
+            while (ctx.system.attempt < ctx.policy.settings.maxAttempts) {
+                ctx.system.attempt++;
                 try {
-                    addTimeline("PROCESS_HANDLING", {
-                        type: "RETRY_START",
-                        data: {}
-                    });
-                    const controller = new AbortController();
+                    const breakRetry = (err) => {
+                        ctx.flags.brokeRetry = true;
+                        throw err;
+                    };
+                    const userController = new AbortController();
                     const timeoutController = new AbortController();
-                    const signal = AbortSignal.any([controller.signal, timeoutController.signal, ...stats.abortSignals]);
-                    await handleInterceptor("before", (interceptorType, func) => ({
-                        abort: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "abort",
-                                args: [error]
-                            });
-                            controller.abort(error);
-                            throw error;
-                        },
-                        breakRetry: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "breakRetry",
-                                args: [error]
-                            });
-                            ctx.flag.broke = true;
-                            throw error;
-                        },
-                        throwError: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "throwError",
-                                args: [error]
-                            });
-                            throw error;
+                    const innerSignals = AbortSignal.any([
+                        userController.signal,
+                        timeoutController.signal
+                    ]);
+                    const outerSignals = AbortSignal.any(ctx.policy.abortSignals);
+                    const autoBreak = () => {
+                        ctx.flags.brokeRetry = true;
+                    };
+                    outerSignals.addEventListener("abort", autoBreak);
+                    const mergedSignals = AbortSignal.any([
+                        innerSignals,
+                        outerSignals
+                    ]);
+                    let onAbort;
+                    let timeoutId;
+                    try {
+                        for (const middleware of ctx.policy.middlewares.before) {
+                            if (middleware._mode === "fluent") {
+                                await middleware.func(ctx);
+                            }
+                            else {
+                                ctx = await middleware.func(ctx, {
+                                    abort: (reason) => userController.abort(reason),
+                                    throwError,
+                                    breakRetry
+                                });
+                            }
                         }
-                    }));
-                    const timeoutTimer = setTimeout(() => {
-                        clearTimeout(timeoutTimer);
-                        timeoutController.abort(new VigorRetryError("TIMED_OUT", {
+                        mergedSignals.throwIfAborted();
+                        timeoutId = setTimeout(() => timeoutController.abort(new VigorRetryError("TIMED_OUT", {
                             method: "request",
                             data: {
-                                limit: stats.settings.timeout,
-                                attempt: ctx.attempt
-                            },
-                        }));
-                    }, stats.settings.timeout);
-                    signal.throwIfAborted();
-                    let onAbort;
-                    try {
-                        addTimeline("TARGET_REQUEST_STARTED", {
-                            target: stats.target
-                        });
-                        const abort = (error) => {
-                            addTimeline("TARGET_API_CALLED", {
-                                target: stats.target,
-                                method: "abort"
-                            });
-                            controller.abort(error);
-                            throw error;
-                        };
-                        const started = performance.now();
+                                limit: ctx.policy.settings.timeout
+                            }
+                        })), ctx.policy.settings.timeout);
                         ctx.result = await Promise.race([
-                            stats.target(ctx, { abort, signal }),
+                            target(mergedSignals),
                             new Promise((_, rej) => {
-                                onAbort = () => rej(signal.reason);
-                                signal.addEventListener("abort", onAbort);
+                                onAbort = () => rej(mergedSignals.reason);
+                                mergedSignals.addEventListener("abort", onAbort);
                             })
                         ]);
-                        const endTime = performance.now();
-                        addTimeline("TARGET_REQUEST_ENDED", {
-                            target: stats.target,
-                            took: endTime - started
-                        });
+                        for (const middleware of ctx.policy.middlewares.after) {
+                            if (middleware._mode === "fluent") {
+                                await middleware.func(ctx);
+                            }
+                            else {
+                                ctx = await middleware.func(ctx, {
+                                    throwError
+                                });
+                            }
+                        }
+                        const setResult = (res) => {
+                            ctx.result = res;
+                        };
+                        for (const middleware of ctx.policy.middlewares.onResult) {
+                            if (middleware._mode === "fluent") {
+                                ctx.result = await middleware.func(ctx.result);
+                            }
+                            else {
+                                ctx = await middleware.func(ctx, {
+                                    setResult,
+                                    throwError
+                                });
+                            }
+                        }
+                        return {
+                            success: true,
+                            data: ctx.result,
+                            error: null
+                        };
                     }
                     finally {
-                        clearTimeout(timeoutTimer);
+                        clearTimeout(timeoutId);
+                        outerSignals.removeEventListener("abort", autoBreak);
                         if (onAbort)
-                            signal.removeEventListener("abort", onAbort);
+                            mergedSignals.removeEventListener("abort", onAbort);
                     }
-                    await handleInterceptor("after", (interceptorType, func) => ({
-                        setResult: (unknown) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "setResult",
-                                args: [unknown]
-                            });
-                            ctx.result = unknown;
-                            return unknown;
-                        },
-                        throwError: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "throwError",
-                                args: [error]
-                            });
-                            throw error;
-                        },
-                        breakRetry: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "breakRetry",
-                                args: [error]
-                            });
-                            ctx.flag.broke = true;
-                            throw error;
-                        },
-                    }));
-                    await handleInterceptor("result", (interceptorType, func) => ({
-                        setResult: (unknown) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "setResult",
-                                args: [unknown]
-                            });
-                            ctx.result = unknown;
-                            return unknown;
-                        },
-                        throwError: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "throwError",
-                                args: [error]
-                            });
-                            throw error;
-                        },
-                    }));
-                    return ctx.result;
                 }
                 catch (error) {
                     ctx.error = error;
-                    addTimeline("PROCESS_HANDLING", {
-                        type: "RETRY_ERROR",
-                        data: {
-                            error
+                    if (ctx.flags.brokeRetry)
+                        throw ctx.error;
+                    ctx.flags.doRetry = true;
+                    const proceedRetry = () => ctx.flags.doRetry = true;
+                    const cancelRetry = () => ctx.flags.doRetry = false;
+                    for (const middleware of ctx.policy.middlewares.retryIf) {
+                        if (middleware._mode === "fluent") {
+                            ctx.flags.doRetry = await middleware.func(ctx.error);
                         }
-                    });
-                    if (ctx.flag.broke)
-                        throw error;
-                    let proceed = true;
-                    await handleInterceptor("retryIf", (interceptorType, func) => ({
-                        proceedRetry: () => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "proceedRetry",
-                                args: []
-                            });
-                            return proceed = true;
-                        },
-                        cancelRetry: () => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "cancelRetry",
-                                args: []
+                        else {
+                            ctx = await middleware.func(ctx, {
+                                proceedRetry,
+                                cancelRetry
                             });
-                            return proceed = false;
                         }
-                    }));
-                    if (!proceed)
-                        throw error;
-                    ctx.delay = VigorDefault;
-                    await handleInterceptor("onRetry", (interceptorType, func) => ({
-                        throwError: (error) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "throwError",
-                                args: [error]
-                            });
-                            throw error;
-                        },
-                        setDelay: (number) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "setDelay",
-                                args: [number]
-                            });
-                            return ctx.delay = number;
-                        },
-                        setAttempt: (number) => {
-                            addTimeline("INTERCEPTOR_API_CALLED", {
-                                interceptorType,
-                                interceptor: func,
-                                method: "setAttempt",
-                                args: [number]
+                    }
+                    if (!ctx.flags.doRetry)
+                        throw ctx.error;
+                    ctx.system.delay = ctx.policy.algorithms._calculateDelay(ctx.system.attempt, ctx.policy.algorithms);
+                    const setDelay = (num) => {
+                        ctx.system.delay = num;
+                    };
+                    for (const middleware of ctx.policy.middlewares.onRetry) {
+                        if (middleware._mode === "fluent") {
+                            await middleware.func(ctx.error);
+                        }
+                        else {
+                            ctx = await middleware.func(ctx, {
+                                throwError,
+                                setDelay
                             });
-                            return ctx.attempt = number;
                         }
-                    }));
-                    if (typeof ctx.delay !== 'number')
-                        ctx.delay = stats.algorithm(ctx.attempt) + Math.random() * stats.settings.jitter;
-                    const delay = ctx.delay;
-                    await new Promise(r => setTimeout(r, delay));
+                    }
+                    const delay = ctx.system.delay;
+                    await new Promise(res => setTimeout(res, delay));
                 }
             }
-            throw new VigorRetryError("EXHAUSTED", {
+            throw new VigorRetryError("RETRY_EXHAUSTED", {
                 method: "request",
                 data: {
-                    maxAttempts: stats.settings.attempt,
-                },
-                context: ctx
+                    maxAttempts: ctx.policy.settings.maxAttempts
+                }
             });
         }
         catch (error) {
             ctx.error = error;
-            addTimeline("PROCESS_HANDLING", {
-                type: "REQUEST_ERROR",
-                data: {
-                    error
+            ctx.flags.doRestart = false;
+            ctx.flags.overridden = false;
+            const setResult = (res) => {
+                ctx.flags.overridden = true;
+                ctx.result = res;
+            };
+            const proceedRestart = () => ctx.flags.doRestart = true;
+            const cancelRestart = () => ctx.flags.doRestart = false;
+            for (const middleware of ctx.policy.middlewares.onError) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx.error);
                 }
-            });
-            await handleInterceptor("onError", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    ctx.flag.overwritten = true;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-                restart: () => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "restart",
-                        args: []
+                else {
+                    ctx = await middleware.func(ctx, {
+                        setResult,
+                        throwError,
+                        proceedRestart,
+                        cancelRestart
                     });
-                    ctx.flag.restarted = true;
                 }
-            }));
-            if (ctx.flag.restarted) {
-                return await this.request(stats, ctx.timeline);
             }
-            if (ctx.flag.overwritten)
-                return ctx.result;
-            if (stats.settings.default !== VigorDefault)
-                return stats.settings.default;
-            throw error;
+            if (ctx.flags.doRestart) {
+                if (restartAttempt + 1 > ctx.policy.settings.maxRestarts)
+                    throw new VigorRetryError("RESTART_EXHAUSTED", {
+                        method: "request",
+                        data: {
+                            maxAttempts: ctx.policy.settings.maxRestarts
+                        }
+                    });
+                return await this.requestRuntime(restartAttempt + 1);
+            }
+            if (ctx.flags.overridden)
+                return {
+                    success: true,
+                    data: ctx.result,
+                    error: null
+                };
+            if (!isVigorEmpty(ctx.policy.settings.default)) {
+                const data = await ctx.policy.settings.default(ctx);
+                return {
+                    success: true,
+                    data,
+                    error: null
+                };
+            }
+            return {
+                success: false,
+                data: null,
+                error: ctx.error
+            };
         }
     }
 }
-class VigorParseSettings extends VigorStatus {
-    constructor(config) {
-        const base = {
-            raw: false,
-            default: VigorDefault
-        };
-        super(config, base, (c) => new VigorParseSettings(c));
+
+const VigorParsePolicySettingsBase = {
+    __brand: createBrand("Parse", "Policy<Settings<Schema"),
+    raw: false,
+    default: VigorEmpty,
+    maxRestarts: 3
+};
+/** Immutable builder for a parse policy's general settings. */
+class VigorParsePolicySettings extends VigorStatus {
+    constructor(config = VigorParseBase) {
+        super(VigorParseBase, config);
+    }
+    _create(config) {
+        return new VigorParsePolicySettings(config);
+    }
+    /** When enabled, skips content-type based parsing and returns the raw response. */
+    raw(bool) {
+        return this._next({
+            policy: { settings: { raw: bool } }
+        });
+    }
+    /** Sets the fallback value/factory used when parsing ultimately fails. */
+    default(func) {
+        return this._next({
+            policy: { settings: { default: func } }
+        });
+    }
+    /** Sets the maximum number of full restarts allowed. */
+    maxRestarts(num) {
+        return this._next({
+            policy: { settings: { maxRestarts: num } }
+        });
     }
-    original(bool) { return this._next({ raw: bool }); }
-    default(unk) { return this._next({ default: unk }); }
 }
-class VigorParseStrategies extends VigorStatus {
-    constructor(config) {
-        const base = {
-            funcs: []
-        };
-        super(config, base, (c) => new VigorParseStrategies(c));
-    }
-    ParseAutoHeaders = [
-        { header: "application/json", regExp: /application\/(.+\+)?json(.+\+)?/i, method: (res) => res.json() },
-        { header: "application/xml", regExp: /application\/(.+\+)?xml(.+\+)?/i, method: (res) => res.text() },
-        { header: "application/x-www-form-urlencoded", regExp: /application\/(.+\+)?x-www-form-urlencoded(.+\+)?/i, method: (res) => res.formData() },
-        { header: "application/octet-stream", regExp: /application\/(.+\+)?octet-stream(.+\+)?/i, method: (res) => res.arrayBuffer() },
-        { header: "image/*", regExp: /^image\/.+/i, method: (res) => res.blob() },
-        { header: "audio/*", regExp: /^audio\/.+/i, method: (res) => res.blob() },
-        { header: "video/*", regExp: /^video\/.+/i, method: (res) => res.blob() },
-        { header: "multipart/form-data", regExp: /multipart\/(.+\+)?form-data(.+\+)?/i, method: (res) => res.formData() },
-        { header: "text/*", regExp: /^text\/.+/i, method: (res) => res.text() },
-    ];
-    ParseAutoMethods = [
-        { title: "json", method: (res) => res.json() },
-        { title: "formData", method: (res) => res.formData() },
-        { title: "text", method: (res) => res.text() },
-        { title: "blob", method: (res) => res.blob() },
-    ];
-    ParseAutoAlgorithms = {
-        contentType: async (response) => {
-            const parsers = this.ParseAutoHeaders;
-            const contentTypeHeader = response.headers.get("content-type");
-            if (!contentTypeHeader)
-                throw new VigorParseError("INVALID_CONTENT_TYPE", {
-                    method: "ParseAutoAlgorithms.contentType",
-                    data: {
-                        expected: ["string"],
-                        received: contentTypeHeader,
-                        response: response
-                    }
-                });
-            const toDo = parsers.find(parser => parser.regExp.test(contentTypeHeader));
-            if (!toDo)
-                throw new VigorParseError("PARSER_NOT_FOUND", {
-                    method: "ParseAutoAlgorithms.contentType",
-                    data: {
-                        expected: parsers.map(parser => parser.header),
-                        received: contentTypeHeader,
-                        response: response
-                    }
-                });
-            return await toDo.method(response);
-        },
-        sniff: async (response) => {
-            const parsers = this.ParseAutoMethods;
-            for (const [i, parser] of parsers.entries()) {
-                const cloned = (i === parsers.length - 1)
-                    ? response
-                    : response.clone();
-                try {
-                    const data = await parser.method(cloned);
-                    return data;
-                }
-                catch { }
+
+const VigorParsePolicyMiddlewaresBase = {
+    __brand: createBrand("Parse", "Policy<Middlewares<Schema"),
+    before: [],
+    after: [],
+    onResult: [],
+    onError: []
+};
+/**
+ * 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).
+ */
+class VigorParsePolicyMiddlewares extends VigorStatus {
+    constructor(config = VigorParseBase) {
+        super(VigorParseBase, config);
+    }
+    _create(config) {
+        return new VigorParsePolicyMiddlewares(config);
+    }
+    before(type, func) {
+        return this._next({ policy: { middlewares: { before: [{ _mode: type, func }] } } });
+    }
+    after(type, func) {
+        return this._next({ policy: { middlewares: { after: [{ _mode: type, func }] } } });
+    }
+    onResult(type, func) {
+        return this._next({ policy: { middlewares: { onResult: [{ _mode: type, func }] } } });
+    }
+    onError(type, func) {
+        return this._next({ policy: { middlewares: { onError: [{ _mode: type, func }] } } });
+    }
+}
+
+const VigorParseErrorMessageFuncs = {
+    VALUE_REQUIRED: ({ key }) => `Value Required (missing ${key})`,
+    INVALID_CONTENT_TYPE: ({ received }) => `Invalid Content-Type header: ${String(received)}`,
+    PARSER_NOT_FOUND: ({ received, expected }) => `Parser not found for Content-Type "${String(received)}" (known: ${expected.join(", ")})`,
+    PARSER_ALL_FAILED: ({ tried }) => `All parsers failed, tried: ${tried.join(", ")}`,
+    RESTART_EXHAUSTED: ({ maxAttempts }) => `Restart exhausted, (max ${maxAttempts})`,
+};
+/** Error type thrown by the parse module. */
+class VigorParseError extends VigorError {
+    /**
+     * @param code - One of the parse module's error codes.
+     * @param options - Error metadata, including the `data` payload for `code`.
+     */
+    constructor(code, options) {
+        const messageFn = VigorParseErrorMessageFuncs[code];
+        super(code, messageFn(options.data), options);
+    }
+}
+
+const VigorParsePolicyStrategiesBase = {
+    __brand: createBrand("Parse", "Policy<Strategies<Schema"),
+    funcs: []
+};
+const ContentTypeParsers = [
+    { header: "application/json", regExp: /application\/(.+\+)?json(.+\+)?/i, method: (res) => res.json() },
+    { header: "application/xml", regExp: /application\/(.+\+)?xml(.+\+)?/i, method: (res) => res.text() },
+    { header: "application/x-www-form-urlencoded", regExp: /application\/(.+\+)?x-www-form-urlencoded(.+\+)?/i, method: (res) => res.formData() },
+    { header: "application/octet-stream", regExp: /application\/(.+\+)?octet-stream(.+\+)?/i, method: (res) => res.arrayBuffer() },
+    { header: "image/*", regExp: /^image\/.+/i, method: (res) => res.blob() },
+    { header: "audio/*", regExp: /^audio\/.+/i, method: (res) => res.blob() },
+    { header: "video/*", regExp: /^video\/.+/i, method: (res) => res.blob() },
+    { header: "multipart/form-data", regExp: /multipart\/(.+\+)?form-data(.+\+)?/i, method: (res) => res.formData() },
+    { header: "text/*", regExp: /^text\/.+/i, method: (res) => res.text() },
+];
+const SniffMethods = [
+    { title: "json", method: (res) => res.json() },
+    { title: "formData", method: (res) => res.formData() },
+    { title: "text", method: (res) => res.text() },
+    { title: "blob", method: (res) => res.blob() },
+];
+/** Parses a response by matching its `Content-Type` header against a known parser table. */
+const VigorParseContentTypeStrategy = async (response) => {
+    const contentTypeHeader = response.headers.get("content-type");
+    if (!contentTypeHeader)
+        throw new VigorParseError("INVALID_CONTENT_TYPE", {
+            method: "VigorParseContentTypeStrategy",
+            data: { received: contentTypeHeader }
+        });
+    const toDo = ContentTypeParsers.find(parser => parser.regExp.test(contentTypeHeader));
+    if (!toDo)
+        throw new VigorParseError("PARSER_NOT_FOUND", {
+            method: "VigorParseContentTypeStrategy",
+            data: {
+                expected: ContentTypeParsers.map(p => p.header),
+                received: contentTypeHeader
             }
-            throw new VigorParseError("PARSER_ALL_FAILED", {
-                method: "ParseAutoAlgorithms.sniff",
-                data: {
-                    tried: parsers.map(parser => parser.title),
-                    response: response
-                }
-            });
+        });
+    return await toDo.method(response);
+};
+/** Parses a response by trying a sequence of body-reading methods until one succeeds. */
+const VigorParseSniffStrategy = async (response) => {
+    for (const [i, parser] of SniffMethods.entries()) {
+        const cloned = (i === SniffMethods.length - 1) ? response : response.clone();
+        try {
+            return await parser.method(cloned);
         }
-    };
-    contentType() { return this._next({ funcs: [this.ParseAutoAlgorithms.contentType] }); }
-    sniff() { return this._next({ funcs: [this.ParseAutoAlgorithms.sniff] }); }
-    json() { return this._next({ funcs: [(res) => res.json()] }); }
-    text() { return this._next({ funcs: [(res) => res.text()] }); }
-    arrayBuffer() { return this._next({ funcs: [(res) => res.arrayBuffer()] }); }
-    blob() { return this._next({ funcs: [(res) => res.blob()] }); }
-    bytes() { return this._next({ funcs: [(res) => res.arrayBuffer().then(r => new Uint8Array(r))] }); }
-    formData() { return this._next({ funcs: [(res) => res.formData()] }); }
-}
-class VigorParseInterceptors extends VigorStatus {
-    constructor(config) {
-        const base = {
-            before: [],
-            after: [],
-            result: [],
-            onError: []
-        };
-        super(config, base, (c) => new VigorParseInterceptors(c));
+        catch { }
+    }
+    throw new VigorParseError("PARSER_ALL_FAILED", {
+        method: "VigorParseSniffStrategy",
+        data: { tried: SniffMethods.map(p => p.title) }
+    });
+};
+/** Immutable builder for a parse policy's fallback chain of parsing strategies. */
+class VigorParsePolicyStrategies extends VigorStatus {
+    constructor(config = VigorParseBase) {
+        super(VigorParseBase, config);
+    }
+    _create(config) {
+        return new VigorParsePolicyStrategies(config);
+    }
+    /**
+     * 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).
+     */
+    _set(funcs, replace) {
+        return this._next({ policy: { strategies: { funcs } } }, replace ? { policy: { strategies: { funcs: "replace" } } } : undefined);
     }
-    before(...funcs) { return this._next({ before: funcs.flat() }); }
-    after(...funcs) { return this._next({ after: funcs.flat() }); }
-    result(...funcs) { return this._next({ result: funcs.flat() }); }
-    onError(...funcs) { return this._next({ onError: funcs.flat() }); }
+    /** Adds the content-type based parsing strategy. */
+    contentType(replace) { return this._set([VigorParseContentTypeStrategy], replace); }
+    /** Adds the sniffing (try-each-method) parsing strategy. */
+    sniff(replace) { return this._set([VigorParseSniffStrategy], replace); }
+    /** Adds a strategy that always parses the response as JSON. */
+    json(replace) { return this._set([(res) => res.json()], replace); }
+    /** Adds a strategy that always parses the response as text. */
+    text(replace) { return this._set([(res) => res.text()], replace); }
+    /** Adds a strategy that always parses the response as an `ArrayBuffer`. */
+    arrayBuffer(replace) { return this._set([(res) => res.arrayBuffer()], replace); }
+    /** Adds a strategy that always parses the response as a `Blob`. */
+    blob(replace) { return this._set([(res) => res.blob()], replace); }
+    /** Adds a strategy that always parses the response as a `Uint8Array`. */
+    bytes(replace) { return this._set([(res) => res.arrayBuffer().then(b => new Uint8Array(b))], replace); }
+    /** Adds a strategy that always parses the response as `FormData`. */
+    formData(replace) { return this._set([(res) => res.formData()], replace); }
+    /** Adds a user-supplied custom parsing strategy. */
+    custom(func, replace) { return this._set([func], replace); }
 }
+
+const VigorParsePolicyBase = {
+    __brand: createBrand("Parse", "Policy<Schema"),
+    target: VigorDefault,
+    settings: VigorParsePolicySettingsBase,
+    middlewares: VigorParsePolicyMiddlewaresBase,
+    strategies: VigorParsePolicyStrategiesBase
+};
+
+const VigorParseContextBase = {
+    __brand: createBrand("Parse", "Context<Schema"),
+    result: VigorDefault,
+    error: VigorDefault,
+    response: VigorDefault,
+    flags: {
+        overrided: false,
+        restarted: false
+    },
+    record: {},
+    policy: VigorParsePolicyBase
+};
+
+const VigorParseBase = {
+    __brand: createBrand("Parse", "Schema"),
+    policy: VigorParsePolicyBase,
+    context: VigorParseContextBase
+};
+/**
+ * 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.
+ */
 class VigorParse extends VigorStatus {
-    constructor(config) {
-        const base = {
-            target: VigorDefault,
-            settings: new VigorParseSettings()._getBase(),
-            strategies: new VigorParseStrategies()._getBase(),
-            interceptors: new VigorParseInterceptors()._getBase()
-        };
-        super(config, base, (c) => new VigorParse(c));
-    }
-    _createTimelineHandler(timeline) {
-        return (action, content) => {
-            timeline.push({
-                action: action,
-                content: content,
-                time: Date.now()
-            });
-        };
+    constructor(config = VigorParseBase) {
+        super(VigorParseBase, config);
+    }
+    _create(config) {
+        return new VigorParse(config);
     }
-    _createInterceptorHandler(ctx, addTimeline) {
-        return async (interceptorType, api) => {
-            const interceptorsConfig = ctx["stats"]["interceptors"];
-            const interceptors = interceptorsConfig[interceptorType];
-            addTimeline("INTERCEPTOR_LOOP_STARTED", {
-                interceptorType: interceptorType,
-                interceptors,
-            });
-            const startTime = performance.now();
-            for (const func of interceptors) {
-                const scopedApi = api(interceptorType, func);
-                await func(ctx, scopedApi);
-            }
-            const endTime = performance.now();
-            addTimeline("INTERCEPTOR_LOOP_ENDED", {
-                interceptorType: interceptorType,
-                interceptors,
-                took: endTime - startTime
-            });
-        };
+    /** Sets the `Response` object to parse. */
+    target(response) {
+        return this._next({ policy: { target: response } });
     }
-    target(response) { return this._next({ target: response }); }
-    settings(func) {
-        if (func instanceof VigorParseSettings) {
-            return this._next({ settings: func._getConfig() });
+    /** Configures the parse policy's general settings. */
+    settings(input) {
+        if (typeof input === 'function' || input instanceof VigorParsePolicySettings) {
+            const result = typeof input === 'function'
+                ? input(new VigorParsePolicySettings())
+                : input;
+            return this._next(result.config);
         }
-        if (typeof func === 'function') {
-            return this._next({ settings: func(new VigorParseSettings(this._config.settings))._getConfig() });
-        }
-        return this._next({ settings: func });
+        return this._next({ policy: { settings: input } });
     }
-    strategies(func) {
-        if (func instanceof VigorParseStrategies) {
-            return this._next({ strategies: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ strategies: func(new VigorParseStrategies(this._config.strategies))._getConfig() });
+    /** Configures the parse policy's middleware pipeline. */
+    middlewares(input) {
+        if (typeof input === 'function' || input instanceof VigorParsePolicyMiddlewares) {
+            const result = typeof input === 'function'
+                ? input(new VigorParsePolicyMiddlewares())
+                : input;
+            return this._next(result.config);
         }
-        return this._next({ strategies: func });
+        return this._next({ policy: { middlewares: input } });
     }
-    interceptors(func) {
-        if (func instanceof VigorParseInterceptors) {
-            return this._next({ interceptors: func._getConfig() });
+    /** Configures the parse policy's fallback chain of parsing strategies. */
+    strategies(input) {
+        if (typeof input === 'function' || input instanceof VigorParsePolicyStrategies) {
+            const result = typeof input === 'function'
+                ? input(new VigorParsePolicyStrategies())
+                : input;
+            return this._next(result.config);
         }
-        if (typeof func === 'function') {
-            return this._next({ interceptors: func(new VigorParseInterceptors(this._config.interceptors))._getConfig() });
-        }
-        return this._next({ interceptors: func });
+        return this._next({ policy: { strategies: input } });
+    }
+    /** Runs parsing and returns the result directly, throwing on final failure. */
+    async request() {
+        const res = await this.requestVerbose();
+        if (res.success)
+            return res.data;
+        throw res.error;
     }
-    async request(config, timeline = []) {
-        const stats = this._mergeConfig(this._config, config);
-        const target = stats.target;
+    /** Runs parsing and returns a result/error envelope instead of throwing. */
+    async requestVerbose() {
+        return await this.requestRuntime();
+    }
+    /** Internal execution loop implementing the strategy fallback and restart handling. */
+    async requestRuntime(restartAttempt = 1) {
+        const config = this._merge(this.config, {});
         let ctx = {
-            timeline: timeline,
-            stats,
-            response: target,
-            result: VigorDefault,
-            error: VigorDefault,
-            flag: {
-                overwritten: false
-            }
+            ...config.context,
+            policy: config.policy
         };
-        const addTimeline = this._createTimelineHandler(ctx.timeline);
-        const handleInterceptor = this._createInterceptorHandler(ctx, addTimeline);
-        addTimeline("PROCESS_HANDLING", {
-            type: "REQUEST_START",
-            data: {}
-        });
+        if (isVigorDefault(ctx.policy.target))
+            throw new VigorParseError("VALUE_REQUIRED", {
+                method: "request",
+                data: { key: "target" },
+                context: ctx
+            });
+        ctx.response = ctx.policy.target;
+        const throwError = (err) => { throw err; };
         try {
-            if (target === VigorDefault)
-                throw new VigorParseError("INVALID_TARGET", {
-                    method: "request",
-                    data: {
-                        expected: ["Response"],
-                        received: target
-                    },
-                    context: ctx
-                });
-            await handleInterceptor("before", (interceptorType, func) => ({
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-            }));
-            if (stats.settings.raw) {
-                ctx.result = ctx.response;
+            for (const middleware of ctx.policy.middlewares.before) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx);
+                }
+                else {
+                    ctx = await middleware.func(ctx, { throwError });
+                }
+            }
+            const response = ctx.response;
+            if (ctx.policy.settings.raw) {
+                ctx.result = response;
             }
             else {
+                const funcs = ctx.policy.strategies.funcs.length > 0
+                    ? ctx.policy.strategies.funcs
+                    : [VigorParseContentTypeStrategy];
                 let parsed = false;
-                for (const [i, func] of stats.strategies.funcs.length > 0
-                    ? stats.strategies.funcs.entries()
-                    : new VigorParseStrategies().contentType()._getConfig().funcs.entries()) {
-                    const cloned = (i === stats.strategies.funcs.length - 1)
-                        ? ctx.response
-                        : ctx.response.clone();
+                for (const [i, func] of funcs.entries()) {
+                    const cloned = (i === funcs.length - 1) ? response : response.clone();
                     try {
                         ctx.result = await func(cloned);
                         parsed = true;
@@ -797,953 +1363,583 @@ class VigorParse extends VigorStatus {
                 if (!parsed)
                     throw new VigorParseError("PARSER_ALL_FAILED", {
                         method: "request",
-                        data: {
-                            tried: stats.strategies.funcs,
-                            response: ctx.response
-                        },
+                        data: { tried: funcs.map((_, i) => `strategy#${i}`) },
                         context: ctx
                     });
             }
-            await handleInterceptor("after", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-            }));
-            await handleInterceptor("result", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-            }));
-            return ctx.result;
+            const setResult = (res) => { ctx.result = res; };
+            for (const middleware of ctx.policy.middlewares.after) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx);
+                }
+                else {
+                    ctx = await middleware.func(ctx, { setResult, throwError });
+                }
+            }
+            for (const middleware of ctx.policy.middlewares.onResult) {
+                if (middleware._mode === "fluent") {
+                    ctx.result = await middleware.func(ctx.result);
+                }
+                else {
+                    ctx = await middleware.func(ctx, { setResult, throwError });
+                }
+            }
+            return {
+                success: true,
+                data: ctx.result,
+                error: null
+            };
         }
         catch (error) {
             ctx.error = error;
-            addTimeline("PROCESS_HANDLING", {
-                type: "REQUEST_ERROR",
-                data: {
-                    error
+            ctx.flags.overrided = false;
+            ctx.flags.restarted = false;
+            const setResult = (res) => {
+                ctx.flags.overrided = true;
+                ctx.result = res;
+            };
+            const proceedRestart = () => ctx.flags.restarted = true;
+            const cancelRestart = () => ctx.flags.restarted = false;
+            for (const middleware of ctx.policy.middlewares.onError) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx.error);
                 }
-            });
-            await handleInterceptor("onError", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    ctx.flag.overwritten = true;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
+                else {
+                    ctx = await middleware.func(ctx, { setResult, throwError, proceedRestart, cancelRestart });
+                }
+            }
+            if (ctx.flags.restarted) {
+                if (restartAttempt + 1 > ctx.policy.settings.maxRestarts)
+                    throw new VigorParseError("RESTART_EXHAUSTED", {
+                        method: "request",
+                        data: {
+                            maxAttempts: ctx.policy.settings.maxRestarts
+                        }
                     });
-                    throw error;
-                },
-            }));
-            if (ctx.flag.overwritten)
-                return ctx.result;
-            if (stats.settings.default !== VigorDefault)
-                return stats.settings.default;
-            throw error;
+                return await this.requestRuntime(restartAttempt + 1);
+            }
+            if (ctx.flags.overrided)
+                return {
+                    success: true,
+                    data: ctx.result,
+                    error: null
+                };
+            if (!isVigorEmpty(ctx.policy.settings.default)) {
+                const data = await ctx.policy.settings.default(ctx);
+                return {
+                    success: true,
+                    data,
+                    error: null
+                };
+            }
+            return {
+                success: false,
+                data: null,
+                error: ctx.error
+            };
         }
     }
 }
-class VigorFetchSettings extends VigorStatus {
-    constructor(config) {
-        const base = {
-            retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
-            unretryStatus: [400, 401, 403, 404, 405, 413, 422],
-            default: VigorDefault
-        };
-        super(config, base, (c) => new VigorFetchSettings(c));
-    }
-    retryHeaders(...strs) { return this._next({ retryHeaders: strs.flat() }); }
-    unretryStatus(...nums) { return this._next({ unretryStatus: nums.flat() }); }
-    default(unk) { return this._next({ default: unk }); }
-}
-class VigorFetchInterceptors extends VigorStatus {
-    constructor(config) {
-        const base = {
-            before: [],
-            after: [],
-            result: [],
-            onError: []
-        };
-        super(config, base, (c) => new VigorFetchInterceptors(c));
+
+const VigorFetchPolicyBase = {
+    __brand: createBrand("Fetch", "Policy<Schema"),
+    method: VigorEmpty,
+    origin: VigorEmpty,
+    path: [],
+    query: [],
+    hash: "",
+    headers: {},
+    body: VigorEmpty,
+    extra: {},
+    settings: VigorFetchPolicySettingsBase,
+    middlewares: VigorFetchPolicyMiddlewaresBase,
+    retry: VigorRetryBase,
+    parse: VigorParseBase
+};
+
+const VigorFetchContextBase = {
+    __brand: createBrand("Fetch", "Context<Schema"),
+    href: "",
+    response: VigorDefault,
+    result: VigorDefault,
+    error: VigorDefault,
+    options: VigorDefault,
+    flags: {
+        overrided: false,
+        restarted: false
+    },
+    record: {},
+    policy: VigorFetchPolicyBase
+};
+
+const VigorFetchErrorMessageFuncs = {
+    VALUE_REQUIRED: ({ key }) => `Value Required (missing ${key})`,
+    INVALID_BODY: ({ received }) => `Invalid Body type: ${typeof received}`,
+    INVALID_PROTOCOL: ({ origin, base }) => base
+        ? `Invalid URL: could not resolve "${origin}" against base "${base}"`
+        : `Invalid URL: "${origin}" is not an absolute URL, and no base (window.location) is available to resolve it against — pass an absolute origin (e.g. "https://api.example.com") when running outside a browser`,
+    FETCH_FAILED: ({ status, statusText }) => `Fetch Failed: ${status} ${statusText}`,
+    RESTART_EXHAUSTED: ({ maxAttempts }) => `Restart exhausted, (max ${maxAttempts})`,
+};
+/** Error type thrown by the fetch module. */
+class VigorFetchError extends VigorError {
+    /**
+     * @param code - One of the fetch module's error codes.
+     * @param options - Error metadata, including the `data` payload for `code`.
+     */
+    constructor(code, options) {
+        const messageFn = VigorFetchErrorMessageFuncs[code];
+        super(code, messageFn(options.data), options);
     }
-    before(...funcs) { return this._next({ before: funcs.flat() }); }
-    after(...funcs) { return this._next({ after: funcs.flat() }); }
-    result(...funcs) { return this._next({ result: funcs.flat() }); }
-    onError(...funcs) { return this._next({ onError: funcs.flat() }); }
 }
+
+const VigorFetchBase = {
+    __brand: createBrand("Fetch", "Schema"),
+    policy: VigorFetchPolicyBase,
+    context: VigorFetchContextBase
+};
+/**
+ * Immutable builder that performs an HTTP request, composing an internal
+ * {@link VigorRetry} engine (for retry/timeout/backoff) and a
+ * {@link VigorParse} engine (for response parsing), with a configurable
+ * middleware pipeline around request building and response handling.
+ */
 class VigorFetch extends VigorStatus {
-    constructor(config) {
-        const base = {
-            origin: VigorDefault,
-            path: [],
-            query: [],
-            hash: "",
-            options: {
-                headers: {},
-                body: VigorDefault
-            },
-            settings: new VigorFetchSettings()._getBase(),
-            interceptors: new VigorFetchInterceptors()._getBase(),
-            retryConfig: new VigorRetry()._getBase(),
-            parseConfig: new VigorParse()._getBase()
-        };
-        super(config, base, (c) => new VigorFetch(c));
-    }
-    _createTimelineHandler(timeline) {
-        return (action, content) => {
-            timeline.push({
-                action: action,
-                content: content,
-                time: Date.now()
-            });
-        };
+    constructor(config = VigorFetchBase) {
+        super(VigorFetchBase, config);
     }
-    _createInterceptorHandler(ctx, addTimeline) {
-        return async (interceptorType, api) => {
-            const interceptorsConfig = ctx["stats"]["interceptors"];
-            const interceptors = interceptorsConfig[interceptorType];
-            addTimeline("INTERCEPTOR_LOOP_STARTED", {
-                interceptorType: interceptorType,
-                interceptors,
-            });
-            const startTime = performance.now();
-            for (const func of interceptors) {
-                const scopedApi = api(interceptorType, func);
-                await func(ctx, scopedApi);
-            }
-            const endTime = performance.now();
-            addTimeline("INTERCEPTOR_LOOP_ENDED", {
-                interceptorType: interceptorType,
-                interceptors,
-                took: endTime - startTime
-            });
-        };
+    _create(config) {
+        return new VigorFetch(config);
+    }
+    /** Sets the HTTP method. Defaults to `POST` when a body is set, otherwise `GET`. */
+    method(str) { return this._next({ policy: { method: str } }); }
+    /** Sets the request origin, either an absolute URL or a path relative to the current page. */
+    origin(str) { return this._next({ policy: { origin: str } }); }
+    /** Appends path segments to the request URL. */
+    path(...strs) {
+        return this._next({ policy: { path: this._stringifyList(strs) } });
+    }
+    /** Adds query-string parameter objects to the request URL. */
+    query(...objs) {
+        return this._next({ policy: { query: objs } });
+    }
+    /** Sets the URL fragment ("hash"), replacing any previous value. */
+    hash(str) { return this._next({ policy: { hash: str } }, { policy: { hash: "replace" } }); }
+    /**
+     * Sets request headers.
+     *
+     * @param mode - `"overwrite"` discards all previously configured headers
+     *  and keeps only the ones passed here. `"merge"` behaves like
+     *  `Object.assign`, overwriting only the keys that overlap and keeping
+     *  the rest.
+     */
+    headers(mode, obj) {
+        if (mode === "overwrite")
+            return this._next({ policy: { headers: obj } }, { policy: { headers: "replace" } });
+        return this._next({ policy: { headers: obj } });
     }
+    /**
+     * Sets the request body.
+     *
+     * @param mode - `"overwrite"` discards the previous body and fully
+     *  replaces it with this value. `"merge"` shallow-merges (via
+     *  `Object.assign`) when both the previous and new body are plain
+     *  objects; for any other body type (string/Blob/FormData/etc) it is
+     *  simply replaced.
+     */
+    body(mode, obj) {
+        if (mode === "overwrite")
+            return this._next({ policy: { body: obj } }, { policy: { body: "replace" } });
+        return this._next({ policy: { body: obj } });
+    }
+    /**
+     * Sets additional `RequestInit` options other than headers/body/method/signal
+     * (e.g. `credentials`, `mode`, `cache`, `redirect`, `referrer`,
+     * `referrerPolicy`, `keepalive`, `integrity`).
+     *
+     * @param mode - `"overwrite"` discards all previously configured options
+     *  and replaces them with this value. `"merge"` shallow-merges this
+     *  value onto the previous options.
+     */
+    options(mode, obj) {
+        if (mode === "overwrite")
+            return this._next({ policy: { extra: obj } }, { policy: { extra: "replace" } });
+        return this._next({ policy: { extra: obj } });
+    }
+    /** Configures the fetch policy's general settings. */
+    settings(input) {
+        if (typeof input === 'function' || input instanceof VigorFetchPolicySettings) {
+            const result = typeof input === 'function'
+                ? input(new VigorFetchPolicySettings())
+                : input;
+            return this._next(result.config);
+        }
+        return this._next({ policy: { settings: input } });
+    }
+    /** Configures the fetch policy's middleware pipeline. */
+    middlewares(input) {
+        if (typeof input === 'function' || input instanceof VigorFetchPolicyMiddlewares) {
+            const result = typeof input === 'function'
+                ? input(new VigorFetchPolicyMiddlewares())
+                : input;
+            return this._next(result.config);
+        }
+        return this._next({ policy: { middlewares: input } });
+    }
+    /** Configures the retry engine used to send the underlying request. */
+    retry(input) {
+        if (typeof input === 'function' || input instanceof VigorRetry) {
+            const result = typeof input === 'function'
+                ? input(new VigorRetry())
+                : input;
+            return this._next({ policy: { retry: result.config } }, { policy: { retry: "replace" } });
+        }
+        return this._next({ policy: { retry: input } }, { policy: { retry: "replace" } });
+    }
+    /** Configures the parse engine used to interpret the response. */
+    parse(input) {
+        if (typeof input === 'function' || input instanceof VigorParse) {
+            const result = typeof input === 'function'
+                ? input(new VigorParse())
+                : input;
+            return this._next({ policy: { parse: result.config } }, { policy: { parse: "replace" } });
+        }
+        return this._next({ policy: { parse: input } }, { policy: { parse: "replace" } });
+    }
+    /** Converts a list of stringable values into strings, dropping `null`/`undefined` entries. */
     _stringifyList(unkList) {
         return unkList
             .filter(unk => unk !== null && unk !== undefined)
-            .map(unk => {
-            if (unk instanceof Date)
-                return unk.toISOString();
-            return String(unk);
-        });
+            .map(unk => unk instanceof Date ? unk.toISOString() : String(unk));
+    }
+    /**
+     * Resolves the base URL used to interpret a relative `origin`. In a
+     * browser environment this is the current page location; in
+     * environments without `location` (e.g. Node), no base is available and
+     * `origin` must be an absolute URL.
+     */
+    _resolveBase() {
+        if (typeof globalThis !== 'undefined' && globalThis.location?.href) {
+            return globalThis.location.href;
+        }
+        return undefined;
     }
-    method(str) { return this._next({ method: str }); }
-    origin(str) { return this._next({ origin: str }); }
-    path(...strs) { return this._next({ path: this._stringifyList(strs.flat()) }); }
-    query(...strs) { return this._next({ query: strs.flat() }); }
-    hash(str) { return this._next({ hash: str }); }
-    options(obj) { return this._next({ options: obj }); }
-    headers(obj) { return this._next({ options: { headers: obj } }); }
-    body(obj) { return this._next({ options: { headers: this._config.options.headers, body: obj } }); }
+    /**
+     * Builds the final request URL from the configured origin, path
+     * segments, query parameters, and hash. An absolute `origin` ignores
+     * the resolved base (per the `URL` spec); a relative `origin` is
+     * resolved against it. Throws `INVALID_PROTOCOL` if neither is possible.
+     */
     _buildUrl(origin, path, query, hash) {
-        const originObj = new URL(origin);
-        const baseStr = originObj.origin;
-        const pathObj = [originObj.pathname.replace(/^\/+|\/+$/g, '')];
-        for (const str of path) {
-            pathObj.push(str.replace(/^\/+|\/+$/g, ''));
+        const base = this._resolveBase();
+        let originObj;
+        try {
+            originObj = new URL(origin, base);
+        }
+        catch {
+            throw new VigorFetchError("INVALID_PROTOCOL", {
+                method: "_buildUrl",
+                data: { origin, base }
+            });
         }
-        const pathStr = pathObj.join('/');
+        const baseStr = originObj.origin;
+        const pathParts = [originObj.pathname.replace(/^\/+|\/+$/g, '')];
+        for (const p of path)
+            pathParts.push(p.replace(/^\/+|\/+$/g, ''));
+        const pathStr = pathParts.filter(Boolean).join('/');
         const mainObj = new URL(pathStr, baseStr);
-        const parseVal = (val) => {
-            if (val instanceof Date)
-                return val.toISOString();
-            return String(val);
-        };
-        const queryObj = [...Array.from(originObj.searchParams.entries()), ...query.flatMap(qu => Object.entries(qu))];
-        for (const [key, val] of queryObj) {
+        const parseVal = (val) => val instanceof Date ? val.toISOString() : String(val);
+        const queryEntries = [...originObj.searchParams.entries(), ...query.flatMap(q => Object.entries(q))];
+        for (const [key, val] of queryEntries) {
             if (val === undefined || val === null)
                 continue;
-            if (Array.isArray(val))
-                for (const e of val) {
+            if (Array.isArray(val)) {
+                for (const e of val)
                     mainObj.searchParams.append(key, parseVal(e));
-                }
+            }
             else {
                 mainObj.searchParams.append(key, parseVal(val));
             }
         }
-        mainObj.hash = hash ?? originObj.hash;
+        mainObj.hash = hash || originObj.hash;
         return mainObj.href;
     }
-    _normalizeOptions(body) {
+    /** Infers the `Content-Type` header and serializes `body` into a `BodyInit`. */
+    _normalizeBody(body) {
         if (body == null)
-            return { isJson: false, headers: {}, body };
+            return { headers: {}, body: body };
         if (typeof body === "string")
-            return { isJson: false, headers: {
-                    "Content-Type": "text/plain;charset=UTF-8"
-                }, body };
+            return { headers: { "Content-Type": "text/plain;charset=UTF-8" }, body };
         if (body instanceof Blob)
-            return { isJson: false, headers: {
-                    ...(body.type && { "Content-Type": body.type })
-                }, body };
+            return { headers: body.type ? { "Content-Type": body.type } : {}, body };
         if (body instanceof ArrayBuffer)
-            return { isJson: false, headers: {
-                    "Content-Type": "application/octet-stream"
-                }, body };
+            return { headers: { "Content-Type": "application/octet-stream" }, body };
         if (body instanceof URLSearchParams)
-            return { isJson: false, headers: {
-                    "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
-                }, body };
+            return { headers: { "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8" }, body };
         if (body instanceof FormData)
-            return { isJson: false, headers: {}, body };
-        if (typeof body === "object") {
-            return { isJson: true, headers: {
-                    "Content-Type": "application/json"
-                }, body: JSON.stringify(body) };
-        }
+            return { headers: {}, body };
+        if (typeof body === "object")
+            return { headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) };
         throw new VigorFetchError("INVALID_BODY", {
             method: "_normalizeBody",
-            data: {
-                expected: ["string", "Blob", "ArrayBuffer", "URLSearchParams", "FormData"],
-                received: body
-            }
+            data: { received: body }
         });
     }
-    settings(func) {
-        if (func instanceof VigorFetchSettings) {
-            return this._next({ settings: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ settings: func(new VigorFetchSettings(this._config.settings))._getConfig() });
-        }
-        return this._next({ settings: func });
-    }
-    interceptors(func) {
-        if (func instanceof VigorFetchInterceptors) {
-            return this._next({ interceptors: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ interceptors: func(new VigorFetchInterceptors(this._config.interceptors))._getConfig() });
-        }
-        return this._next({ interceptors: func });
-    }
-    retryConfig(func) {
-        if (func instanceof VigorRetry) {
-            return this._next({ retryConfig: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ retryConfig: func(new VigorRetry(this._config.retryConfig))._getConfig() });
-        }
-        return this._next({ retryConfig: func });
+    /** Runs the request and returns its parsed result directly, throwing on final failure. */
+    async request() {
+        const res = await this.requestVerbose();
+        if (res.success)
+            return res.data;
+        throw res.error;
     }
-    parseConfig(func) {
-        if (func instanceof VigorParse) {
-            return this._next({ parseConfig: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ parseConfig: func(new VigorParse(this._config.parseConfig))._getConfig() });
-        }
-        return this._next({ parseConfig: func });
+    /** Runs the request and returns a result/error envelope instead of throwing. */
+    async requestVerbose() {
+        return await this.requestRuntime();
     }
-    async request(config, timeline = []) {
-        const stats = this._mergeConfig(this._config, config);
+    /** Internal execution loop implementing URL building, retry, parsing, and restart handling. */
+    async requestRuntime(restartAttempt = 1) {
+        const config = this._merge(this.config, {});
         let ctx = {
-            href: "",
-            result: VigorDefault,
-            response: VigorDefault,
-            options: {
-                headers: VigorDefault,
-                body: VigorDefault
-            },
-            error: VigorDefault,
-            timeline: timeline,
-            stats,
-            flag: {
-                overwritten: false,
-                restarted: false
-            }
+            ...config.context,
+            policy: config.policy
         };
-        const addTimeline = this._createTimelineHandler(ctx.timeline);
-        const handleInterceptor = this._createInterceptorHandler(ctx, addTimeline);
-        addTimeline("PROCESS_HANDLING", {
-            type: "REQUEST_START",
-            data: {}
-        });
+        const throwError = (err) => { throw err; };
         try {
-            try {
-                new URL(stats.origin);
-            }
-            catch {
-                throw new VigorFetchError("INVALID_PROTOCOL", {
+            if (isVigorEmpty(ctx.policy.origin))
+                throw new VigorFetchError("VALUE_REQUIRED", {
                     method: "request",
-                    data: {
-                        expected: ["valid URL protocol"],
-                        received: stats.origin
-                    }
+                    data: { key: "origin" }
                 });
-            }
-            ctx.href = this._buildUrl(stats.origin, stats.path, stats.query, stats.hash);
-            addTimeline("BUILT_URL", {
-                url: ctx.href
-            });
-            const { headers, body, ...others } = stats.options;
-            const hasBody = body !== VigorDefault &&
-                body !== undefined;
-            const method = stats.method || (hasBody ? 'POST' : 'GET');
-            ctx.options = {
-                ...others,
+            ctx.href = this._buildUrl(ctx.policy.origin, ctx.policy.path, ctx.policy.query, ctx.policy.hash);
+            const hasBody = !isVigorEmpty(ctx.policy.body) && ctx.policy.body !== undefined;
+            const method = ctx.policy.method || (hasBody ? "POST" : "GET");
+            let options = {
+                ...ctx.policy.extra,
                 method: method,
                 headers: {}
             };
             if (hasBody) {
-                const normalized = this._normalizeOptions(body);
-                if (normalized.body !== undefined) {
-                    ctx.options.body = normalized.body;
+                const normalized = this._normalizeBody(ctx.policy.body);
+                if (normalized.body !== undefined)
+                    options.body = normalized.body;
+                Object.assign(options.headers, normalized.headers);
+            }
+            Object.assign(options.headers, ctx.policy.headers);
+            for (const middleware of ctx.policy.middlewares.before) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx);
+                }
+                else {
+                    ctx = await middleware.func(ctx, {
+                        throwError,
+                        setOptions: (o) => { options = o; },
+                        setHeaders: (h) => { options.headers = h; },
+                        setBody: (b) => { options.body = b; }
+                    });
                 }
-                Object.assign(ctx.options.headers, normalized.headers);
             }
-            Object.assign(ctx.options.headers, headers);
-            addTimeline("SET_OPTIONS", {
-                options: ctx.options
-            });
-            const fetchTask = async (ctx2, { abort, signal }) => {
-                ctx.options.signal = signal;
-                const result = await fetch(ctx.href, ctx.options);
-                return result;
-            };
-            const throwStatus = async (ctx2, api) => {
-                const response = ctx2.result;
+            ctx.options = options;
+            const retryEngine = new VigorRetry(ctx.policy.retry)
+                .target(async (signal) => {
+                return await fetch(ctx.href, { ...options, signal });
+            })
+                .middlewares(m => m
+                .after("intercept", async (rctx, api) => {
+                const response = rctx.result;
                 if (!response.ok) {
+                    let parsed = undefined;
+                    try {
+                        parsed = await new VigorParse(ctx.policy.parse).target(response.clone()).request();
+                    }
+                    catch {
+                    }
                     api.throwError(new VigorFetchError("FETCH_FAILED", {
                         method: "request",
                         data: {
                             status: response.status,
-                            response: response,
+                            statusText: response.statusText,
+                            response,
                             url: response.url,
-                            headers: response.headers,
-                            body: response.body,
-                            statusText: response.statusText
+                            parsed
                         }
                     }));
                 }
-            };
-            const handleBlacklist = async (ctx2, api) => {
-                const response = ctx2.result;
-                ctx.error = ctx2.error;
-                if (response instanceof Response) {
-                    if (stats.settings.unretryStatus.includes(response.status))
-                        api.cancelRetry();
-                    else
-                        api.proceedRetry();
-                }
-            };
-            const handleRatelimit = async (ctx2, api) => {
-                const response = ctx2.result;
-                ctx.error = ctx2.error;
-                if (response instanceof Response) {
-                    if (response.status === 429) {
-                        let retryHeader = null;
-                        for (const header of stats.settings.retryHeaders) {
-                            retryHeader = response.headers.get(header);
-                            if (retryHeader)
-                                break;
-                        }
-                        if (retryHeader) {
-                            const toNumber = Number(retryHeader);
-                            const delay = !isNaN(toNumber)
-                                ? toNumber * 1000
-                                : (() => {
-                                    const toDate = new Date(retryHeader).getTime();
-                                    return !isNaN(toDate)
-                                        ? toDate - Date.now()
-                                        : null;
-                                })();
-                            if (delay !== null && delay > 0)
-                                api.setDelay(delay + Math.random() * ctx2.stats.settings.jitter);
-                        }
+                return rctx;
+            })
+                .retryIf("intercept", async (rctx, api) => {
+                const response = rctx.error instanceof VigorFetchError
+                    ? rctx.error.data?.response
+                    : undefined;
+                if (response && ctx.policy.settings.unretryStatus.includes(response.status))
+                    api.cancelRetry();
+                else
+                    api.proceedRetry();
+                return rctx;
+            })
+                .onRetry("intercept", async (rctx, api) => {
+                const response = rctx.error instanceof VigorFetchError
+                    ? rctx.error.data?.response
+                    : undefined;
+                if (response?.status === 429) {
+                    let retryHeader = null;
+                    for (const header of ctx.policy.settings.retryHeaders) {
+                        retryHeader = response.headers.get(header);
+                        if (retryHeader)
+                            break;
+                    }
+                    if (retryHeader) {
+                        const toNumber = Number(retryHeader);
+                        const delay = !isNaN(toNumber)
+                            ? toNumber * 1000
+                            : (() => {
+                                const toDate = new Date(retryHeader).getTime();
+                                return !isNaN(toDate) ? toDate - Date.now() : null;
+                            })();
+                        if (delay !== null && delay > 0)
+                            api.setDelay(delay);
                     }
                 }
-            };
-            stats.retryConfig.interceptors.after = [throwStatus, ...stats.retryConfig.interceptors.after];
-            stats.retryConfig.interceptors.retryIf = [handleBlacklist, ...stats.retryConfig.interceptors.retryIf];
-            stats.retryConfig.interceptors.onRetry = [handleRatelimit, ...stats.retryConfig.interceptors.onRetry];
-            const retryEngine = new VigorRetry(stats.retryConfig)
-                .target(fetchTask);
-            const parseEngine = new VigorParse(stats.parseConfig);
-            addTimeline("ENGINE_CREATED", {
-                retryEngine,
-                parseEngine
-            });
-            await handleInterceptor("before", (interceptorType, func) => ({
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-                setOptions: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setOptions",
-                        args: [unknown]
-                    });
-                    return ctx.options = unknown;
-                },
-                setHeaders: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setHeaders",
-                        args: [unknown]
-                    });
-                    return ctx.options.headers = unknown;
-                },
-                setBody: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setBody",
-                        args: [unknown]
-                    });
-                    return ctx.options.body = unknown;
-                }
+                return rctx;
             }));
-            addTimeline("RETRY_STARTED", {
-                engine: retryEngine
-            });
-            const retryStart = performance.now();
-            const retryTimeline = [];
-            ctx.response = await retryEngine.request(undefined, retryTimeline);
-            const retryEnd = performance.now();
-            addTimeline("RETRY_ENDED", {
-                engine: retryEngine,
-                timeline: retryTimeline,
-                took: retryEnd - retryStart,
-                response: ctx.response
-            });
-            addTimeline("PARSE_STARTED", {
-                engine: parseEngine
-            });
-            const parseStart = performance.now();
-            const parseTimeline = [];
-            ctx.result = await parseEngine.target(ctx.response).request(undefined, parseTimeline);
-            const parseEnd = performance.now();
-            addTimeline("PARSE_ENDED", {
-                engine: parseEngine,
-                timeline: parseTimeline,
-                took: parseEnd - parseStart,
-                result: ctx.result
-            });
-            await handleInterceptor("after", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-            }));
-            await handleInterceptor("result", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-            }));
-            return ctx.result;
-        }
-        catch (error) {
-            ctx.error = error;
-            addTimeline("PROCESS_HANDLING", {
-                type: "REQUEST_ERROR",
-                data: {
-                    error
+            ctx.response = await retryEngine.request();
+            const parseEngine = new VigorParse(ctx.policy.parse).target(ctx.response);
+            ctx.result = await parseEngine.request();
+            for (const middleware of ctx.policy.middlewares.after) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx);
                 }
-            });
-            await handleInterceptor("onError", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    ctx.flag.overwritten = true;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
-                    });
-                    throw error;
-                },
-                restart: () => {
-                    addTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "restart",
-                        args: []
-                    });
-                    ctx.flag.restarted = true;
+                else {
+                    ctx = await middleware.func(ctx, { throwError, setResult: (r) => { ctx.result = r; } });
                 }
-            }));
-            if (ctx.flag.restarted) {
-                return await this.request(stats, ctx.timeline);
-            }
-            if (ctx.flag.overwritten)
-                return ctx.result;
-            if (stats.settings.default !== VigorDefault)
-                return stats.settings.default;
-            throw error;
-        }
-    }
-}
-class VigorAllSettings extends VigorStatus {
-    constructor(config) {
-        const base = {
-            concurrency: 5,
-            onlySuccess: false
-        };
-        super(config, base, (c) => new VigorAllSettings(c));
-    }
-    concurrency(num) { return this._next({ concurrency: num }); }
-    onlySuccess(num) { return this._next({ onlySuccess: num }); }
-}
-class VigorAllInterceptors extends VigorStatus {
-    constructor(config) {
-        const base = {
-            before: [],
-            after: [],
-            result: [],
-            onError: []
-        };
-        super(config, base, (c) => new VigorAllInterceptors(c));
-    }
-    before(...funcs) { return this._next({ before: funcs.flat() }); }
-    after(...funcs) { return this._next({ after: funcs.flat() }); }
-    result(...funcs) { return this._next({ result: funcs.flat() }); }
-    onError(...funcs) { return this._next({ onError: funcs.flat() }); }
-}
-class VigorAll extends VigorStatus {
-    constructor(config) {
-        const base = {
-            target: [],
-            settings: new VigorAllSettings()._getBase(),
-            interceptors: new VigorAllInterceptors()._getBase()
-        };
-        super(config, base, (c) => new VigorAll(c));
-    }
-    _createTimelineHandler(timeline) {
-        return (action, content) => {
-            timeline.push({
-                action: action,
-                content: content,
-                time: Date.now()
-            });
-        };
-    }
-    _createInterceptorHandler(ctx, addTimeline) {
-        return async (interceptorType, api) => {
-            const interceptorsConfig = ctx["stats"]["interceptors"];
-            const interceptors = interceptorsConfig[interceptorType];
-            addTimeline("INTERCEPTOR_LOOP_STARTED", {
-                interceptorType: interceptorType,
-                interceptors,
-            });
-            const startTime = performance.now();
-            for (const func of interceptors) {
-                const scopedApi = api(interceptorType, func);
-                await func(ctx, scopedApi);
-            }
-            const endTime = performance.now();
-            addTimeline("INTERCEPTOR_LOOP_ENDED", {
-                interceptorType: interceptorType,
-                interceptors,
-                took: endTime - startTime
-            });
-        };
-    }
-    _createEachTimelineHandler(timeline) {
-        return (action, content) => {
-            timeline.push({
-                action: action,
-                content: content,
-                time: Date.now()
-            });
-        };
-    }
-    _createEachInterceptorHandler(ctx, addEachTimeline) {
-        return async (interceptorType, api) => {
-            const interceptorsConfig = ctx["stats"]["interceptors"];
-            const interceptors = interceptorsConfig[interceptorType];
-            addEachTimeline("INTERCEPTOR_LOOP_STARTED", {
-                interceptorType: interceptorType,
-                interceptors,
-            });
-            const startTime = performance.now();
-            for (const func of interceptors) {
-                const scopedApi = api(interceptorType, func);
-                await func(ctx, scopedApi);
-            }
-            const endTime = performance.now();
-            addEachTimeline("INTERCEPTOR_LOOP_ENDED", {
-                interceptorType: interceptorType,
-                interceptors,
-                took: endTime - startTime
-            });
-        };
-    }
-    target(...funcs) { return this._next({ target: funcs.flat() }); }
-    settings(func) {
-        if (func instanceof VigorAllSettings) {
-            return this._next({ settings: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ settings: func(new VigorAllSettings(this._config.settings))._getConfig() });
-        }
-        return this._next({ settings: func });
-    }
-    interceptors(func) {
-        if (func instanceof VigorAllInterceptors) {
-            return this._next({ interceptors: func._getConfig() });
-        }
-        if (typeof func === 'function') {
-            return this._next({ interceptors: func(new VigorAllInterceptors(this._config.interceptors))._getConfig() });
-        }
-        return this._next({ interceptors: func });
-    }
-    async runTask(task, { stats, root }, semaphore) {
-        let ctx = {
-            result: VigorDefault,
-            error: VigorDefault,
-            timeline: [],
-            stats,
-            root,
-            target: task,
-            semaphore,
-            flag: {
-                overwritten: false
-            }
-        };
-        const addEachTimeline = this._createEachTimelineHandler(ctx.timeline);
-        const handleEachInterceptor = this._createEachInterceptorHandler(ctx, addEachTimeline);
-        addEachTimeline("PROCESS_HANDLING", {
-            type: "TASK_START",
-            data: {}
-        });
-        try {
-            try {
-                await semaphore.acquire();
-                addEachTimeline("TASK_ACQUIRED", {
-                    target: ctx.target
-                });
-                await handleEachInterceptor("before", (interceptorType, func) => ({
-                    throwError: (error) => {
-                        addEachTimeline("INTERCEPTOR_API_CALLED", {
-                            interceptorType,
-                            interceptor: func,
-                            method: "throwError",
-                            args: [error]
-                        });
-                        throw error;
-                    }
-                }));
-                addEachTimeline("TASK_STARTED", {
-                    target: ctx.target
-                });
-                const startTime = performance.now();
-                ctx.result = await ctx.target(ctx);
-                const endTime = performance.now();
-                addEachTimeline("TASK_ENDED", {
-                    target: ctx.target,
-                    took: endTime - startTime
-                });
-                await handleEachInterceptor("after", (interceptorType, func) => ({
-                    setResult: (unknown) => {
-                        addEachTimeline("INTERCEPTOR_API_CALLED", {
-                            interceptorType,
-                            interceptor: func,
-                            method: "setResult",
-                            args: [unknown]
-                        });
-                        ctx.result = unknown;
-                        return unknown;
-                    },
-                    throwError: (error) => {
-                        addEachTimeline("INTERCEPTOR_API_CALLED", {
-                            interceptorType,
-                            interceptor: func,
-                            method: "throwError",
-                            args: [error]
-                        });
-                        throw error;
-                    }
-                }));
             }
-            finally {
-                semaphore.release();
-                addEachTimeline("TASK_RELEASED", {
-                    target: ctx.target
-                });
+            const setResult = (r) => { ctx.result = r; };
+            for (const middleware of ctx.policy.middlewares.onResult) {
+                if (middleware._mode === "fluent") {
+                    ctx.result = await middleware.func(ctx.result);
+                }
+                else {
+                    ctx = await middleware.func(ctx, { setResult, throwError });
+                }
             }
+            return {
+                success: true,
+                data: ctx.result,
+                error: null
+            };
         }
         catch (error) {
             ctx.error = error;
-            addEachTimeline("PROCESS_HANDLING", {
-                type: "TASK_ERROR",
-                data: {
-                    error
+            ctx.flags.overrided = false;
+            ctx.flags.restarted = false;
+            const setResult = (r) => {
+                ctx.flags.overrided = true;
+                ctx.result = r;
+            };
+            const proceedRestart = () => ctx.flags.restarted = true;
+            const cancelRestart = () => ctx.flags.restarted = false;
+            for (const middleware of ctx.policy.middlewares.onError) {
+                if (middleware._mode === "fluent") {
+                    await middleware.func(ctx.error);
                 }
-            });
-            await handleEachInterceptor("onError", (interceptorType, func) => ({
-                setResult: (unknown) => {
-                    addEachTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "setResult",
-                        args: [unknown]
-                    });
-                    ctx.result = unknown;
-                    ctx.flag.overwritten = true;
-                    return unknown;
-                },
-                throwError: (error) => {
-                    addEachTimeline("INTERCEPTOR_API_CALLED", {
-                        interceptorType,
-                        interceptor: func,
-                        method: "throwError",
-                        args: [error]
+                else {
+                    ctx = await middleware.func(ctx, { setResult, throwError, proceedRestart, cancelRestart });
+                }
+            }
+            if (ctx.flags.restarted) {
+                if (restartAttempt + 1 > ctx.policy.settings.maxRestarts)
+                    throw new VigorFetchError("RESTART_EXHAUSTED", {
+                        method: "request",
+                        data: {
+                            maxAttempts: ctx.policy.settings.maxRestarts
+                        }
                     });
-                    throw error;
-                },
-            }));
-            if (ctx.flag.overwritten)
-                return ctx.result;
-            throw error;
-        }
-        return ctx.result;
-    }
-    async request(config, timeline = []) {
-        const stats = this._mergeConfig(this._config, config);
-        let ctx = {
-            result: VigorDefault,
-            timeline,
-            stats,
-            queue: new Set(),
-            active: 0
-        };
-        const addTimeline = this._createTimelineHandler(ctx.timeline);
-        const handleInterceptor = this._createInterceptorHandler(ctx, addTimeline);
-        addTimeline("PROCESS_HANDLING", {
-            type: "REQUEST_START",
-            data: {}
-        });
-        if (stats.target.length === 0)
-            throw new VigorAllError("EMPTY_TARGET", {
-                method: "request",
-                data: {}
-            });
-        const waitQueue = [];
-        const acquire = () => {
-            if (ctx.active < stats.settings.concurrency) {
-                ctx.active++;
-                return Promise.resolve();
+                return await this.requestRuntime(restartAttempt + 1);
             }
-            return new Promise((res) => waitQueue.push(() => { ctx.active++; res(); }));
-        };
-        const release = () => {
-            ctx.active--;
-            if (waitQueue.length > 0) {
-                const next = waitQueue.shift();
-                if (next)
-                    next();
+            if (ctx.flags.overrided)
+                return {
+                    success: true,
+                    data: ctx.result,
+                    error: null
+                };
+            if (!isVigorEmpty(ctx.policy.settings.default)) {
+                const data = await ctx.policy.settings.default(ctx);
+                return {
+                    success: true,
+                    data,
+                    error: null
+                };
             }
-        };
-        for (const task of stats.target) {
-            let promise;
-            promise = this.runTask(task, { stats, root: ctx }, { acquire, release })
-                .then(res => ({ success: true, value: res }))
-                .catch(err => ({ success: false, value: err }))
-                .finally(() => ctx.queue.delete(promise));
-            ctx.queue.add(promise);
+            return {
+                success: false,
+                data: null,
+                error
+            };
         }
-        addTimeline("QUEUE_REQUEST_STARTED", {
-            queue: ctx.queue
-        });
-        const startTime = performance.now();
-        const raw = await Promise.all(ctx.queue);
-        const endTime = performance.now();
-        addTimeline("QUEUE_REQUEST_ENDED", {
-            queue: ctx.queue,
-            took: endTime - startTime
-        });
-        ctx.result = stats.settings.onlySuccess
-            ? raw.filter(r => r.success).map(r => r.value)
-            : raw.map(r => r.value);
-        await handleInterceptor("result", (interceptorType, func) => ({
-            setResult: (unknown) => {
-                addTimeline("INTERCEPTOR_API_CALLED", {
-                    interceptorType,
-                    interceptor: func,
-                    method: "setResult",
-                    args: [unknown]
-                });
-                ctx.result = unknown;
-                return unknown;
-            },
-            throwError: (error) => {
-                addTimeline("INTERCEPTOR_API_CALLED", {
-                    interceptorType,
-                    interceptor: func,
-                    method: "throwError",
-                    args: [error]
-                });
-                throw error;
-            },
-        }));
-        return ctx.result;
     }
 }
-const VigorEntry = {
-    retry: {
-        main: VigorRetry,
-        settings: VigorRetrySettings,
-        interceptors: VigorRetryInterceptors,
-        error: VigorRetryError,
-        algorithms: {
-            constant: VigorRetryAlgorithmsConstant,
-            linear: VigorRetryAlgorithmsLinear,
-            backoff: VigorRetryAlgorithmsBackoff,
-            custom: VigorRetryAlgorithmsCustom
-        }
-    },
-    parse: {
-        main: VigorParse,
-        settings: VigorParseSettings,
-        interceptors: VigorParseInterceptors,
-        error: VigorParseError,
-        strategies: VigorParseStrategies
-    },
-    fetch: {
-        main: VigorFetch,
-        settings: VigorFetchSettings,
-        interceptors: VigorFetchInterceptors,
-        error: VigorFetchError,
-    },
-    all: {
-        main: VigorAll,
-        settings: VigorAllSettings,
-        interceptors: VigorAllInterceptors,
-        error: VigorAllError
-    }
-};
+
 const vigor = {
-    use: async (func, config) => {
-        return await func(VigorEntry, config);
-    },
-    fetch: (str) => {
-        return new VigorFetch().origin(str);
-    },
-    retry: (target) => {
-        return new VigorRetry().target(target);
+    use: (plugin, options) => {
+        plugin.func(vigor, options);
     },
-    parse: (response) => {
-        return new VigorParse().target(response);
-    },
-    all: (...funcs) => {
-        return new VigorAll().target(...funcs);
-    },
-    builder: {
-        fetch: {
-            settings: (c) => new VigorFetchSettings(c),
-            interceptors: (c) => new VigorFetchInterceptors(c),
-        },
-        retry: {
-            settings: (c) => new VigorRetrySettings(c),
-            interceptors: (c) => new VigorRetryInterceptors(c),
-        },
-        parse: {
-            settings: (c) => new VigorParseSettings(c),
-            interceptors: (c) => new VigorParseInterceptors(c),
-        },
-        all: {
-            settings: (c) => new VigorAllSettings(c),
-            interceptors: (c) => new VigorAllInterceptors(c),
-        }
-    }
+    retry: (task) => task ? new VigorRetry().target(task) : new VigorRetry(),
+    parse: (response) => response ? new VigorParse().target(response) : new VigorParse(),
+    fetch: (origin) => origin ? new VigorFetch().origin(origin) : new VigorFetch(),
+    all: (...tasks) => tasks.length > 0 ? new VigorAll().target(...tasks) : new VigorAll()
 };
 
+exports.VigorAll = VigorAll;
+exports.VigorAllBase = VigorAllBase;
 exports.VigorAllError = VigorAllError;
-exports.VigorEntry = VigorEntry;
+exports.VigorAllErrorMessageFuncs = VigorAllErrorMessageFuncs;
+exports.VigorAllPolicyBase = VigorAllPolicyBase;
+exports.VigorAllPolicyMiddlewares = VigorAllPolicyMiddlewares;
+exports.VigorAllPolicyMiddlewaresBase = VigorAllPolicyMiddlewaresBase;
+exports.VigorAllPolicySettings = VigorAllPolicySettings;
+exports.VigorAllPolicySettingsBase = VigorAllPolicySettingsBase;
+exports.VigorError = VigorError;
+exports.VigorFetch = VigorFetch;
+exports.VigorFetchBase = VigorFetchBase;
 exports.VigorFetchError = VigorFetchError;
+exports.VigorFetchErrorMessageFuncs = VigorFetchErrorMessageFuncs;
+exports.VigorFetchPolicyBase = VigorFetchPolicyBase;
+exports.VigorFetchPolicyMiddlewares = VigorFetchPolicyMiddlewares;
+exports.VigorFetchPolicyMiddlewaresBase = VigorFetchPolicyMiddlewaresBase;
+exports.VigorFetchPolicySettings = VigorFetchPolicySettings;
+exports.VigorFetchPolicySettingsBase = VigorFetchPolicySettingsBase;
+exports.VigorJitter = VigorJitter;
+exports.VigorParse = VigorParse;
+exports.VigorParseBase = VigorParseBase;
+exports.VigorParseContentTypeStrategy = VigorParseContentTypeStrategy;
 exports.VigorParseError = VigorParseError;
+exports.VigorParseErrorMessageFuncs = VigorParseErrorMessageFuncs;
+exports.VigorParsePolicyBase = VigorParsePolicyBase;
+exports.VigorParsePolicyMiddlewares = VigorParsePolicyMiddlewares;
+exports.VigorParsePolicyMiddlewaresBase = VigorParsePolicyMiddlewaresBase;
+exports.VigorParsePolicySettings = VigorParsePolicySettings;
+exports.VigorParsePolicySettingsBase = VigorParsePolicySettingsBase;
+exports.VigorParsePolicyStrategies = VigorParsePolicyStrategies;
+exports.VigorParsePolicyStrategiesBase = VigorParsePolicyStrategiesBase;
+exports.VigorParseSniffStrategy = VigorParseSniffStrategy;
+exports.VigorRetry = VigorRetry;
+exports.VigorRetryBase = VigorRetryBase;
 exports.VigorRetryError = VigorRetryError;
+exports.VigorRetryErrorMessageFuncs = VigorRetryErrorMessageFuncs;
+exports.VigorRetryPolicyAlgorithms = VigorRetryPolicyAlgorithms;
+exports.VigorRetryPolicyAlgorithmsBackoff = VigorRetryPolicyAlgorithmsBackoff;
+exports.VigorRetryPolicyAlgorithmsBackoffBase = VigorRetryPolicyAlgorithmsBackoffBase;
+exports.VigorRetryPolicyAlgorithmsBase = VigorRetryPolicyAlgorithmsBase;
+exports.VigorRetryPolicyAlgorithmsConstant = VigorRetryPolicyAlgorithmsConstant;
+exports.VigorRetryPolicyAlgorithmsConstantBase = VigorRetryPolicyAlgorithmsConstantBase;
+exports.VigorRetryPolicyAlgorithmsCustom = VigorRetryPolicyAlgorithmsCustom;
+exports.VigorRetryPolicyAlgorithmsCustomBase = VigorRetryPolicyAlgorithmsCustomBase;
+exports.VigorRetryPolicyAlgorithmsLinear = VigorRetryPolicyAlgorithmsLinear;
+exports.VigorRetryPolicyAlgorithmsLinearBase = VigorRetryPolicyAlgorithmsLinearBase;
+exports.VigorRetryPolicyBase = VigorRetryPolicyBase;
+exports.VigorRetryPolicyMiddlewares = VigorRetryPolicyMiddlewares;
+exports.VigorRetryPolicyMiddlewaresBase = VigorRetryPolicyMiddlewaresBase;
+exports.VigorRetryPolicySettings = VigorRetryPolicySettings;
+exports.VigorRetryPolicySettingsBase = VigorRetryPolicySettingsBase;
+exports.VigorStatus = VigorStatus;
 exports.default = vigor;
 exports.vigor = vigor;