@independo/inderun-web 0.3.0-dev.8 → 0.3.0

package/dist/core/router.js

@@ -31,25 +31,24 @@ export class Router {
         const snapshots = await collectProviderRuntimeSnapshots(this.registry.list(), hostServices);
         const planInput = buildSharedPlannerInput(request, snapshots, online, interactionMode);
         const outcome = await this.planner.planRoute(planInput);
-        if (outcome.routePlan) {
-            return this.selectFromSharedPlan(snapshots, outcome.routePlan);
+        if (!outcome.routePlan) {
+            // There is no second planner to degrade to: routing is the shared Rust
+            // core's semantics or nothing. Failing here keeps provider selection
+            // identical everywhere rather than forking it on a module load failure.
+            const reason = outcome.unavailableReason ?? "import_failed";
+            throw createInternal(`Route planner unavailable (${reason}).`, {
+                details: { plannerUnavailableReason: reason }
+            });
         }
-        return this.selectFallbackRoute(request, snapshots, online, interactionMode, outcome.unavailableReason);
+        return this.selectFromSharedPlan(snapshots, outcome.routePlan);
     }
     selectFromSharedPlan(snapshots, routePlan) {
         if (!routePlan.selectedProviderId) {
             throw this.routePlanFailure(routePlan);
         }
-        return this.buildSelectionFromRoutePlan(snapshots, routePlan, "wasm");
-    }
-    selectFallbackRoute(request, snapshots, online, interactionMode, plannerUnavailableReason) {
-        const plan = this.createFallbackPlan(request, snapshots, online, interactionMode);
-        if (!plan.selectedProviderId) {
-            throw this.routePlanFailure(plan);
-        }
-        return this.buildSelectionFromRoutePlan(snapshots, plan, "fallback", plannerUnavailableReason);
+        return this.buildSelectionFromRoutePlan(snapshots, routePlan);
     }
-    buildSelectionFromRoutePlan(snapshots, routePlan, plannerSource, plannerUnavailableReason) {
+    buildSelectionFromRoutePlan(snapshots, routePlan) {
         const orderedProviders = routePlan.candidates
             .map((candidate) => snapshots.find((snapshot) => snapshot.descriptor.id === candidate.providerId))
             .filter((snapshot) => snapshot !== undefined);
@@ -61,202 +60,9 @@ export class Router {
             provider: selected.provider,
             fallbackProviders: orderedProviders.slice(1).map((snapshot) => snapshot.provider),
             routePlan,
-            explanation: routePlan.explanation.summary,
-            plannerSource,
-            ...(plannerUnavailableReason ? { plannerUnavailableReason } : {})
+            explanation: routePlan.explanation.summary
         };
     }
-    /**
-     * Hand-written mirror of the shared Rust planner (`rust/inderun-route-core/src/planner.rs`),
-     * used when the WASM core cannot be loaded. It reproduces the same rejection
-     * codes and messages so route explanations stay comparable across both paths.
-     *
-     * Known, deliberate divergence: this mirror keeps the id-sorted snapshot order
-     * instead of reproducing the Rust placement/preference ranks, so `optimizeFor`
-     * does not influence ordering here.
-     */
-    createFallbackPlan(request, snapshots, online, interactionMode) {
-        const planInput = buildSharedPlannerInput(request, snapshots, online, interactionMode);
-        const eligible = snapshots.filter((candidate) => candidate.descriptor.tasks.includes(planInput.task.kind));
-        const localCandidates = eligible.filter((candidate) => candidate.descriptor.type !== "cloud");
-        const cloudCandidates = eligible.filter((candidate) => candidate.descriptor.type === "cloud");
-        // 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 = [];
-        const rejectedProviders = [];
-        for (const candidate of snapshots) {
-            const reasons = this.evaluateFallbackCandidate(candidate, planInput, interactionMode);
-            if (reasons.length === 0) {
-                admissible.push(candidate);
-            }
-            else {
-                rejectedProviders.push({ providerId: candidate.descriptor.id, reasons });
-            }
-        }
-        if (admissible.length === 0) {
-            const failureSummary = this.buildFallbackFailureSummary({
-                online,
-                interactionMode,
-                taskKind: planInput.task.kind,
-                constraints: planInput.constraints,
-                localCandidates,
-                cloudCandidates
-            });
-            const failureCode = this.inferFallbackFailureCode(planInput, rejectedProviders);
-            return {
-                fallbackProviderIds: [],
-                candidates: [],
-                rejectedProviders,
-                failureCode,
-                explanation: {
-                    summary: failureSummary
-                }
-            };
-        }
-        const selectedProviderId = admissible[0]?.descriptor.id;
-        const summary = interactionMode === "stream"
-            ? `Selected streaming provider '${selectedProviderId}' deterministically from ${admissible.length} eligible candidate(s).`
-            : `Selected provider '${selectedProviderId}' deterministically from ${admissible.length} eligible candidate(s).`;
-        return {
-            selectedProviderId,
-            fallbackProviderIds: admissible.slice(1).map((candidate) => candidate.descriptor.id),
-            candidates: admissible.map((candidate, index) => ({
-                providerId: candidate.descriptor.id,
-                order: index
-            })),
-            rejectedProviders,
-            explanation: {
-                summary,
-                selectedProviderId
-            }
-        };
-    }
-    /**
-     * Mirrors `infer_failure_code` in the shared Rust planner. The offline class is
-     * derived from the rejection reasons rather than from the connectivity flag
-     * alone: an offline host whose only provider is local and non-streaming failed
-     * on capability, not on connectivity, and reporting `Offline` there would
-     * contradict the explanation shipped alongside it.
-     */
-    inferFallbackFailureCode(planInput, rejectedProviders) {
-        if (rejectedProviders.some((rejected) => rejected.reasons.some((reason) => reason.code === "offline"))) {
-            return "offline";
-        }
-        if (planInput.constraints.cloud === "required" ||
-            planInput.constraints.privacy === "cloud_required") {
-            return "unavailable";
-        }
-        return "capability_mismatch";
-    }
-    /**
-     * Mirrors `evaluate_provider` in the shared Rust planner: it accumulates every
-     * violated rule rather than short-circuiting, so a rejected provider carries a
-     * complete explanation. The streaming checks are ordered static-before-dynamic
-     * for the same reason as in Rust — a provider that never declared streaming
-     * must not also be reported as dynamically unavailable.
-     */
-    evaluateFallbackCandidate(candidate, planInput, interactionMode) {
-        const descriptor = candidate.descriptor;
-        const capabilities = candidate.capabilities;
-        const constraints = planInput.constraints;
-        const wantsStream = interactionMode === "stream";
-        const reasons = [];
-        // 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 (!descriptor.tasks.includes(planInput.task.kind)) {
-            reasons.push({
-                code: "task_not_supported",
-                message: `Provider '${descriptor.id}' does not support task '${planInput.task.kind}'.`
-            });
-        }
-        if (!wantsStream && !descriptor.supports.run) {
-            reasons.push({
-                code: "run_not_supported",
-                message: `Provider '${descriptor.id}' does not support run().`
-            });
-        }
-        if (wantsStream) {
-            if (!descriptor.supports.streaming) {
-                reasons.push({
-                    code: "streaming_not_supported",
-                    message: `Provider '${descriptor.id}' does not support streaming (Mode 2).`
-                });
-            }
-            else if (capabilities.streamingAvailable === false) {
-                reasons.push({
-                    code: "streaming_unavailable",
-                    message: capabilities.streamingUnavailableReason ??
-                        `Provider '${descriptor.id}' cannot stream in the current host environment.`
-                });
-            }
-        }
-        if (constraints.privacy === "local_required" && !isDataPrivate) {
-            reasons.push({
-                code: "privacy_constraint",
-                message: `Provider '${descriptor.id}' does not satisfy local-required privacy.`
-            });
-        }
-        if (constraints.privacy === "cloud_required" && descriptor.type !== "cloud") {
-            reasons.push({
-                code: "privacy_constraint",
-                message: `Provider '${descriptor.id}' does not satisfy cloud-required privacy.`
-            });
-        }
-        if (constraints.cloud === "forbidden" && descriptor.type === "cloud") {
-            reasons.push({
-                code: "cloud_constraint",
-                message: `Provider '${descriptor.id}' is cloud-based but cloud execution is forbidden.`
-            });
-        }
-        if (constraints.cloud === "required" && descriptor.type !== "cloud") {
-            reasons.push({
-                code: "cloud_constraint",
-                message: `Provider '${descriptor.id}' is not cloud-based but cloud execution is required.`
-            });
-        }
-        if (constraints.networkOnline === false && descriptor.type === "cloud") {
-            reasons.push({
-                code: "offline",
-                message: `Provider '${descriptor.id}' requires cloud connectivity, but the host is offline.`
-            });
-        }
-        if (!capabilities.available) {
-            reasons.push({
-                code: "capability_unavailable",
-                message: capabilities.reason ?? `Provider '${descriptor.id}' is currently unavailable.`
-            });
-        }
-        return reasons;
-    }
-    buildFallbackFailureSummary(input) {
-        const wantsCloud = input.constraints.cloud === "required" || input.constraints.privacy === "cloud_required";
-        const wantsLocal = input.constraints.privacy === "local_required";
-        if (!input.online && (wantsCloud || input.cloudCandidates.length > 0)) {
-            return "No network connection is available.";
-        }
-        if (wantsCloud) {
-            if (input.cloudCandidates.length === 0) {
-                return "No cloud provider found.";
-            }
-            return "No cloud provider is currently available.";
-        }
-        if (wantsLocal) {
-            if (input.localCandidates.length === 0) {
-                return "No on-device provider found.";
-            }
-            return "No on-device provider is currently available.";
-        }
-        if (input.interactionMode === "stream") {
-            // Kept verbatim in sync with the shared Rust planner's stream-mode failure
-            // summary so the message a caller sees does not depend on which planner ran.
-            return `No provider capable of streaming was found for task '${input.taskKind}'.`;
-        }
-        return "No eligible provider found for the current routing constraints.";
-    }
     /**
      * Routing failure throws before any `route_decided` telemetry is emitted, so the
      * plan's diagnostics are attached to the exception — that is the only channel

package/dist/index.d.ts

@@ -1,13 +1,76 @@
+/**
+ * Unified entry point for the IndeRun Web SDK (`@independo/inderun-web`).
+ *
+ * Everything a browser app needs to run and stream tasks is exported from here:
+ * the engine, the routing and provider seams, host services, error and telemetry
+ * types, and the contract types the SDK's own signatures use. Provider adapters
+ * are the deliberate exception — each ships from its own subpath
+ * (`/openai`, `/onnx`, `/system-model`) so this surface stays provider-agnostic.
+ */
+/**
+ * Host services: the platform capabilities the engine reads and calls through,
+ * and the seams an embedder overrides to supply its own (custom transport,
+ * credential storage, clock).
+ */
 export { type AbortSignalLike, type ConnectivityService, type DeviceConstraintsService, type SecureStorageService, type ClockService, type HttpClientService, type HttpRequest, type HttpResponse, type HttpStreamResponse, type HttpStreamingClientService, type HostServices, type ThermalState } from "./core/host.js";
+/**
+ * The provider contract. Implement `ProviderAdapter` for a Mode 1 backend and add
+ * a `stream` for Mode 2; the descriptor and dynamic capability check are what the
+ * router plans against.
+ */
 export { type ProviderDescriptor, type ProviderDynamicCapabilities, type ProviderCapabilitySnapshot, type RunContext, type ProviderAdapter, type ProviderStreamContext, type ProviderStreamEvent, type StreamRun } from "./core/provider.js";
+/**
+ * Per-run gatekeeper for a Mode 2 stream: assigns the sequence numbers callers
+ * order by, and enforces that exactly one terminal outcome is produced with
+ * nothing admitted after it. Exported for embedders driving a stream themselves.
+ */
 export { EventGate } from "./core/event-gate.js";
+/** Holds the provider adapters a given engine instance can route to. */
 export { ProviderRegistry } from "./core/registry.js";
+/**
+ * Route selection. `Router` turns a request plus a host capability snapshot into
+ * a provider chain; `WasmRoutePlanner` is the shared Rust planner behind it, and
+ * the only planner the Web SDK has — there is no JavaScript fallback.
+ */
 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";
+/**
+ * The normalized error taxonomy. Every failure the SDK surfaces is an
+ * `IndeRunException` in one of these classes, whatever the provider raised.
+ */
 export { type IndeRunExceptionParams, IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./core/errors.js";
+/** The engine itself, and the app-facing API surface it implements. */
 export { IndeRun, type StreamHandleResult } from "./core/engine.js";
 export type { IndeRunApi } from "./core/generated/inderun-api.js";
+/**
+ * The contract types this SDK's own signatures take and return.
+ *
+ * Re-exported so a typed app needs only the one dependency the README tells it to
+ * install. `@independo/inderun-contracts` is ours transitively, and under pnpm's
+ * isolated `node_modules` an undeclared import of it does not resolve at all.
+ * This is the npm counterpart of Gradle `api(...)` on Android and `@_exported
+ * import` on Swift — see
+ * {@link https://github.com/independo-gmbh/inderun/issues/189 | #189}. The
+ * host-service and telemetry blocks in this file re-export their halves of the
+ * same contract surface for the same reason.
+ *
+ * Depend on `@independo/inderun-contracts` directly only for what is not
+ * re-exported here: the JSON Schemas and the `get*ValidationIssues` validators.
+ */
+export type { IndeRunError, IndeRunErrorClass, StreamEvent, StreamRunHandle, StreamTerminalOutcome, TaskRequest, TaskResult } from "@independo/inderun-contracts";
+/**
+ * Telemetry. Pass a `TelemetryService` to observe routing decisions and attempt
+ * outcomes; the engine defaults to `NoOpTelemetryService`.
+ */
 export { type TelemetryEventType, type TelemetryEvent, type TelemetryService, NoOpTelemetryService } from "./core/telemetry.js";
+/**
+ * The browser implementations of the host services above, and the factory that
+ * assembles them. Use these directly only when constructing `IndeRun` by hand.
+ */
 export { BrowserConnectivityService, FetchHttpClient, FetchStreamingHttpClient, SystemClockService, createBrowserHostServices, type CreateBrowserHostServicesOptions, type FetchHttpClientOptions } from "./core/browser-host.js";
+/**
+ * The recommended way in: builds host services, registers the providers named in
+ * the options, and returns a ready engine.
+ */
 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,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,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,EACpB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,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,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,wBAAwB,EACxB,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB;;;;GAIG;AACH,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACf,MAAM,oBAAoB,CAAC;AAE5B;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,wEAAwE;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;;GAIG;AACH,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;;;GAGG;AACH,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,uEAAuE;AACvE,OAAO,EAAE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE;;;;;;;;;;;;;;GAcG;AACH,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,qBAAqB,EACrB,WAAW,EACX,UAAU,EACX,MAAM,8BAA8B,CAAC;AAEtC;;;GAGG;AACH,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B;;;GAGG;AACH,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,wBAAwB,EACxB,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAEhC;;;GAGG;AACH,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,13 +1,58 @@
+/**
+ * Unified entry point for the IndeRun Web SDK (`@independo/inderun-web`).
+ *
+ * Everything a browser app needs to run and stream tasks is exported from here:
+ * the engine, the routing and provider seams, host services, error and telemetry
+ * types, and the contract types the SDK's own signatures use. Provider adapters
+ * are the deliberate exception — each ships from its own subpath
+ * (`/openai`, `/onnx`, `/system-model`) so this surface stays provider-agnostic.
+ */
+/**
+ * Host services: the platform capabilities the engine reads and calls through,
+ * and the seams an embedder overrides to supply its own (custom transport,
+ * credential storage, clock).
+ */
 export {} from "./core/host.js";
+/**
+ * The provider contract. Implement `ProviderAdapter` for a Mode 1 backend and add
+ * a `stream` for Mode 2; the descriptor and dynamic capability check are what the
+ * router plans against.
+ */
 export {} from "./core/provider.js";
+/**
+ * Per-run gatekeeper for a Mode 2 stream: assigns the sequence numbers callers
+ * order by, and enforces that exactly one terminal outcome is produced with
+ * nothing admitted after it. Exported for embedders driving a stream themselves.
+ */
 export { EventGate } from "./core/event-gate.js";
+/** Holds the provider adapters a given engine instance can route to. */
 export { ProviderRegistry } from "./core/registry.js";
+/**
+ * Route selection. `Router` turns a request plus a host capability snapshot into
+ * a provider chain; `WasmRoutePlanner` is the shared Rust planner behind it, and
+ * the only planner the Web SDK has — there is no JavaScript fallback.
+ */
 export { Router } from "./core/router.js";
 export { WasmRoutePlanner } from "./core/route-planner.js";
+/**
+ * The normalized error taxonomy. Every failure the SDK surfaces is an
+ * `IndeRunException` in one of these classes, whatever the provider raised.
+ */
 export { IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./core/errors.js";
+/** The engine itself, and the app-facing API surface it implements. */
 export { IndeRun } from "./core/engine.js";
+/**
+ * Telemetry. Pass a `TelemetryService` to observe routing decisions and attempt
+ * outcomes; the engine defaults to `NoOpTelemetryService`.
+ */
 export { NoOpTelemetryService } from "./core/telemetry.js";
+/**
+ * The browser implementations of the host services above, and the factory that
+ * assembles them. Use these directly only when constructing `IndeRun` by hand.
+ */
 export { BrowserConnectivityService, FetchHttpClient, FetchStreamingHttpClient, SystemClockService, createBrowserHostServices } from "./core/browser-host.js";
+/**
+ * The recommended way in: builds host services, registers the providers named in
+ * the options, and returns a ready engine.
+ */
 export { createIndeRunWeb } from "./web-sdk.js";
-// The OpenAI Responses adapter is provider-specific and intentionally excluded
-// from this unified index. Import it from "@independo/inderun-web/openai".

package/dist/onnx.d.ts

@@ -6,8 +6,29 @@
  * when registering the adapter manually or when implementing a custom
  * `OnnxTextGenerationRuntime`; most browser apps should pass `onnx` to
  * `createIndeRunWeb` from the main entry point instead.
+ *
+ * See {@link https://github.com/independo-gmbh/inderun/blob/main/docs/architecture/onnx-runtime-provider-family.md | the ONNX Runtime provider family doc}
+ * for the model IO contract, supported source types, and error mapping.
  */
+/** The adapter itself, plus the source types and default id the router plans against. */
 export { OnnxRuntimeWebProvider, DEFAULT_ONNX_WEB_PROVIDER_ID, SUPPORTED_WEB_MODEL_SOURCE_TYPES, type OnnxProviderOptions } from "./providers/onnx/provider.js";
+/**
+ * The runtime seam. The provider does no inference itself: it delegates to an
+ * `OnnxTextGenerationRuntime`, so an app can swap in its own engine, or
+ * `createFixtureOnnxRuntime()` for demos and tests without shipping a model.
+ */
 export { OnnxRuntimeError, createFixtureOnnxRuntime, type FixtureOnnxRuntimeOptions, type OnnxGenerationInput, type OnnxGenerationMessage, type OnnxGenerationOutput, type OnnxRuntimeAvailability, type OnnxRuntimeErrorKind, type OnnxTextGenerationRuntime } from "./providers/onnx/runtime.js";
+/**
+ * The model-description contract types this entry point's options take.
+ * Re-exported for the same reason as the contract types on the SDK index — see
+ * the note there.
+ */
+export type { ModelPackage, ModelSourceType } from "@independo/inderun-contracts";
+/**
+ * The default runtime, backed by `@huggingface/transformers`. That package is an
+ * optional peer dependency and is reached structurally through
+ * `TransformersModule`, so nothing here forces it on apps that supply their own
+ * runtime.
+ */
 export { createTransformersJsRuntime, type TransformersJsRuntimeOptions, type TransformersModule, type TransformersTextGenerator } from "./providers/onnx/transformers-runtime.js";
 //# sourceMappingURL=onnx.d.ts.map

package/dist/onnx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onnx.d.ts","sourceRoot":"","sources":["../src/onnx.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,gCAAgC,EAChC,KAAK,mBAAmB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,2BAA2B,EAC3B,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,0CAA0C,CAAC"}
+{"version":3,"file":"onnx.d.ts","sourceRoot":"","sources":["../src/onnx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,yFAAyF;AACzF,OAAO,EACL,sBAAsB,EACtB,4BAA4B,EAC5B,gCAAgC,EAChC,KAAK,mBAAmB,EACzB,MAAM,8BAA8B,CAAC;AAEtC;;;;GAIG;AACH,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,6BAA6B,CAAC;AAErC;;;;GAIG;AACH,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAElF;;;;;GAKG;AACH,OAAO,EACL,2BAA2B,EAC3B,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC/B,MAAM,0CAA0C,CAAC"}

package/dist/onnx.js

@@ -6,7 +6,22 @@
  * when registering the adapter manually or when implementing a custom
  * `OnnxTextGenerationRuntime`; most browser apps should pass `onnx` to
  * `createIndeRunWeb` from the main entry point instead.
+ *
+ * See {@link https://github.com/independo-gmbh/inderun/blob/main/docs/architecture/onnx-runtime-provider-family.md | the ONNX Runtime provider family doc}
+ * for the model IO contract, supported source types, and error mapping.
  */
+/** The adapter itself, plus the source types and default id the router plans against. */
 export { OnnxRuntimeWebProvider, DEFAULT_ONNX_WEB_PROVIDER_ID, SUPPORTED_WEB_MODEL_SOURCE_TYPES } from "./providers/onnx/provider.js";
+/**
+ * The runtime seam. The provider does no inference itself: it delegates to an
+ * `OnnxTextGenerationRuntime`, so an app can swap in its own engine, or
+ * `createFixtureOnnxRuntime()` for demos and tests without shipping a model.
+ */
 export { OnnxRuntimeError, createFixtureOnnxRuntime } from "./providers/onnx/runtime.js";
+/**
+ * The default runtime, backed by `@huggingface/transformers`. That package is an
+ * optional peer dependency and is reached structurally through
+ * `TransformersModule`, so nothing here forces it on apps that supply their own
+ * runtime.
+ */
 export { createTransformersJsRuntime } from "./providers/onnx/transformers-runtime.js";

package/dist/openai.d.ts

@@ -5,6 +5,13 @@
  * surface stays provider-agnostic. Import from `@independo/inderun-web/openai`
  * when registering the adapter manually; most browser apps should use
  * `createIndeRunWeb` from the main entry point instead.
+ *
+ * Browser apps must point `endpointUrl` at a same-origin proxy that holds the
+ * API key server-side. Provider credentials must never reach the browser.
+ */
+/**
+ * The adapter and its options. Runs Mode 1 and Mode 2 against any
+ * OpenAI-Responses-compatible endpoint, not just OpenAI's own.
  */
 export { OpenAIResponsesProvider, type OpenAIProviderOptions, DEFAULT_OPENAI_RESPONSES_ENDPOINT } from "./providers/openai/provider.js";
 //# sourceMappingURL=openai.d.ts.map

package/dist/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,iCAAiC,EAClC,MAAM,gCAAgC,CAAC"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,OAAO,EACL,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,iCAAiC,EAClC,MAAM,gCAAgC,CAAC"}

package/dist/openai.js

@@ -5,5 +5,12 @@
  * surface stays provider-agnostic. Import from `@independo/inderun-web/openai`
  * when registering the adapter manually; most browser apps should use
  * `createIndeRunWeb` from the main entry point instead.
+ *
+ * Browser apps must point `endpointUrl` at a same-origin proxy that holds the
+ * API key server-side. Provider credentials must never reach the browser.
+ */
+/**
+ * The adapter and its options. Runs Mode 1 and Mode 2 against any
+ * OpenAI-Responses-compatible endpoint, not just OpenAI's own.
  */
 export { OpenAIResponsesProvider, DEFAULT_OPENAI_RESPONSES_ENDPOINT } from "./providers/openai/provider.js";

package/dist/system-model.d.ts

@@ -6,8 +6,21 @@
  * when registering the adapter manually or when implementing a custom
  * `SystemModelRuntime`; most browser apps should pass `systemModel` to
  * `createIndeRunWeb` from the main entry point instead.
+ *
+ * "System model" means a model the browser itself manages, so availability is a
+ * richer answer than a boolean: it may be present, downloadable, mid-download, or
+ * blocked for a browser, device, or policy reason. The provider flattens every
+ * non-available state into one route rejection and carries the detail as text.
  */
+/** The adapter itself, plus the default id the router plans against. */
 export { DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID, SystemModelWebProvider, type SystemModelProviderOptions } from "./providers/system-model/provider.js";
+/**
+ * The runtime seam. The provider delegates generation to a `SystemModelRuntime`,
+ * so an app can target a different browser API, or use
+ * `createFixtureSystemModelRuntime()` in demos and tests where no system model
+ * exists.
+ */
 export { SystemModelRuntimeError, createFixtureSystemModelRuntime, type FixtureSystemModelRuntimeOptions, type SystemModelAvailability, type SystemModelAvailabilityKind, type SystemModelGenerationInput, type SystemModelGenerationOutput, type SystemModelPromptMessage, type SystemModelRuntime, type SystemModelRuntimeErrorKind } from "./providers/system-model/runtime.js";
+/** The default runtime, backed by Chrome's built-in Prompt API. */
 export { createChromePromptApiRuntime, type ChromePromptApiGenerationOptions, type ChromePromptApiRuntimeOptions, type PromptApiLanguageModel, type PromptApiSession } from "./providers/system-model/chrome-runtime.js";
 //# sourceMappingURL=system-model.d.ts.map

package/dist/system-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-model.d.ts","sourceRoot":"","sources":["../src/system-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,oCAAoC,EACpC,sBAAsB,EACtB,KAAK,0BAA0B,EAChC,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EACjC,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,4BAA4B,EAC5B,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,4CAA4C,CAAC"}
+{"version":3,"file":"system-model.d.ts","sourceRoot":"","sources":["../src/system-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,wEAAwE;AACxE,OAAO,EACL,oCAAoC,EACpC,sBAAsB,EACtB,KAAK,0BAA0B,EAChC,MAAM,sCAAsC,CAAC;AAE9C;;;;;GAKG;AACH,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EACjC,MAAM,qCAAqC,CAAC;AAE7C,mEAAmE;AACnE,OAAO,EACL,4BAA4B,EAC5B,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,4CAA4C,CAAC"}

package/dist/system-model.js

@@ -6,7 +6,20 @@
  * when registering the adapter manually or when implementing a custom
  * `SystemModelRuntime`; most browser apps should pass `systemModel` to
  * `createIndeRunWeb` from the main entry point instead.
+ *
+ * "System model" means a model the browser itself manages, so availability is a
+ * richer answer than a boolean: it may be present, downloadable, mid-download, or
+ * blocked for a browser, device, or policy reason. The provider flattens every
+ * non-available state into one route rejection and carries the detail as text.
  */
+/** The adapter itself, plus the default id the router plans against. */
 export { DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID, SystemModelWebProvider } from "./providers/system-model/provider.js";
+/**
+ * The runtime seam. The provider delegates generation to a `SystemModelRuntime`,
+ * so an app can target a different browser API, or use
+ * `createFixtureSystemModelRuntime()` in demos and tests where no system model
+ * exists.
+ */
 export { SystemModelRuntimeError, createFixtureSystemModelRuntime } from "./providers/system-model/runtime.js";
+/** The default runtime, backed by Chrome's built-in Prompt API. */
 export { createChromePromptApiRuntime } from "./providers/system-model/chrome-runtime.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@independo/inderun-web",
-  "version": "0.3.0-dev.8",
-  "description": "TypeScript/Web SDK for IndeRun.",
+  "version": "0.3.0",
+  "description": "On-device AI with automatic cloud fallback for web apps. Runs ONNX Runtime or the Chrome Prompt API in the browser and falls back to an OpenAI-compatible endpoint, with streaming and cancellation behind one API.",
   "license": "MIT",
   "author": {
     "name": "Independo GmbH",
@@ -11,7 +11,7 @@
   "bugs": "https://github.com/independo-gmbh/inderun/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/independo-gmbh/inderun.git",
+    "url": "git+https://github.com/independo-gmbh/inderun.git",
     "directory": "packages/inderun-web"
   },
   "publishConfig": {
@@ -21,9 +21,19 @@
   "keywords": [
     "inderun",
     "ai",
+    "llm",
     "sdk",
     "web",
-    "llm",
+    "on-device",
+    "on-device-ai",
+    "local-llm",
+    "offline",
+    "cloud-fallback",
+    "streaming",
+    "onnx",
+    "onnxruntime",
+    "prompt-api",
+    "openai",
     "routing"
   ],
   "engines": {
@@ -52,11 +62,14 @@
   },
   "files": [
     "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/test",
     "README.md"
   ],
   "dependencies": {
-    "@independo/inderun-contracts": "^0.3.0-dev.8",
-    "@independo/inderun-route-core-wasm": "^0.3.0-dev.8"
+    "@independo/inderun-contracts": "^0.3.0",
+    "@independo/inderun-route-core-wasm": "^0.3.0"
   },
   "peerDependencies": {
     "@huggingface/transformers": "^4.0.0"
@@ -67,12 +80,13 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.5.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.11"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "vitest run"
+    "test": "vitest run",
+    "verify:packaging": "publint && attw --pack . --profile esm-only"
   }
 }