@independo/inderun-web 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Independo GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @independo/inderun-web
+
+TypeScript/Web SDK for IndeRun.
+
+This package provides the Web SDK entrypoint, the engine core, routing, telemetry, error normalization, and the OpenAI-compatible cloud provider.
+
+## Basic Usage
+
+```ts
+import { createIndeRunWeb } from "@independo/inderun-web";
+
+const inderun = createIndeRunWeb({
+  openAI: {
+    model: "gpt-5.2",
+    endpointUrl: "/api/inderun/openai-responses",
+    auth: "none"
+  }
+});
+
+const result = await inderun.run({
+  schemaVersion: "1.0",
+  task: { kind: "text_to_text" },
+  prompt: "Write a one-sentence summary of IndeRun."
+});
+```
+
+## Security Model
+
+Browser apps should use a proxy endpoint and keep provider credentials server-side. `createIndeRunWeb` rejects direct calls to the public OpenAI Responses endpoint unless `allowDirectOpenAIEndpoint: true` is set for a controlled environment.
+
+## Advanced: registering the OpenAI provider directly
+
+`createIndeRunWeb` wires the OpenAI Responses provider for you. To register it
+manually (e.g. alongside other providers), import it from the provider subpath:
+
+```ts
+import { OpenAIResponsesProvider } from "@independo/inderun-web/openai";
+```
+
+The provider normalizes OpenAI transport and API failures into the IndeRun error
+taxonomy (`AuthError`, `RateLimited`, `Timeout`, `Unavailable`, `Internal`). The
+exact status-to-class mapping is documented on the provider in code — see
+`OpenAIResponsesProvider` — so it stays in sync with behavior.
+
+## Commands
+
+```sh
+pnpm --filter @independo/inderun-web build
+pnpm --filter @independo/inderun-web test
+```

package/dist/browser-host.d.ts

@@ -0,0 +1,67 @@
+import type { ClockService, ConnectivityService, HostServices, HttpClientService, HttpRequest, HttpResponse } from "./host.js";
+/**
+ * Configuration for the fetch-backed HTTP host service.
+ */
+export interface FetchHttpClientOptions {
+    /**
+     * Optional fetch implementation. Useful for tests, SSR-like environments, or custom wrappers.
+     */
+    fetchFn?: typeof fetch;
+}
+/**
+ * Browser connectivity service based on `navigator.onLine`.
+ */
+export declare class BrowserConnectivityService implements ConnectivityService {
+    /**
+     * Returns the browser's current online hint.
+     * Non-browser environments are treated as online so injected HTTP clients can still run in tests.
+     */
+    isOnline(): Promise<boolean>;
+}
+/**
+ * Clock service using wall-clock time and the browser performance timer when available.
+ */
+export declare class SystemClockService implements ClockService {
+    /**
+     * Returns current Unix epoch time in milliseconds.
+     */
+    now(): number;
+    /**
+     * Returns monotonic milliseconds from `performance.now()` when available.
+     */
+    monotonicNow(): number;
+}
+/**
+ * HTTP client service that adapts the platform `fetch` API to IndeRun's normalized HTTP contract.
+ */
+export declare class FetchHttpClient implements HttpClientService {
+    private readonly fetchFn;
+    /**
+     * Creates a fetch-backed HTTP client.
+     * @param options - Optional fetch implementation override.
+     * @throws Error when no fetch implementation is available.
+     */
+    constructor(options?: FetchHttpClientOptions);
+    /**
+     * Sends a normalized HTTP request using `fetch`.
+     * @param request - Normalized HTTP request payload.
+     * @returns Normalized HTTP response payload with lower-cased response header names.
+     */
+    send(request: HttpRequest): Promise<HttpResponse>;
+}
+/**
+ * Options for constructing default browser host services.
+ */
+export interface CreateBrowserHostServicesOptions extends Partial<HostServices> {
+    /**
+     * Optional fetch implementation used when `httpClient` is not supplied.
+     */
+    fetchFn?: typeof fetch;
+}
+/**
+ * Creates a browser-oriented HostServices bundle for the Web SDK.
+ * Supplied host services override the defaults; missing connectivity, clock, and HTTP services are created.
+ * @param options - Optional host service overrides and fetch implementation.
+ */
+export declare function createBrowserHostServices(options?: CreateBrowserHostServicesOptions): HostServices;
+//# sourceMappingURL=browser-host.d.ts.map

