@independo/inderun-web 0.1.3-dev.7 → 0.2.0-dev.10

package/README.md

@@ -8,7 +8,7 @@
 
 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.
+This package provides the Web SDK entrypoint, the engine core, routing, telemetry, error normalization, the OpenAI-compatible cloud provider, the Web ONNX Runtime provider for developer-supplied local models, and the Web system-model provider for browser-managed on-device models.
 
 ## Basic Usage
 
@@ -48,6 +48,192 @@ 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.
 
+## On-Device Models: ONNX Runtime (Web)
+
+`local.onnx.genai.web` runs developer-supplied ONNX models in the browser. Registering it is what
+makes `constraints.privacy = "local_required"` routable. Pass `onnx` to the factory (`openAI` and
+`onnx` are both optional, but at least one is required):
+
+```ts
+import { createIndeRunWeb } from "@independo/inderun-web";
+
+const inderun = createIndeRunWeb({
+  onnx: {
+    modelPackage: {
+      id: "phi-3-mini-web",
+      format: "onnx",
+      tasks: ["text_to_text"],
+      runtime: { platforms: ["web"] },
+      source: { sourceType: "registry", ref: "onnx-community/Phi-3-mini-4k-instruct" }
+    }
+  }
+});
+```
+
+`modelPackage` is the provider-neutral `ModelPackage` contract from
+`@independo/inderun-contracts`; only `id` and `format` are required, and the package is validated
+(including the inline-secret and URL-userinfo rules) before every attempt. Model files must never
+carry credentials — use `authContextRef` and secure storage instead.
+
+Options: `id` (defaults to `local.onnx.genai.web`), `modelPackage` (required), `runtime`, and
+`timeoutMs` (a request's `constraints.timeoutMs` wins).
+
+The default runtime loads **quantized** weights (`q4f16` on WebGPU, `q4` otherwise). Transformers.js
+would otherwise pick `fp32`, which makes ONNX Runtime fail session creation with an allocation error
+(`std::bad_alloc`) for anything but tiny models. Override with `dtype` when your model does not
+publish that variant:
+
+```ts
+import { OnnxRuntimeWebProvider, createTransformersJsRuntime } from "@independo/inderun-web/onnx";
+
+const provider = new OnnxRuntimeWebProvider({
+  modelPackage,
+  runtime: createTransformersJsRuntime({ dtype: "q8", device: "wasm" })
+});
+```
+
+The default runtime targets models that load through the Transformers.js `text-generation` pipeline
+— for example `onnx-community/gemma-3-1b-it-ONNX`. Multimodal exports split across separate
+encoder/decoder graphs need `AutoProcessor` plus a model-specific class and should implement the
+runtime seam instead — see [Custom runtimes](#custom-runtimes).
+
+### Runtime dependency
+
+The default runtime uses [Transformers.js](https://www.npmjs.com/package/@huggingface/transformers),
+which runs ONNX models on `onnxruntime-web` and owns the generation loop (ONNX Runtime GenAI has no
+browser build). It is an optional dependency that IndeRun does not bundle — install it yourself:
+
+```sh
+pnpm add @huggingface/transformers
+```
+
+If the package is present but fails to initialize, the provider reports itself unavailable and
+routing produces an explainable `capability_unavailable` rejection instead of throwing. Bundlers do
+need to resolve the specifier, so an app that imports `@independo/inderun-web/onnx` without
+installing Transformers.js should pass its own runtime (or a `load` override) — see
+[Custom runtimes](#custom-runtimes). WASM threads additionally require
+cross-origin isolation (`Cross-Origin-Opener-Policy: same-origin`,
+`Cross-Origin-Embedder-Policy: require-corp`) on whatever serves your app.
+
+### Supported model sources
+
+| `source.sourceType` | Web         |
+| ------------------- | ----------- |
+| `registry`          | Supported (hub model id in `source.ref`) |
+| `bundled`           | Supported (assets served by your app) |
+| `app_managed`       | Supported (assets served by your app) |
+| `programmatic`      | Supported (requires `createGenerator`) |
+| `remote`            | Deferred — download yourself, then declare the files |
+| `filesystem`        | Unsupported — browsers cannot read arbitrary local paths |
+
+### Errors
+
+| Condition                                                   | `errorClass`         |
+| ----------------------------------------------------------- | -------------------- |
+| Capability gate fails pre-attempt, model missing/incompatible | `CapabilityMismatch` |
+| Runtime initialization failure, resource exhaustion          | `Unavailable`        |
+| Generation exceeded its timeout budget                       | `Timeout`            |
+| Malformed/empty model output, unexpected runtime failure     | `Internal`           |
+
+A purely local runtime never produces `AuthError`, `RateLimited`, or `Offline`.
+
+### Custom runtimes
+
+Swap the execution backend without touching provider semantics by implementing
+`OnnxTextGenerationRuntime`:
+
+```ts
+import {
+  OnnxRuntimeWebProvider,
+  OnnxRuntimeError,
+  createFixtureOnnxRuntime,
+  type OnnxTextGenerationRuntime
+} from "@independo/inderun-web/onnx";
+
+const runtime: OnnxTextGenerationRuntime = {
+  async prepare(modelPackage) {
+    return { available: true };
+  },
+  async generate({ messages, generation }, signal) {
+    // Throw OnnxRuntimeError("capability" | "unavailable" | "timeout" | "internal", …)
+    // to steer IndeRun error normalization.
+    return { text: "…" };
+  }
+};
+```
+
+`createFixtureOnnxRuntime()` provides a deterministic in-memory runtime for tests and offline demos.
+
+## On-Device Models: Web System-Model Provider
+
+`local.system-model.web` runs a browser-managed on-device model — currently
+[Chrome's Prompt API](https://developer.chrome.com/docs/ai/prompt-api) (`LanguageModel`, Gemini
+Nano). Unlike the ONNX provider above, this provider takes no `modelPackage`: the browser owns
+model availability, download, and execution. Registering it also makes
+`constraints.privacy = "local_required"` routable. Pass `systemModel` to the factory:
+
+```ts
+import { createIndeRunWeb } from "@independo/inderun-web";
+
+const inderun = createIndeRunWeb({
+  systemModel: {}
+});
+```
+
+Options: `id` (defaults to `local.system-model.web`), `runtime` (defaults to
+`createChromePromptApiRuntime()`), and `timeoutMs` (a request's `constraints.timeoutMs` wins).
+
+### Browser support
+
+Desktop Chrome 138+ only (Windows 10/11, macOS 13+, Linux, ChromeOS), and requires roughly 22 GB
+free storage plus either a >4 GB VRAM GPU or a 16 GB RAM / 4+ core CPU. These figures come from
+Chrome and may change — see the [Prompt API docs](https://developer.chrome.com/docs/ai/prompt-api)
+for the current requirements. Edge exposes an analogous API, but this package has not yet verified
+whether it shares the exact `LanguageModel` global shape. Everywhere else, the provider reports
+itself unavailable (`api_missing`) rather than throwing.
+
+### Errors
+
+| Condition                                                   | `errorClass`         |
+| ------------------------------------------------------------- | --------------------- |
+| Capability gate fails pre-attempt (any non-available state)   | `CapabilityMismatch`  |
+| Hardware/browser-feature failure surfaced during generation   | `CapabilityMismatch`  |
+| Storage/network constraints, transient failure                | `Unavailable`         |
+| Generation aborted or exceeded its timeout budget              | `Timeout`             |
+| Malformed/empty model output, unexpected runtime failure       | `Internal`            |
+
+A purely local runtime never produces `AuthError`, `RateLimited`, or `Offline`. See
+[`docs/architecture/web-system-model-provider-family.md`](https://github.com/independo-gmbh/inderun/blob/main/docs/architecture/web-system-model-provider-family.md)
+in the monorepo for the full capability-state vocabulary.
+
+### Custom runtimes
+
+Swap the execution backend without touching provider semantics by implementing
+`SystemModelRuntime`:
+
+```ts
+import {
+  SystemModelWebProvider,
+  SystemModelRuntimeError,
+  createFixtureSystemModelRuntime,
+  type SystemModelRuntime
+} from "@independo/inderun-web/system-model";
+
+const runtime: SystemModelRuntime = {
+  async availability() {
+    return { kind: "available" };
+  },
+  async generate({ messages, generation }, signal) {
+    // Throw SystemModelRuntimeError("capability" | "unavailable" | "timeout" | "internal", …)
+    // to steer IndeRun error normalization.
+    return { text: "…" };
+  }
+};
+```
+
+`createFixtureSystemModelRuntime()` provides a deterministic in-memory runtime for tests and
+offline demos.
+
 ## Commands
 
 ```sh

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-host.d.ts","sourceRoot":"","sources":["../../src/core/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/{engine.d.ts → core/engine.d.ts}

@@ -1,5 +1,6 @@
 import { type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
 import type { HostServices } from "./host.js";
+import type { ProviderCapabilitySnapshot } from "./provider.js";
 import { ProviderRegistry } from "./registry.js";
 import { type TelemetryService } from "./telemetry.js";
 /**
@@ -38,5 +39,10 @@ export declare class IndeRun {
      * @throws {IndeRunException} Standardized error indicating validation, connection, or provider failures.
      */
     run(request: TaskRequest): Promise<TaskResult>;
+    /**
+     * Reports each registered provider's static descriptor and current dynamic capability check,
+     * without executing a task. Useful for UI that shows live provider availability before a run.
+     */
+    checkCapabilities(): Promise<ProviderCapabilitySnapshot[]>;
 }
 //# sourceMappingURL=engine.d.ts.map

package/dist/core/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/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,KAAK,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAChE,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;IAuIpD;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}

package/dist/{engine.js → core/engine.js}

@@ -101,7 +101,9 @@ export class IndeRun {
                     taskKind: request.task.kind,
                     explanation: routeSelection.explanation,
                     constraints: request.constraints ?? null,
-                    preferences: request.preferences ?? null
+                    preferences: request.preferences ?? null,
+                    plannerSource: routeSelection.plannerSource,
+                    plannerUnavailableReason: routeSelection.plannerUnavailableReason ?? null
                 }
             });
             // 3. Execute the run task using the planned provider chain
@@ -188,4 +190,15 @@ export class IndeRun {
             throw exception;
         }
     }
+    /**
+     * Reports each registered provider's static descriptor and current dynamic capability check,
+     * without executing a task. Useful for UI that shows live provider availability before a run.
+     */
+    async checkCapabilities() {
+        return Promise.all(this.registry.list().map(async (provider) => ({
+            providerId: provider.describe().id,
+            descriptor: provider.describe(),
+            capabilities: await provider.capabilities(this.hostServices)
+        })));
+    }
 }

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/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"}

package/dist/core/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/core/host.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAC"}

package/dist/{provider.d.ts → core/provider.d.ts}

@@ -83,6 +83,15 @@ export interface ProviderDynamicCapabilities {
      */
     reason?: string;
 }
+/**
+ * Snapshot of a registered provider's static descriptor and current dynamic
+ * capability check, without executing a task.
+ */
+export interface ProviderCapabilitySnapshot {
+    providerId: string;
+    descriptor: ProviderDescriptor;
+    capabilities: ProviderDynamicCapabilities;
+}
 /**
  * Execution context passed to provider run commands.
  */

package/dist/core/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/core/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;IACjC;;OAEG;IACH,SAAS,EAAE,YAAY,GAAG,gBAAgB,GAAG,MAAM,GAAG,KAAK,GAAG,UAAU,CAAC;IACzE;;OAEG;IACH,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;IAEnD;;OAEG;IACH,QAAQ,EAAE;QACR,mEAAmE;QACnE,GAAG,EAAE,OAAO,CAAC;QACb,mDAAmD;QACnD,SAAS,EAAE,OAAO,CAAC;QACnB,6DAA6D;QAC7D,QAAQ,EAAE,OAAO,CAAC;QAClB,6DAA6D;QAC7D,KAAK,EAAE,OAAO,CAAC;QACf,wEAAwE;QACxE,eAAe,EAAE,OAAO,CAAC;QACzB,kFAAkF;QAClF,gBAAgB,EAAE,OAAO,CAAC;QAC1B,6EAA6E;QAC7E,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;IAEF;;;;;OAKG;IACH,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAEjC;;OAEG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IAEF;;OAEG;IACH,OAAO,CAAC,EAAE;QACR,6DAA6D;QAC7D,gBAAgB,EAAE,OAAO,CAAC;QAC1B,2DAA2D;QAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,YAAY,EAAE,2BAA2B,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,IAAI,kBAAkB,CAAC;IAC/B;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACvE;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC7D"}

package/dist/core/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/core/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAsC;IAEvD;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAWzC;;;OAGG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI5C;;OAEG;IACH,IAAI,IAAI,eAAe,EAAE;IAIzB;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/{route-planner.d.ts → core/route-planner.d.ts}

@@ -12,11 +12,28 @@ export interface SharedPlannerModule {
     planRouteJson: (inputJson: string) => string | Promise<string>;
 }
 /**
- * Strategy that turns planner input into a deterministic route plan, or `null`
- * when the planner is unavailable (callers then fall back to local selection).
+ * Coarse, privacy-safe reason the WASM planner produced no route plan. Used
+ * only for observability (telemetry/logging) — callers still fall back to
+ * local selection regardless of which reason fired.
+ */
+export type WasmUnavailableReason = "import_failed" | "invalid_module_shape" | "init_failed" | "plan_failed";
+/**
+ * Result of a {@link RoutePlanner} attempt. `routePlan` is `null` when the
+ * planner could not produce a plan, in which case `source` is `"unavailable"`
+ * and `unavailableReason` narrows down why, so callers can log/emit telemetry
+ * instead of silently swapping planners.
+ */
+export interface PlannerOutcome {
+    routePlan: SharedPlannerRoutePlan | null;
+    source: "wasm" | "unavailable";
+    unavailableReason?: WasmUnavailableReason;
+}
+/**
+ * Strategy that turns planner input into a deterministic route plan, or an
+ * "unavailable" outcome (callers then fall back to local selection).
  */
 export interface RoutePlanner {
-    planRoute(input: SharedPlannerInput): Promise<SharedPlannerRoutePlan | null>;
+    planRoute(input: SharedPlannerInput): Promise<PlannerOutcome>;
 }
 /**
  * A provider paired with the descriptor/capability projection the shared route
@@ -29,16 +46,22 @@ export interface ProviderRuntimeSnapshot {
 }
 /**
  * {@link RoutePlanner} backed by the Rust route core compiled to WASM. The
- * module is imported lazily and memoized; if it cannot be loaded, `planRoute`
- * resolves to `null` so the engine can fall back to local selection.
+ * module specifier is a static literal (not configurable) so bundlers such as
+ * Vite/webpack/Rollup can statically resolve and chunk it — a variable
+ * specifier defeats bundler analysis and silently never loads in the browser
+ * (see issue #109). The module is imported lazily and memoized; if it cannot
+ * be loaded, `planRoute` resolves an "unavailable" outcome so the engine can
+ * fall back to local selection, and logs once via `console.warn` so the
+ * degradation is never fully silent.
  */
 export declare class WasmRoutePlanner implements RoutePlanner {
-    private readonly moduleSpecifier;
     private modulePromise?;
-    constructor(moduleSpecifier?: string);
-    planRoute(input: SharedPlannerInput): Promise<SharedPlannerRoutePlan | null>;
+    private loadFailureReason?;
+    private hasWarned;
+    planRoute(input: SharedPlannerInput): Promise<PlannerOutcome>;
     private loadModule;
     private importModule;
+    private warnOnce;
 }
 /**
  * Describes each provider and evaluates its dynamic capabilities against the

package/dist/core/route-planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-planner.d.ts","sourceRoot":"","sources":["../../src/core/route-planner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,IAAI,sBAAsB,EACnC,iBAAiB,IAAI,kBAAkB,EACvC,WAAW,EACZ,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChE;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC/B,eAAe,GAAG,sBAAsB,GAAG,aAAa,GAAG,aAAa,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACzC,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC/D;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;IAClE,YAAY,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,CAAC;CACvE;AAED;;;;;;;;;GASG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACnD,OAAO,CAAC,aAAa,CAAC,CAAsC;IAC5D,OAAO,CAAC,iBAAiB,CAAC,CAAwB;IAClD,OAAO,CAAC,SAAS,CAAS;IAEpB,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;YAkBrD,UAAU;YAOV,YAAY;IA6B1B,OAAO,CAAC,QAAQ;CAUjB;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,iBAAiB,EAAE,eAAe,EAAE,EACpC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAepC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,uBAAuB,EAAE,EACpC,aAAa,EAAE,OAAO,GACrB,kBAAkB,CAsBpB"}

package/dist/{route-planner.js → core/route-planner.js}

@@ -1,23 +1,33 @@
-const DEFAULT_WASM_SPECIFIER = "@independo/inderun-route-core-wasm";
 /**
  * {@link RoutePlanner} backed by the Rust route core compiled to WASM. The
- * module is imported lazily and memoized; if it cannot be loaded, `planRoute`
- * resolves to `null` so the engine can fall back to local selection.
+ * module specifier is a static literal (not configurable) so bundlers such as
+ * Vite/webpack/Rollup can statically resolve and chunk it — a variable
+ * specifier defeats bundler analysis and silently never loads in the browser
+ * (see issue #109). The module is imported lazily and memoized; if it cannot
+ * be loaded, `planRoute` resolves an "unavailable" outcome so the engine can
+ * fall back to local selection, and logs once via `console.warn` so the
+ * degradation is never fully silent.
  */
 export class WasmRoutePlanner {
-    moduleSpecifier;
     modulePromise;
-    constructor(moduleSpecifier = DEFAULT_WASM_SPECIFIER) {
-        this.moduleSpecifier = moduleSpecifier;
-    }
+    loadFailureReason;
+    hasWarned = false;
     async planRoute(input) {
         const module = await this.loadModule();
         if (!module) {
-            return null;
+            const unavailableReason = this.loadFailureReason ?? "import_failed";
+            this.warnOnce(unavailableReason);
+            return { routePlan: null, source: "unavailable", unavailableReason };
+        }
+        try {
+            const json = JSON.stringify(input);
+            const result = await module.planRouteJson(json);
+            return { routePlan: JSON.parse(result), source: "wasm" };
+        }
+        catch (error) {
+            this.warnOnce("plan_failed", error);
+            return { routePlan: null, source: "unavailable", unavailableReason: "plan_failed" };
         }
-        const json = JSON.stringify(input);
-        const result = await module.planRouteJson(json);
-        return JSON.parse(result);
     }
     async loadModule() {
         if (!this.modulePromise) {
@@ -26,19 +36,38 @@ export class WasmRoutePlanner {
         return this.modulePromise;
     }
     async importModule() {
+        let mod;
         try {
-            const mod = (await import(/* @vite-ignore */ this.moduleSpecifier));
-            if (mod.initSharedCore) {
+            mod = (await import("@independo/inderun-route-core-wasm"));
+        }
+        catch (error) {
+            this.loadFailureReason = "import_failed";
+            this.warnOnce("import_failed", error);
+            return null;
+        }
+        if (typeof mod.planRouteJson !== "function") {
+            this.loadFailureReason = "invalid_module_shape";
+            this.warnOnce("invalid_module_shape");
+            return null;
+        }
+        if (mod.initSharedCore) {
+            try {
                 await mod.initSharedCore();
             }
-            if (typeof mod.planRouteJson !== "function") {
+            catch (error) {
+                this.loadFailureReason = "init_failed";
+                this.warnOnce("init_failed", error);
                 return null;
             }
-            return mod;
         }
-        catch {
-            return null;
+        return mod;
+    }
+    warnOnce(reason, error) {
+        if (this.hasWarned) {
+            return;
         }
+        this.hasWarned = true;
+        console.warn(`[IndeRun] WASM route planner unavailable (${reason}); falling back to local route selection.`, error);
     }
 }
 /**

package/dist/{router.d.ts → core/router.d.ts}

@@ -2,7 +2,7 @@ import type { TaskRequest } from "@independo/inderun-contracts";
 import type { HostServices } from "./host.js";
 import type { ProviderAdapter } from "./provider.js";
 import type { ProviderRegistry } from "./registry.js";
-import { type RoutePlanner, type SharedPlannerRoutePlan } from "./route-planner.js";
+import { type RoutePlanner, type SharedPlannerRoutePlan, type WasmUnavailableReason } from "./route-planner.js";
 /**
  * Output structure from the Router containing the chosen provider and a route selection description.
  */
@@ -23,6 +23,16 @@ export interface RouteSelection {
      * Explanation detailing the selection decision. Useful for debugging and telemetry.
      */
     explanation: string;
+    /**
+     * Which planner produced `routePlan`: the shared Rust/WASM core, or the
+     * local TypeScript fallback used when the WASM planner is unavailable.
+     */
+    plannerSource: "wasm" | "fallback";
+    /**
+     * Set when `plannerSource` is `"fallback"` because the WASM planner failed;
+     * `undefined` when the fallback was not caused by a planner failure.
+     */
+    plannerUnavailableReason?: WasmUnavailableReason;
 }
 /**
  * Routing engine module. Filters registered providers against task types, request constraints,

package/dist/core/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/core/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAOtD,OAAO,EAIL,KAAK,YAAY,EAEjB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAE3B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC;IAC1B;;OAEG;IACH,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC;;OAEG;IACH,SAAS,EAAE,sBAAsB,CAAC;IAClC;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,aAAa,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,qBAAqB,CAAC;CAClD;AAED;;;;GAIG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;gBADP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAqC;IAGxD;;;;;;;;;OASG;IACG,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;IAc5F,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,mBAAmB;IAc3B,OAAO,CAAC,2BAA2B;IA2BnC,OAAO,CAAC,kBAAkB;IA0F1B,OAAO,CAAC,2BAA2B;IAiCnC,OAAO,CAAC,gBAAgB;CAYzB"}

package/dist/{router.js → core/router.js}

@@ -26,26 +26,26 @@ export class Router {
         const online = await hostServices.connectivity.isOnline();
         const snapshots = await collectProviderRuntimeSnapshots(this.registry.list(), hostServices);
         const planInput = buildSharedPlannerInput(request, snapshots, online);
-        const routePlan = await this.planner.planRoute(planInput);
-        if (routePlan) {
-            return this.selectFromSharedPlan(snapshots, routePlan);
+        const outcome = await this.planner.planRoute(planInput);
+        if (outcome.routePlan) {
+            return this.selectFromSharedPlan(snapshots, outcome.routePlan);
         }
-        return this.selectFallbackRoute(request, snapshots, online);
+        return this.selectFallbackRoute(request, snapshots, online, outcome.unavailableReason);
     }
     selectFromSharedPlan(snapshots, routePlan) {
         if (!routePlan.selectedProviderId) {
             throw this.routePlanFailure(routePlan);
         }
-        return this.buildSelectionFromRoutePlan(snapshots, routePlan);
+        return this.buildSelectionFromRoutePlan(snapshots, routePlan, "wasm");
     }
-    selectFallbackRoute(request, snapshots, online) {
+    selectFallbackRoute(request, snapshots, online, plannerUnavailableReason) {
         const plan = this.createFallbackPlan(request, snapshots, online);
         if (!plan.selectedProviderId) {
             throw this.routePlanFailure(plan);
         }
-        return this.buildSelectionFromRoutePlan(snapshots, plan);
+        return this.buildSelectionFromRoutePlan(snapshots, plan, "fallback", plannerUnavailableReason);
     }
-    buildSelectionFromRoutePlan(snapshots, routePlan) {
+    buildSelectionFromRoutePlan(snapshots, routePlan, plannerSource, plannerUnavailableReason) {
         const orderedProviders = routePlan.candidates
             .map((candidate) => snapshots.find((snapshot) => snapshot.descriptor.id === candidate.providerId))
             .filter((snapshot) => snapshot !== undefined);
@@ -57,7 +57,9 @@ export class Router {
             provider: selected.provider,
             fallbackProviders: orderedProviders.slice(1).map((snapshot) => snapshot.provider),
             routePlan,
-            explanation: routePlan.explanation.summary
+            explanation: routePlan.explanation.summary,
+            plannerSource,
+            ...(plannerUnavailableReason ? { plannerUnavailableReason } : {})
         };
     }
     createFallbackPlan(request, snapshots, online) {
@@ -67,17 +69,24 @@ export class Router {
             .filter((candidate) => candidate.descriptor.supports.run);
         const localCandidates = eligible.filter((candidate) => candidate.descriptor.type !== "cloud");
         const cloudCandidates = eligible.filter((candidate) => candidate.descriptor.type === "cloud");
-        const selected = eligible.find((candidate) => {
+        // Constraint filtering must apply to the whole candidate list, not just the selected provider:
+        // the remainder becomes the engine's fallback chain, and a fallback that violates the request
+        // constraints would let a `local_required` run be retried against a cloud provider.
+        const admissible = eligible.filter((candidate) => {
             const descriptor = candidate.descriptor;
             const constraints = planInput.constraints;
-            const privacy = descriptor.privacy?.dataLeavesDevice ?? descriptor.type !== "cloud";
+            // Mirrors `is_data_private` in the shared Rust planner: a provider is private when it
+            // declares that data does not leave the device, defaulting to non-cloud providers.
+            const isDataPrivate = descriptor.privacy
+                ? !descriptor.privacy.dataLeavesDevice
+                : descriptor.type !== "cloud";
             if (constraints.cloud === "forbidden" && descriptor.type === "cloud") {
                 return false;
             }
             if (constraints.cloud === "required" && descriptor.type !== "cloud") {
                 return false;
             }
-            if (constraints.privacy === "local_required" && !privacy) {
+            if (constraints.privacy === "local_required" && !isDataPrivate) {
                 return false;
             }
             if (constraints.privacy === "cloud_required" && descriptor.type !== "cloud") {
@@ -88,10 +97,7 @@ export class Router {
             }
             return candidate.capabilities.available;
         });
-        const ordered = selected
-            ? [selected, ...eligible.filter((candidate) => candidate !== selected)]
-            : [];
-        if (ordered.length === 0) {
+        if (admissible.length === 0) {
             const failureSummary = this.buildFallbackFailureSummary({
                 online,
                 constraints: planInput.constraints,
@@ -114,17 +120,17 @@ export class Router {
                 }
             };
         }
-        const selectedProviderId = ordered[0]?.descriptor.id;
+        const selectedProviderId = admissible[0]?.descriptor.id;
         return {
             selectedProviderId,
-            fallbackProviderIds: ordered.slice(1).map((candidate) => candidate.descriptor.id),
-            candidates: ordered.map((candidate, index) => ({
+            fallbackProviderIds: admissible.slice(1).map((candidate) => candidate.descriptor.id),
+            candidates: admissible.map((candidate, index) => ({
                 providerId: candidate.descriptor.id,
                 order: index
             })),
             rejectedProviders: [],
             explanation: {
-                summary: `Selected provider '${selectedProviderId}' deterministically from ${ordered.length} eligible candidate(s).`,
+                summary: `Selected provider '${selectedProviderId}' deterministically from ${admissible.length} eligible candidate(s).`,
                 selectedProviderId
             }
         };

package/dist/core/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/core/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErF,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC;;GAEG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;CAGnC"}

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export { type ConnectivityService, type DeviceConstraintsService, type SecureStorageService, type ClockService, type HttpClientService, type HttpRequest, type HttpResponse, type HostServices, type ThermalState } from "./host.js";
-export { type ProviderDescriptor, type ProviderDynamicCapabilities, type RunContext, type ProviderAdapter } from "./provider.js";
-export { ProviderRegistry } from "./registry.js";
-export { type RouteSelection, Router } from "./router.js";
-export { type RoutePlanner, type SharedPlannerInput, type SharedPlannerRoutePlan, WasmRoutePlanner } from "./route-planner.js";
-export { type IndeRunExceptionParams, IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./errors.js";
-export { IndeRun } from "./engine.js";
-export { type TelemetryEventType, type TelemetryEvent, type TelemetryService, NoOpTelemetryService } from "./telemetry.js";
-export { BrowserConnectivityService, FetchHttpClient, SystemClockService, createBrowserHostServices, type CreateBrowserHostServicesOptions, type FetchHttpClientOptions } from "./browser-host.js";
+export { type ConnectivityService, type DeviceConstraintsService, type SecureStorageService, type ClockService, type HttpClientService, type HttpRequest, type HttpResponse, type HostServices, type ThermalState } from "./core/host.js";
+export { type ProviderDescriptor, type ProviderDynamicCapabilities, type ProviderCapabilitySnapshot, type RunContext, type ProviderAdapter } from "./core/provider.js";
+export { ProviderRegistry } from "./core/registry.js";
+export { type RouteSelection, Router } from "./core/router.js";
+export { type RoutePlanner, type PlannerOutcome, type WasmUnavailableReason, type SharedPlannerInput, type SharedPlannerRoutePlan, WasmRoutePlanner } from "./core/route-planner.js";
+export { type IndeRunExceptionParams, IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./core/errors.js";
+export { IndeRun } from "./core/engine.js";
+export { type TelemetryEventType, type TelemetryEvent, type TelemetryService, NoOpTelemetryService } from "./core/telemetry.js";
+export { BrowserConnectivityService, FetchHttpClient, SystemClockService, createBrowserHostServices, type CreateBrowserHostServicesOptions, type FetchHttpClientOptions } from "./core/browser-host.js";
 export { createIndeRunWeb, type CreateIndeRunWebOptions } from "./web-sdk.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,UAAU,EACf,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,UAAU,EACf,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}