@plusplusoneplusplus/coc 1.0.4 → 1.0.6

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/concurrency-limiter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"concurrency-limiter.d.ts","sourceRoot":"","sources":["../../src/runtime/concurrency-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,iBAAiB,IAAI,wBAAwB,EAAiB,MAAM,gBAAgB,CAAC;AAE9F;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,wBAAwB;gBAC/C,OAAO,SAAwB;CAK9C;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAQf,OAAO,CAAC,QAAQ,CAAC,cAAc;IAP3C,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAyB;IAEtC;;;OAGG;gBAC0B,cAAc,GAAE,MAAU;IAMvD;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;;;;;;OAOG;IACG,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IAqB3E;;;;;;;OAOG;IACG,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIvF;;;;;;;OAOG;IACG,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC;IAUpH;;;OAGG;IACH,OAAO,CAAC,OAAO;IAYf;;;OAGG;IACH,OAAO,CAAC,OAAO;CAUlB;AAGD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/concurrency-limiter.js

@@ -1,144 +0,0 @@
-"use strict";
-/**
- * ConcurrencyLimiter
- *
- * Controls parallel execution of async tasks with a configurable concurrency limit.
- * Prevents overwhelming APIs with too many simultaneous requests.
- *
- * This is the canonical implementation. Other modules re-export from here.
- *
- * Cross-platform compatible (Linux/Mac/Windows).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MAX_CONCURRENCY = exports.ConcurrencyLimiter = exports.CancellationError = void 0;
-const cancellation_1 = require("./cancellation");
-/**
- * Error thrown when an operation is cancelled.
- * Re-exported from runtime for backward compatibility.
- */
-class CancellationError extends cancellation_1.CancellationError {
-    constructor(message = 'Operation cancelled') {
-        super(message);
-        // Keep 'CancellationError' name for backward compatibility
-        this.name = 'CancellationError';
-    }
-}
-exports.CancellationError = CancellationError;
-/**
- * A limiter that controls the maximum number of concurrent async operations.
- * Uses a queue-based approach to manage pending tasks.
- */
-class ConcurrencyLimiter {
-    /**
-     * Creates a new ConcurrencyLimiter
-     * @param maxConcurrency Maximum number of concurrent operations (default: 5)
-     */
-    constructor(maxConcurrency = 5) {
-        this.maxConcurrency = maxConcurrency;
-        this.running = 0;
-        this.queue = [];
-        if (maxConcurrency < 1) {
-            throw new Error('maxConcurrency must be at least 1');
-        }
-    }
-    /**
-     * Get the current number of running tasks
-     */
-    get runningCount() {
-        return this.running;
-    }
-    /**
-     * Get the current number of queued tasks
-     */
-    get queuedCount() {
-        return this.queue.length;
-    }
-    /**
-     * Get the maximum concurrency limit
-     */
-    get limit() {
-        return this.maxConcurrency;
-    }
-    /**
-     * Execute a single async function with concurrency limiting.
-     * If the limit is reached, the function will be queued until a slot is available.
-     *
-     * @param fn The async function to execute
-     * @param isCancelled Optional function to check if operation should be cancelled
-     * @returns Promise that resolves with the function's result
-     */
-    async run(fn, isCancelled) {
-        // Check for cancellation before acquiring slot
-        if (isCancelled?.()) {
-            throw new CancellationError();
-        }
-        await this.acquire();
-        // Check for cancellation after acquiring slot but before executing
-        if (isCancelled?.()) {
-            this.release();
-            throw new CancellationError();
-        }
-        try {
-            return await fn();
-        }
-        finally {
-            this.release();
-        }
-    }
-    /**
-     * Execute multiple async tasks with concurrency limiting.
-     * Similar to Promise.all but respects the maxConcurrency limit.
-     *
-     * @param tasks Array of functions that return promises
-     * @param isCancelled Optional function to check if operation should be cancelled
-     * @returns Promise that resolves with array of results (in same order as input)
-     */
-    async all(tasks, isCancelled) {
-        return Promise.all(tasks.map(task => this.run(task, isCancelled)));
-    }
-    /**
-     * Execute multiple async tasks with concurrency limiting, settling all promises.
-     * Similar to Promise.allSettled but respects the maxConcurrency limit.
-     *
-     * @param tasks Array of functions that return promises
-     * @param isCancelled Optional function to check if operation should be cancelled
-     * @returns Promise that resolves with array of settled results
-     */
-    async allSettled(tasks, isCancelled) {
-        return Promise.all(tasks.map(task => this.run(task, isCancelled)
-            .then(value => ({ status: 'fulfilled', value }))
-            .catch(reason => ({ status: 'rejected', reason }))));
-    }
-    /**
-     * Acquire a slot for execution.
-     * If maxConcurrency is reached, this will wait until a slot is available.
-     */
-    acquire() {
-        if (this.running < this.maxConcurrency) {
-            this.running++;
-            return Promise.resolve();
-        }
-        // Queue the request and wait for a slot
-        return new Promise(resolve => {
-            this.queue.push(resolve);
-        });
-    }
-    /**
-     * Release a slot after execution completes.
-     * If there are queued tasks, the next one will be started.
-     */
-    release() {
-        this.running--;
-        // Start next queued task if any
-        const next = this.queue.shift();
-        if (next) {
-            this.running++;
-            next();
-        }
-    }
-}
-exports.ConcurrencyLimiter = ConcurrencyLimiter;
-// Re-export for backward compatibility
-var defaults_1 = require("../config/defaults");
-Object.defineProperty(exports, "DEFAULT_MAX_CONCURRENCY", { enumerable: true, get: function () { return defaults_1.DEFAULT_MAX_CONCURRENCY; } });
-//# sourceMappingURL=concurrency-limiter.js.map

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/concurrency-limiter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"concurrency-limiter.js","sourceRoot":"","sources":["../../src/runtime/concurrency-limiter.ts"],"names":[],"mappings":"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"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Runtime Module - Public API
- *
- * Exports centralized async policy utilities for timeout, retry, cancellation, and concurrency.
- */
-export { CancellationError, IsCancelledFn, isCancellationError, throwIfCancelled, createCancellationToken, } from './cancellation';
-export { ConcurrencyLimiter } from './concurrency-limiter';
-export { TimeoutError, TimeoutOptions, withTimeout, isTimeoutError, createTimeoutPromise, } from './timeout';
-export { RetryExhaustedError, BackoffStrategy, OnAttemptFn, RetryOnFn, RetryOptions, DEFAULT_RETRY_OPTIONS, defaultRetryOn, retryOnTimeout, calculateDelay, withRetry, isRetryExhaustedError, } from './retry';
-export { PolicyOptions, DEFAULT_POLICY_OPTIONS, runWithPolicy, createPolicyRunner, } from './policy';
-//# sourceMappingURL=index.d.ts.map

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACH,iBAAiB,EACjB,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAChB,uBAAuB,GAC1B,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAG3D,OAAO,EACH,YAAY,EACZ,cAAc,EACd,WAAW,EACX,cAAc,EACd,oBAAoB,GACvB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACH,mBAAmB,EACnB,eAAe,EACf,WAAW,EACX,SAAS,EACT,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,cAAc,EACd,cAAc,EACd,SAAS,EACT,qBAAqB,GACxB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACH,aAAa,EACb,sBAAsB,EACtB,aAAa,EACb,kBAAkB,GACrB,MAAM,UAAU,CAAC"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/index.js

@@ -1,38 +0,0 @@
-"use strict";
-/**
- * Runtime Module - Public API
- *
- * Exports centralized async policy utilities for timeout, retry, cancellation, and concurrency.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPolicyRunner = exports.runWithPolicy = exports.DEFAULT_POLICY_OPTIONS = exports.isRetryExhaustedError = exports.withRetry = exports.calculateDelay = exports.retryOnTimeout = exports.defaultRetryOn = exports.DEFAULT_RETRY_OPTIONS = exports.RetryExhaustedError = exports.createTimeoutPromise = exports.isTimeoutError = exports.withTimeout = exports.TimeoutError = exports.ConcurrencyLimiter = exports.createCancellationToken = exports.throwIfCancelled = exports.isCancellationError = exports.CancellationError = void 0;
-// Cancellation
-var cancellation_1 = require("./cancellation");
-Object.defineProperty(exports, "CancellationError", { enumerable: true, get: function () { return cancellation_1.CancellationError; } });
-Object.defineProperty(exports, "isCancellationError", { enumerable: true, get: function () { return cancellation_1.isCancellationError; } });
-Object.defineProperty(exports, "throwIfCancelled", { enumerable: true, get: function () { return cancellation_1.throwIfCancelled; } });
-Object.defineProperty(exports, "createCancellationToken", { enumerable: true, get: function () { return cancellation_1.createCancellationToken; } });
-// Concurrency limiter (canonical location)
-var concurrency_limiter_1 = require("./concurrency-limiter");
-Object.defineProperty(exports, "ConcurrencyLimiter", { enumerable: true, get: function () { return concurrency_limiter_1.ConcurrencyLimiter; } });
-// Timeout
-var timeout_1 = require("./timeout");
-Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return timeout_1.TimeoutError; } });
-Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return timeout_1.withTimeout; } });
-Object.defineProperty(exports, "isTimeoutError", { enumerable: true, get: function () { return timeout_1.isTimeoutError; } });
-Object.defineProperty(exports, "createTimeoutPromise", { enumerable: true, get: function () { return timeout_1.createTimeoutPromise; } });
-// Retry
-var retry_1 = require("./retry");
-Object.defineProperty(exports, "RetryExhaustedError", { enumerable: true, get: function () { return retry_1.RetryExhaustedError; } });
-Object.defineProperty(exports, "DEFAULT_RETRY_OPTIONS", { enumerable: true, get: function () { return retry_1.DEFAULT_RETRY_OPTIONS; } });
-Object.defineProperty(exports, "defaultRetryOn", { enumerable: true, get: function () { return retry_1.defaultRetryOn; } });
-Object.defineProperty(exports, "retryOnTimeout", { enumerable: true, get: function () { return retry_1.retryOnTimeout; } });
-Object.defineProperty(exports, "calculateDelay", { enumerable: true, get: function () { return retry_1.calculateDelay; } });
-Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return retry_1.withRetry; } });
-Object.defineProperty(exports, "isRetryExhaustedError", { enumerable: true, get: function () { return retry_1.isRetryExhaustedError; } });
-// Policy (unified runner)
-var policy_1 = require("./policy");
-Object.defineProperty(exports, "DEFAULT_POLICY_OPTIONS", { enumerable: true, get: function () { return policy_1.DEFAULT_POLICY_OPTIONS; } });
-Object.defineProperty(exports, "runWithPolicy", { enumerable: true, get: function () { return policy_1.runWithPolicy; } });
-Object.defineProperty(exports, "createPolicyRunner", { enumerable: true, get: function () { return policy_1.createPolicyRunner; } });
-//# sourceMappingURL=index.js.map

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,eAAe;AACf,+CAMwB;AALpB,iHAAA,iBAAiB,OAAA;AAEjB,mHAAA,mBAAmB,OAAA;AACnB,gHAAA,gBAAgB,OAAA;AAChB,uHAAA,uBAAuB,OAAA;AAG3B,2CAA2C;AAC3C,6DAA2D;AAAlD,yHAAA,kBAAkB,OAAA;AAE3B,UAAU;AACV,qCAMmB;AALf,uGAAA,YAAY,OAAA;AAEZ,sGAAA,WAAW,OAAA;AACX,yGAAA,cAAc,OAAA;AACd,+GAAA,oBAAoB,OAAA;AAGxB,QAAQ;AACR,iCAYiB;AAXb,4GAAA,mBAAmB,OAAA;AAKnB,8GAAA,qBAAqB,OAAA;AACrB,uGAAA,cAAc,OAAA;AACd,uGAAA,cAAc,OAAA;AACd,uGAAA,cAAc,OAAA;AACd,kGAAA,SAAS,OAAA;AACT,8GAAA,qBAAqB,OAAA;AAGzB,0BAA0B;AAC1B,mCAKkB;AAHd,gHAAA,sBAAsB,OAAA;AACtB,uGAAA,aAAa,OAAA;AACb,4GAAA,kBAAkB,OAAA"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/policy.d.ts

@@ -1,95 +0,0 @@
-/**
- * Policy Runner
- *
- * Composes timeout, retry, and cancellation into a single unified policy.
- * This is the top-level API for running operations with cross-cutting concerns.
- */
-import { ErrorMetadata } from '../errors';
-import { IsCancelledFn } from './cancellation';
-import { BackoffStrategy } from './retry';
-/**
- * Unified policy options combining timeout, retry, and cancellation
- */
-export interface PolicyOptions {
-    /** Timeout in milliseconds for each attempt (not total). Optional. */
-    timeoutMs?: number;
-    /** Whether to retry on failure. Default: false */
-    retryOnFailure?: boolean;
-    /** Number of retry attempts (including initial). Default: 3 when retryOnFailure is true */
-    retryAttempts?: number;
-    /** Base delay between retries in milliseconds. Default: 1000 */
-    retryDelayMs?: number;
-    /** Backoff strategy. Default: 'exponential' */
-    backoff?: BackoffStrategy;
-    /** Maximum delay between retries. Default: 30000 */
-    maxRetryDelayMs?: number;
-    /** Function to check if operation should be cancelled */
-    isCancelled?: IsCancelledFn;
-    /** Operation name for error messages */
-    operationName?: string;
-    /** Additional metadata for errors */
-    meta?: ErrorMetadata;
-}
-/** Default policy options */
-export declare const DEFAULT_POLICY_OPTIONS: Partial<PolicyOptions>;
-/**
- * Run an async function with a unified policy for timeout, retry, and cancellation.
- *
- * The policy applies in this order:
- * 1. Check for cancellation before starting
- * 2. If retry is enabled, wrap with retry logic
- * 3. For each attempt, if timeout is specified, wrap with timeout
- *
- * @param fn The async function to execute
- * @param options Policy configuration
- * @returns Promise resolving to the function's result
- *
- * @example
- * ```typescript
- * // Simple timeout
- * const result = await runWithPolicy(
- *     () => fetchData(),
- *     { timeoutMs: 5000 }
- * );
- *
- * // Timeout with retry
- * const result = await runWithPolicy(
- *     () => fetchData(),
- *     {
- *         timeoutMs: 5000,
- *         retryOnFailure: true,
- *         retryAttempts: 3,
- *         backoff: 'exponential'
- *     }
- * );
- *
- * // With cancellation
- * const result = await runWithPolicy(
- *     () => fetchData(),
- *     {
- *         timeoutMs: 5000,
- *         isCancelled: () => shouldCancel
- *     }
- * );
- * ```
- */
-export declare function runWithPolicy<T>(fn: () => Promise<T>, options?: PolicyOptions): Promise<T>;
-/**
- * Create a policy runner with pre-configured defaults.
- * Useful for creating consistent policies across a module.
- *
- * @example
- * ```typescript
- * const aiPolicy = createPolicyRunner({
- *     timeoutMs: 30000,
- *     retryOnFailure: true,
- *     retryAttempts: 2,
- *     operationName: 'AI Invocation'
- * });
- *
- * // Later use:
- * const result = await aiPolicy(() => invokeAI(prompt));
- * ```
- */
-export declare function createPolicyRunner(defaultOptions: PolicyOptions): <T>(fn: () => Promise<T>, overrides?: Partial<PolicyOptions>) => Promise<T>;
-//# sourceMappingURL=policy.d.ts.map

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/policy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/runtime/policy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAoB,MAAM,gBAAgB,CAAC;AAEjE,OAAO,EAA2B,eAAe,EAAE,MAAM,SAAS,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,aAAa;IAI1B,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IAKnB,kDAAkD;IAClD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,2FAA2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,oDAAoD;IACpD,eAAe,CAAC,EAAE,MAAM,CAAC;IAKzB,yDAAyD;IACzD,WAAW,CAAC,EAAE,aAAa,CAAC;IAK5B,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,IAAI,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,6BAA6B;AAC7B,eAAO,MAAM,sBAAsB,EAAE,OAAO,CAAC,aAAa,CAMzD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACjC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,aAAa,GACxB,OAAO,CAAC,CAAC,CAAC,CA0CZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAC9B,cAAc,EAAE,aAAa,GAC9B,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAG7E"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/policy.js

@@ -1,112 +0,0 @@
-"use strict";
-/**
- * Policy Runner
- *
- * Composes timeout, retry, and cancellation into a single unified policy.
- * This is the top-level API for running operations with cross-cutting concerns.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_POLICY_OPTIONS = void 0;
-exports.runWithPolicy = runWithPolicy;
-exports.createPolicyRunner = createPolicyRunner;
-const cancellation_1 = require("./cancellation");
-const timeout_1 = require("./timeout");
-const retry_1 = require("./retry");
-/** Default policy options */
-exports.DEFAULT_POLICY_OPTIONS = {
-    retryOnFailure: false,
-    retryAttempts: 3,
-    retryDelayMs: 1000,
-    backoff: 'exponential',
-    maxRetryDelayMs: 30000,
-};
-/**
- * Run an async function with a unified policy for timeout, retry, and cancellation.
- *
- * The policy applies in this order:
- * 1. Check for cancellation before starting
- * 2. If retry is enabled, wrap with retry logic
- * 3. For each attempt, if timeout is specified, wrap with timeout
- *
- * @param fn The async function to execute
- * @param options Policy configuration
- * @returns Promise resolving to the function's result
- *
- * @example
- * ```typescript
- * // Simple timeout
- * const result = await runWithPolicy(
- *     () => fetchData(),
- *     { timeoutMs: 5000 }
- * );
- *
- * // Timeout with retry
- * const result = await runWithPolicy(
- *     () => fetchData(),
- *     {
- *         timeoutMs: 5000,
- *         retryOnFailure: true,
- *         retryAttempts: 3,
- *         backoff: 'exponential'
- *     }
- * );
- *
- * // With cancellation
- * const result = await runWithPolicy(
- *     () => fetchData(),
- *     {
- *         timeoutMs: 5000,
- *         isCancelled: () => shouldCancel
- *     }
- * );
- * ```
- */
-async function runWithPolicy(fn, options) {
-    const { timeoutMs, retryOnFailure = false, retryAttempts = 3, retryDelayMs = 1000, backoff = 'exponential', maxRetryDelayMs = 30000, isCancelled, operationName, meta, } = options ?? {};
-    // Check for immediate cancellation
-    (0, cancellation_1.throwIfCancelled)(isCancelled, meta);
-    // Build the execution function with timeout if specified
-    const executeWithTimeout = timeoutMs
-        ? () => (0, timeout_1.withTimeout)(fn, {
-            timeoutMs,
-            isCancelled,
-            operationName,
-            meta,
-        })
-        : fn;
-    // If retry is enabled, wrap with retry
-    if (retryOnFailure) {
-        return (0, retry_1.withRetry)(executeWithTimeout, {
-            attempts: retryAttempts,
-            delayMs: retryDelayMs,
-            backoff,
-            maxDelayMs: maxRetryDelayMs,
-            isCancelled,
-            operationName,
-            meta,
-        });
-    }
-    // Just execute (possibly with timeout)
-    return executeWithTimeout();
-}
-/**
- * Create a policy runner with pre-configured defaults.
- * Useful for creating consistent policies across a module.
- *
- * @example
- * ```typescript
- * const aiPolicy = createPolicyRunner({
- *     timeoutMs: 30000,
- *     retryOnFailure: true,
- *     retryAttempts: 2,
- *     operationName: 'AI Invocation'
- * });
- *
- * // Later use:
- * const result = await aiPolicy(() => invokeAI(prompt));
- * ```
- */
-function createPolicyRunner(defaultOptions) {
-    return (fn, overrides) => runWithPolicy(fn, { ...defaultOptions, ...overrides });
-}
-//# sourceMappingURL=policy.js.map

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/policy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../src/runtime/policy.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAgGH,sCA6CC;AAmBD,gDAKC;AAlKD,iDAAiE;AACjE,uCAAwD;AACxD,mCAAmE;AAyCnE,6BAA6B;AAChB,QAAA,sBAAsB,GAA2B;IAC1D,cAAc,EAAE,KAAK;IACrB,aAAa,EAAE,CAAC;IAChB,YAAY,EAAE,IAAI;IAClB,OAAO,EAAE,aAAa;IACtB,eAAe,EAAE,KAAK;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACI,KAAK,UAAU,aAAa,CAC/B,EAAoB,EACpB,OAAuB;IAEvB,MAAM,EACF,SAAS,EACT,cAAc,GAAG,KAAK,EACtB,aAAa,GAAG,CAAC,EACjB,YAAY,GAAG,IAAI,EACnB,OAAO,GAAG,aAAa,EACvB,eAAe,GAAG,KAAK,EACvB,WAAW,EACX,aAAa,EACb,IAAI,GACP,GAAG,OAAO,IAAI,EAAE,CAAC;IAElB,mCAAmC;IACnC,IAAA,+BAAgB,EAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IAEpC,yDAAyD;IACzD,MAAM,kBAAkB,GAAG,SAAS;QAChC,CAAC,CAAC,GAAG,EAAE,CACH,IAAA,qBAAW,EAAC,EAAE,EAAE;YACZ,SAAS;YACT,WAAW;YACX,aAAa;YACb,IAAI;SACW,CAAC;QACxB,CAAC,CAAC,EAAE,CAAC;IAET,uCAAuC;IACvC,IAAI,cAAc,EAAE,CAAC;QACjB,OAAO,IAAA,iBAAS,EAAC,kBAAkB,EAAE;YACjC,QAAQ,EAAE,aAAa;YACvB,OAAO,EAAE,YAAY;YACrB,OAAO;YACP,UAAU,EAAE,eAAe;YAC3B,WAAW;YACX,aAAa;YACb,IAAI;SACS,CAAC,CAAC;IACvB,CAAC;IAED,uCAAuC;IACvC,OAAO,kBAAkB,EAAE,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,kBAAkB,CAC9B,cAA6B;IAE7B,OAAO,CAAI,EAAoB,EAAE,SAAkC,EAAE,EAAE,CACnE,aAAa,CAAC,EAAE,EAAE,EAAE,GAAG,cAAc,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;AAC/D,CAAC"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/retry.d.ts

@@ -1,92 +0,0 @@
-/**
- * Retry Utilities
- *
- * Provides a standard way to retry async operations with configurable backoff.
- * Produces structured PipelineCoreError with RETRY_EXHAUSTED code.
- */
-import { PipelineCoreError, ErrorMetadata } from '../errors';
-import { IsCancelledFn } from './cancellation';
-/**
- * Error thrown when all retry attempts have been exhausted.
- */
-export declare class RetryExhaustedError extends PipelineCoreError {
-    constructor(message: string, cause?: unknown, meta?: ErrorMetadata);
-}
-/**
- * Backoff strategy type
- */
-export type BackoffStrategy = 'fixed' | 'exponential' | 'linear';
-/**
- * Function called before each retry attempt
- */
-export type OnAttemptFn = (attempt: number, maxAttempts: number, lastError?: unknown) => void;
-/**
- * Function to determine if an error should trigger a retry
- */
-export type RetryOnFn = (error: unknown, attempt: number) => boolean;
-/**
- * Options for withRetry
- */
-export interface RetryOptions {
-    /** Maximum number of attempts (including initial attempt). Default: 3 */
-    attempts?: number;
-    /** Base delay between retries in milliseconds. Default: 1000 */
-    delayMs?: number;
-    /** Backoff strategy. Default: 'exponential' */
-    backoff?: BackoffStrategy;
-    /** Maximum delay between retries (caps exponential/linear growth). Default: 30000 */
-    maxDelayMs?: number;
-    /** Function to determine if error should trigger retry. Default: retry all except cancellation */
-    retryOn?: RetryOnFn;
-    /** Callback before each attempt */
-    onAttempt?: OnAttemptFn;
-    /** Optional cancellation check function */
-    isCancelled?: IsCancelledFn;
-    /** Optional operation name for error messages */
-    operationName?: string;
-    /** Additional metadata for errors */
-    meta?: ErrorMetadata;
-}
-/** Default retry options */
-export declare const DEFAULT_RETRY_OPTIONS: Required<Omit<RetryOptions, 'retryOn' | 'onAttempt' | 'isCancelled' | 'operationName' | 'meta'>>;
-/**
- * Default retry predicate - retry everything except cancellation errors
- */
-export declare const defaultRetryOn: RetryOnFn;
-/**
- * Retry predicate that also retries on timeout
- */
-export declare const retryOnTimeout: RetryOnFn;
-/**
- * Calculate delay for a given attempt based on backoff strategy
- */
-export declare function calculateDelay(attempt: number, baseDelayMs: number, backoff: BackoffStrategy, maxDelayMs: number): number;
-/**
- * Execute an async function with retries.
- *
- * @param fn The async function to execute
- * @param options Retry configuration
- * @returns Promise resolving to the function's result
- * @throws RetryExhaustedError if all attempts fail
- * @throws CancellationError if cancelled
- * @throws Original error if retryOn returns false
- *
- * @example
- * ```typescript
- * const result = await withRetry(
- *     () => fetchData(),
- *     {
- *         attempts: 3,
- *         delayMs: 1000,
- *         backoff: 'exponential',
- *         onAttempt: (attempt) => console.log(`Attempt ${attempt}`)
- *     }
- * );
- * ```
- */
-export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-/**
- * Check if an error is a retry exhausted error
- */
-export declare function isRetryExhaustedError(error: unknown): error is RetryExhaustedError;
-//# sourceMappingURL=retry.d.ts.map

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/retry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/runtime/retry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAa,aAAa,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EAAE,aAAa,EAAyC,MAAM,gBAAgB,CAAC;AAGtF;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,iBAAiB;gBAElD,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,EACf,IAAI,CAAC,EAAE,aAAa;CAS3B;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;AAE9F;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kGAAkG;IAClG,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,mCAAmC;IACnC,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,aAAa,CAAC;IAC5B,iDAAiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,IAAI,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,4BAA4B;AAC5B,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,WAAW,GAAG,aAAa,GAAG,eAAe,GAAG,MAAM,CAAC,CAKlI,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,SAE5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,SAE5B,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAC1B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,GACnB,MAAM,CAiBR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC7B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,YAAY,GACvB,OAAO,CAAC,CAAC,CAAC,CAmDZ;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAQlF"}

package/node_modules/@plusplusoneplusplus/forge/dist/runtime/retry.js

@@ -1,143 +0,0 @@
-"use strict";
-/**
- * Retry Utilities
- *
- * Provides a standard way to retry async operations with configurable backoff.
- * Produces structured PipelineCoreError with RETRY_EXHAUSTED code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryOnTimeout = exports.defaultRetryOn = exports.DEFAULT_RETRY_OPTIONS = exports.RetryExhaustedError = void 0;
-exports.calculateDelay = calculateDelay;
-exports.withRetry = withRetry;
-exports.isRetryExhaustedError = isRetryExhaustedError;
-const errors_1 = require("../errors");
-const cancellation_1 = require("./cancellation");
-const timeout_1 = require("./timeout");
-/**
- * Error thrown when all retry attempts have been exhausted.
- */
-class RetryExhaustedError extends errors_1.PipelineCoreError {
-    constructor(message, cause, meta) {
-        super(message, {
-            code: errors_1.ErrorCode.RETRY_EXHAUSTED,
-            cause,
-            meta,
-        });
-        this.name = 'RetryExhaustedError';
-    }
-}
-exports.RetryExhaustedError = RetryExhaustedError;
-/** Default retry options */
-exports.DEFAULT_RETRY_OPTIONS = {
-    attempts: 3,
-    delayMs: 1000,
-    backoff: 'exponential',
-    maxDelayMs: 30000,
-};
-/**
- * Default retry predicate - retry everything except cancellation errors
- */
-const defaultRetryOn = (error) => {
-    return !(0, cancellation_1.isCancellationError)(error);
-};
-exports.defaultRetryOn = defaultRetryOn;
-/**
- * Retry predicate that also retries on timeout
- */
-const retryOnTimeout = (error) => {
-    return !(0, cancellation_1.isCancellationError)(error) && (0, timeout_1.isTimeoutError)(error);
-};
-exports.retryOnTimeout = retryOnTimeout;
-/**
- * Calculate delay for a given attempt based on backoff strategy
- */
-function calculateDelay(attempt, baseDelayMs, backoff, maxDelayMs) {
-    let delay;
-    switch (backoff) {
-        case 'fixed':
-            delay = baseDelayMs;
-            break;
-        case 'linear':
-            delay = baseDelayMs * attempt;
-            break;
-        case 'exponential':
-        default:
-            delay = baseDelayMs * Math.pow(2, attempt - 1);
-            break;
-    }
-    return Math.min(delay, maxDelayMs);
-}
-/**
- * Execute an async function with retries.
- *
- * @param fn The async function to execute
- * @param options Retry configuration
- * @returns Promise resolving to the function's result
- * @throws RetryExhaustedError if all attempts fail
- * @throws CancellationError if cancelled
- * @throws Original error if retryOn returns false
- *
- * @example
- * ```typescript
- * const result = await withRetry(
- *     () => fetchData(),
- *     {
- *         attempts: 3,
- *         delayMs: 1000,
- *         backoff: 'exponential',
- *         onAttempt: (attempt) => console.log(`Attempt ${attempt}`)
- *     }
- * );
- * ```
- */
-async function withRetry(fn, options) {
-    const { attempts = exports.DEFAULT_RETRY_OPTIONS.attempts, delayMs = exports.DEFAULT_RETRY_OPTIONS.delayMs, backoff = exports.DEFAULT_RETRY_OPTIONS.backoff, maxDelayMs = exports.DEFAULT_RETRY_OPTIONS.maxDelayMs, retryOn = exports.defaultRetryOn, onAttempt, isCancelled, operationName, meta, } = options ?? {};
-    let lastError;
-    for (let attempt = 1; attempt <= attempts; attempt++) {
-        // Check for cancellation before each attempt
-        (0, cancellation_1.throwIfCancelled)(isCancelled, { ...meta, attempt, maxAttempts: attempts });
-        // Notify about attempt
-        onAttempt?.(attempt, attempts, lastError);
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            // Check if we should retry
-            if (!retryOn(error, attempt)) {
-                throw error;
-            }
-            // Check if we have more attempts
-            if (attempt < attempts) {
-                const delay = calculateDelay(attempt, delayMs, backoff, maxDelayMs);
-                await sleep(delay);
-            }
-        }
-    }
-    // All attempts exhausted
-    const name = operationName ?? 'Operation';
-    throw new RetryExhaustedError(`${name} failed after ${attempts} attempts`, lastError, {
-        ...meta,
-        attempt: attempts,
-        maxAttempts: attempts,
-    });
-}
-/**
- * Check if an error is a retry exhausted error
- */
-function isRetryExhaustedError(error) {
-    if (error instanceof RetryExhaustedError) {
-        return true;
-    }
-    if (error instanceof errors_1.PipelineCoreError && error.code === errors_1.ErrorCode.RETRY_EXHAUSTED) {
-        return true;
-    }
-    return false;
-}
-/**
- * Sleep for a specified duration
- */
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//# sourceMappingURL=retry.js.map