package/dist/browser-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-host.d.ts","sourceRoot":"","sources":["../src/browser-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACb,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED;;GAEG;AACH,qBAAa,0BAA2B,YAAW,mBAAmB;IACpE;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;CAOnC;AAED;;GAEG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD;;OAEG;IACH,GAAG,IAAI,MAAM;IAIb;;OAEG;IACH,YAAY,IAAI,MAAM;CAOvB;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;OAIG;gBACS,OAAO,GAAE,sBAA2B;IAShD;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CA0CxD;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,OAAO,CAAC,YAAY,CAAC;IAC7E;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,YAAY,CA2Bd"}

package/dist/browser-host.js

@@ -0,0 +1,125 @@
+/**
+ * Browser connectivity service based on `navigator.onLine`.
+ */
+export class BrowserConnectivityService {
+    /**
+     * Returns the browser's current online hint.
+     * Non-browser environments are treated as online so injected HTTP clients can still run in tests.
+     */
+    async isOnline() {
+        if (typeof navigator === "undefined") {
+            return true;
+        }
+        return navigator.onLine;
+    }
+}
+/**
+ * Clock service using wall-clock time and the browser performance timer when available.
+ */
+export class SystemClockService {
+    /**
+     * Returns current Unix epoch time in milliseconds.
+     */
+    now() {
+        return Date.now();
+    }
+    /**
+     * Returns monotonic milliseconds from `performance.now()` when available.
+     */
+    monotonicNow() {
+        if (typeof performance === "undefined") {
+            return Date.now();
+        }
+        return performance.now();
+    }
+}
+/**
+ * HTTP client service that adapts the platform `fetch` API to IndeRun's normalized HTTP contract.
+ */
+export class FetchHttpClient {
+    fetchFn;
+    /**
+     * Creates a fetch-backed HTTP client.
+     * @param options - Optional fetch implementation override.
+     * @throws Error when no fetch implementation is available.
+     */
+    constructor(options = {}) {
+        const fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
+        if (!fetchFn) {
+            throw new Error("FetchHttpClient requires a fetch implementation.");
+        }
+        this.fetchFn = fetchFn;
+    }
+    /**
+     * Sends a normalized HTTP request using `fetch`.
+     * @param request - Normalized HTTP request payload.
+     * @returns Normalized HTTP response payload with lower-cased response header names.
+     */
+    async send(request) {
+        const controller = typeof AbortController === "undefined" ? undefined : new AbortController();
+        let timeoutId;
+        if (controller && request.timeoutMs !== undefined) {
+            timeoutId = setTimeout(() => controller.abort(), request.timeoutMs);
+        }
+        try {
+            const init = {
+                method: request.method
+            };
+            if (request.headers) {
+                init.headers = request.headers;
+            }
+            if (request.body !== undefined) {
+                init.body = request.body;
+            }
+            if (controller) {
+                init.signal = controller.signal;
+            }
+            const response = await this.fetchFn(request.url, init);
+            const headers = {};
+            response.headers.forEach((value, key) => {
+                headers[key.toLowerCase()] = value;
+            });
+            return {
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+                body: await response.text()
+            };
+        }
+        finally {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+}
+/**
+ * Creates a browser-oriented HostServices bundle for the Web SDK.
+ * Supplied host services override the defaults; missing connectivity, clock, and HTTP services are created.
+ * @param options - Optional host service overrides and fetch implementation.
+ */
+export function createBrowserHostServices(options = {}) {
+    const hostServices = {
+        connectivity: options.connectivity ?? new BrowserConnectivityService()
+    };
+    hostServices.clock = options.clock ?? new SystemClockService();
+    if (options.httpClient) {
+        hostServices.httpClient = options.httpClient;
+    }
+    else if (options.fetchFn) {
+        hostServices.httpClient = new FetchHttpClient({ fetchFn: options.fetchFn });
+    }
+    else {
+        hostServices.httpClient = new FetchHttpClient();
+    }
+    if (options.deviceConstraints) {
+        hostServices.deviceConstraints = options.deviceConstraints;
+    }
+    if (options.secureStorage) {
+        hostServices.secureStorage = options.secureStorage;
+    }
+    if (options.telemetry) {
+        hostServices.telemetry = options.telemetry;
+    }
+    return hostServices;
+}

package/dist/engine.d.ts

@@ -0,0 +1,42 @@
+import { type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
+import type { HostServices } from "./host.js";
+import { ProviderRegistry } from "./registry.js";
+import { type TelemetryService } from "./telemetry.js";
+/**
+ * Main orchestrator SDK entrypoint class.
+ * Validates tasks, executes routing rules based on request constraints and connectivity,
+ * triggers provider adapters, and logs timing telemetry.
+ */
+export declare class IndeRun {
+    private registry;
+    private hostServices;
+    private router;
+    private telemetryService;
+    /**
+     * Initializes the IndeRun instance.
+     * @param registry - Registry filled with active providers.
+     * @param hostServices - Services wrapping OS interfaces and indicators.
+     * @param telemetryService - Optional custom telemetry service listener.
+     */
+    constructor(registry: ProviderRegistry, hostServices: HostServices, telemetryService?: TelemetryService);
+    /**
+     * Safely emits a telemetry event by swallowing any internal logging/telemetry system errors.
+     * @param event - The telemetry event to emit.
+     */
+    private safeEmit;
+    /**
+     * Returns a stable, generic description of an error class for privacy-preserving telemetry.
+     * @param errorClass - The taxonomy classification of the exception.
+     */
+    private getStableMessage;
+    /**
+     * Orchestrates the execution of a TaskRequest.
+     * Performs JSON Schema validation, selects a provider via routing rules,
+     * measures total execution time, and attaches telemetry metadata to the outcome.
+     * @param request - The canonical task request containing prompts, tasks, and constraints.
+     * @returns Canonical task output containing output details and telemetry metadata.
+     * @throws {IndeRunException} Standardized error indicating validation, connection, or provider failures.
+     */
+    run(request: TaskRequest): Promise<TaskResult>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAElG;;;;GAIG;AACH,qBAAa,OAAO;IAWhB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IAXtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAmB;IAE3C;;;;;OAKG;gBAEO,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,YAAY,EAClC,gBAAgB,CAAC,EAAE,gBAAgB;IAOrC;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;;OAOG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;CAoIrD"}

package/dist/engine.js

@@ -0,0 +1,191 @@
+import { getTaskRequestValidationIssues } from "@independo/inderun-contracts";
+import { ProviderRegistry } from "./registry.js";
+import { Router } from "./router.js";
+import { createInternal, toIndeRunException } from "./errors.js";
+import { NoOpTelemetryService } from "./telemetry.js";
+/**
+ * Main orchestrator SDK entrypoint class.
+ * Validates tasks, executes routing rules based on request constraints and connectivity,
+ * triggers provider adapters, and logs timing telemetry.
+ */
+export class IndeRun {
+    registry;
+    hostServices;
+    router;
+    telemetryService;
+    /**
+     * Initializes the IndeRun instance.
+     * @param registry - Registry filled with active providers.
+     * @param hostServices - Services wrapping OS interfaces and indicators.
+     * @param telemetryService - Optional custom telemetry service listener.
+     */
+    constructor(registry, hostServices, telemetryService) {
+        this.registry = registry;
+        this.hostServices = hostServices;
+        this.router = new Router(this.registry);
+        this.telemetryService =
+            telemetryService || this.hostServices.telemetry || new NoOpTelemetryService();
+    }
+    /**
+     * Safely emits a telemetry event by swallowing any internal logging/telemetry system errors.
+     * @param event - The telemetry event to emit.
+     */
+    safeEmit(event) {
+        try {
+            this.telemetryService.emit(event);
+        }
+        catch (err) {
+            // Telemetry failures must never disrupt primary execution flows.
+            console.warn("[IndeRun] Telemetry service emission failed:", err);
+        }
+    }
+    /**
+     * Returns a stable, generic description of an error class for privacy-preserving telemetry.
+     * @param errorClass - The taxonomy classification of the exception.
+     */
+    getStableMessage(errorClass) {
+        switch (errorClass) {
+            case "CapabilityMismatch":
+                return "Provider capability mismatch.";
+            case "Offline":
+                return "Device is offline.";
+            case "AuthError":
+                return "Authentication failed.";
+            case "RateLimited":
+                return "Rate limit exceeded.";
+            case "Timeout":
+                return "Execution timed out.";
+            case "Unavailable":
+                return "Provider is unavailable.";
+            case "Internal":
+            default:
+                return "An internal engine error occurred.";
+        }
+    }
+    /**
+     * Orchestrates the execution of a TaskRequest.
+     * Performs JSON Schema validation, selects a provider via routing rules,
+     * measures total execution time, and attaches telemetry metadata to the outcome.
+     * @param request - The canonical task request containing prompts, tasks, and constraints.
+     * @returns Canonical task output containing output details and telemetry metadata.
+     * @throws {IndeRunException} Standardized error indicating validation, connection, or provider failures.
+     */
+    async run(request) {
+        const startTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+        const runId = request.requestId || `run_${Math.random().toString(36).substring(2, 11)}`;
+        try {
+            // 1. Validate request payload using schema contracts
+            const validationIssues = getTaskRequestValidationIssues(request);
+            if (validationIssues.length > 0) {
+                const message = `Validation failed for TaskRequest: ${validationIssues
+                    .map((i) => `${i.path} - ${i.message}`)
+                    .join("; ")}`;
+                throw createInternal(message, {
+                    runId,
+                    details: { validationIssues }
+                });
+            }
+            // 2. Select the route based on constraints and host capabilities
+            const routeSelection = await this.router.selectRoute(request, this.hostServices);
+            const providers = [routeSelection.provider, ...routeSelection.fallbackProviders];
+            // Emit route_decided event
+            this.safeEmit({
+                type: "route_decided",
+                runId,
+                timestamp: this.hostServices.clock ? this.hostServices.clock.now() : Date.now(),
+                payload: {
+                    selectedProviderId: routeSelection.routePlan.selectedProviderId,
+                    fallbackProviderIds: routeSelection.routePlan.fallbackProviderIds,
+                    rejectedProviders: routeSelection.routePlan.rejectedProviders,
+                    fallbackAvailable: providers.length > 1,
+                    taskKind: request.task.kind,
+                    explanation: routeSelection.explanation,
+                    constraints: request.constraints ?? null,
+                    preferences: request.preferences ?? null
+                }
+            });
+            // 3. Execute the run task using the planned provider chain
+            const attemptedProviderIds = [];
+            let lastError;
+            for (const [index, provider] of providers.entries()) {
+                const providerId = provider.describe().id;
+                attemptedProviderIds.push(providerId);
+                try {
+                    const result = await provider.run(request, {
+                        runId,
+                        hostServices: this.hostServices
+                    });
+                    const endTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+                    const totalMs = endTime - startTime;
+                    result.runId = runId;
+                    result.telemetry = {
+                        ...result.telemetry,
+                        providerUsed: providerId,
+                        totalMs
+                    };
+                    this.safeEmit({
+                        type: "attempt_succeeded",
+                        runId,
+                        timestamp: endTime,
+                        payload: {
+                            providerId,
+                            durationMs: totalMs,
+                            fallbackOccurred: index > 0,
+                            attemptedProviderIds
+                        }
+                    });
+                    return result;
+                }
+                catch (err) {
+                    lastError = toIndeRunException(err, {
+                        providerId,
+                        runId,
+                        details: {
+                            attemptedProviderIds,
+                            fallbackOccurred: index > 0,
+                            routePlan: routeSelection.routePlan
+                        }
+                    });
+                }
+            }
+            const endTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+            const totalMs = endTime - startTime;
+            const exception = toIndeRunException(lastError ?? new Error("No providers were attempted."), {
+                runId,
+                details: {
+                    totalMs,
+                    attemptedProviderIds,
+                    fallbackOccurred: providers.length > 1,
+                    routePlan: routeSelection.routePlan
+                }
+            });
+            throw exception;
+        }
+        catch (error) {
+            const exception = toIndeRunException(error, {
+                runId,
+                details: {
+                    totalMs: typeof error.details?.totalMs === "number"
+                        ? error.details?.totalMs
+                        : (this.hostServices.clock ? this.hostServices.clock.now() : Date.now()) - startTime
+                }
+            });
+            const endTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+            const totalMs = typeof exception.details?.totalMs === "number"
+                ? exception.details?.totalMs
+                : endTime - startTime;
+            this.safeEmit({
+                type: "attempt_failed",
+                runId,
+                timestamp: endTime,
+                payload: {
+                    providerId: exception.providerId ?? null,
+                    durationMs: totalMs,
+                    errorClass: exception.errorClass,
+                    message: this.getStableMessage(exception.errorClass)
+                }
+            });
+            throw exception;
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,93 @@
+import type { IndeRunError, IndeRunErrorClass } from "@independo/inderun-contracts";
+/**
+ * Parameter structure required to initialize an IndeRunException.
+ */
+export interface IndeRunExceptionParams {
+    /**
+     * The standardized error class (e.g. 'CapabilityMismatch', 'Offline').
+     */
+    errorClass: IndeRunErrorClass;
+    /**
+     * Explanatory human-readable message.
+     */
+    message: string;
+    /**
+     * The unique run ID where this exception occurred.
+     */
+    runId?: string;
+    /**
+     * The provider ID that triggered the exception, if execution reached a provider.
+     */
+    providerId?: string;
+    /**
+     * Whether the client should retry this request.
+     */
+    retryable?: boolean;
+    /**
+     * Backoff time suggestion in milliseconds before retrying.
+     */
+    retryAfterMs?: number;
+    /**
+     * Rich contextual metadata regarding the error.
+     */
+    details?: Record<string, unknown>;
+}
+/**
+ * Standardized framework exception thrown when route selection or provider execution fails.
+ * Extends the native JavaScript Error class and exposes normalized error schema fields.
+ */
+export declare class IndeRunException extends Error {
+    /** The schema version matching the API contracts. */
+    readonly schemaVersion = "1.0";
+    /** The categorized class of error. */
+    readonly errorClass: IndeRunErrorClass;
+    /** The unique execution run ID. */
+    readonly runId?: string;
+    /** The provider ID responsible for the error. */
+    readonly providerId?: string;
+    /** Whether the error is transient and retryable. */
+    readonly retryable?: boolean;
+    /** Suggested cooling-down time in milliseconds before retry. */
+    readonly retryAfterMs?: number;
+    /** Custom details and metadata context. */
+    readonly details?: Record<string, unknown>;
+    constructor(params: IndeRunExceptionParams);
+    /**
+     * Converts the exception into a JSON-compatible contract-compliant IndeRunError.
+     */
+    toContractError(): IndeRunError;
+}
+/**
+ * Factory helper for CapabilityMismatch error class.
+ */
+export declare function createCapabilityMismatch(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Factory helper for Offline error class.
+ */
+export declare function createOffline(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Factory helper for AuthError error class.
+ */
+export declare function createAuthError(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Factory helper for RateLimited error class.
+ */
+export declare function createRateLimited(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Factory helper for Timeout error class.
+ */
+export declare function createTimeout(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Factory helper for Unavailable error class.
+ */
+export declare function createUnavailable(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Factory helper for Internal error class.
+ */
+export declare function createInternal(message: string, extra?: Omit<IndeRunExceptionParams, "errorClass" | "message">): IndeRunException;
+/**
+ * Standardizes any caught error into an IndeRunException.
+ * If the input error is already an IndeRunException, merges additional fallback parameters (like totalMs).
+ */
+export declare function toIndeRunException(error: unknown, fallbackParams?: Partial<Omit<IndeRunExceptionParams, "message">>): IndeRunException;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,UAAU,EAAE,iBAAiB,CAAC;IAC9B;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,qDAAqD;IACrD,QAAQ,CAAC,aAAa,SAAS;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,mCAAmC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,oDAAoD;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAE/B,MAAM,EAAE,sBAAsB;IAa1C;;OAEG;IACH,eAAe,IAAI,YAAY;CAahC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,CAAC,GAC7D,gBAAgB,CAElB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,EACd,cAAc,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC,CAAC,GAChE,gBAAgB,CAuDlB"}