@plusplusoneplusplus/coc 1.0.2 → 1.0.4

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,144 @@
+"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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,38 @@
+"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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,95 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,112 @@
+"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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,92 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,143 @@
+"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