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

package/dist/core/engine.d.ts

@@ -27,6 +27,17 @@ export declare class IndeRun implements IndeRunApi {
      * @param telemetryService - Optional custom telemetry service listener.
      */
     constructor(registry: ProviderRegistry, hostServices: HostServices, telemetryService?: TelemetryService);
+    /**
+     * Current time from the host clock, falling back to wall-clock time when the
+     * host does not supply one.
+     */
+    private now;
+    /**
+     * Emits `route_decided` for a completed route selection. Shared by `run()` and
+     * `stream()`: the payload is identical for both modes, and the interaction
+     * mode is already reflected in the plan the router returned.
+     */
+    private emitRouteDecided;
     /**
      * Safely emits a telemetry event by swallowing any internal logging/telemetry system errors.
      * @param event - The telemetry event to emit.

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

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAmB,0BAA0B,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAQjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAGlG;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAE3C;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,UAAU;IAWtC,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;;;;;;;;;;;;;;;;;OAiBG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IA+QtD;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAmB,0BAA0B,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAQjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAGlG;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAE3C;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,UAAU;IAWtC,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,GAAG;IAIX;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;;OAOG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAsHpD;;;;;;;;;;;;;;;;;OAiBG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IA+PtD;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}

package/dist/core/engine.js

@@ -27,6 +27,35 @@ export class IndeRun {
         this.telemetryService =
             telemetryService || this.hostServices.telemetry || new NoOpTelemetryService();
     }
+    /**
+     * Current time from the host clock, falling back to wall-clock time when the
+     * host does not supply one.
+     */
+    now() {
+        return this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+    }
+    /**
+     * Emits `route_decided` for a completed route selection. Shared by `run()` and
+     * `stream()`: the payload is identical for both modes, and the interaction
+     * mode is already reflected in the plan the router returned.
+     */
+    emitRouteDecided(runId, request, routeSelection, providerCount) {
+        this.safeEmit({
+            type: "route_decided",
+            runId,
+            timestamp: this.now(),
+            payload: {
+                selectedProviderId: routeSelection.routePlan.selectedProviderId,
+                fallbackProviderIds: routeSelection.routePlan.fallbackProviderIds,
+                rejectedProviders: routeSelection.routePlan.rejectedProviders,
+                fallbackAvailable: providerCount > 1,
+                taskKind: request.task.kind,
+                constraints: request.constraints ?? null,
+                preferences: request.preferences ?? null,
+                explanation: routeSelection.explanation
+            }
+        });
+    }
     /**
      * Safely emits a telemetry event by swallowing any internal logging/telemetry system errors.
      * @param event - The telemetry event to emit.
@@ -72,7 +101,7 @@ export class IndeRun {
      * @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 startTime = this.now();
         const runId = request.requestId || `run_${Math.random().toString(36).substring(2, 11)}`;
         try {
             // 1. Validate request payload using schema contracts
@@ -89,24 +118,7 @@ export class IndeRun {
             // 2. Select the route based on constraints and host capabilities
             const routeSelection = await this.router.selectRoute(request, this.hostServices, "run");
             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,
-                    plannerSource: routeSelection.plannerSource,
-                    plannerUnavailableReason: routeSelection.plannerUnavailableReason ?? null
-                }
-            });
+            this.emitRouteDecided(runId, request, routeSelection, providers.length);
             // 3. Execute the run task using the planned provider chain
             const attemptedProviderIds = [];
             let lastError;
@@ -118,7 +130,7 @@ export class IndeRun {
                         runId,
                         hostServices: this.hostServices
                     });
-                    const endTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+                    const endTime = this.now();
                     const totalMs = endTime - startTime;
                     result.runId = runId;
                     result.telemetry = {
@@ -151,7 +163,7 @@ export class IndeRun {
                     });
                 }
             }
-            const endTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+            const endTime = this.now();
             const totalMs = endTime - startTime;
             const exception = toIndeRunException(lastError ?? new Error("No providers were attempted."), {
                 runId,
@@ -170,10 +182,10 @@ export class IndeRun {
                 details: {
                     totalMs: typeof error.details?.totalMs === "number"
                         ? error.details?.totalMs
-                        : (this.hostServices.clock ? this.hostServices.clock.now() : Date.now()) - startTime
+                        : this.now() - startTime
                 }
             });
-            const endTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
+            const endTime = this.now();
             const totalMs = typeof exception.details?.totalMs === "number"
                 ? exception.details?.totalMs
                 : endTime - startTime;
@@ -210,8 +222,8 @@ export class IndeRun {
      * @throws {IndeRunException} If validation fails or no eligible streaming provider exists.
      */
     async stream(request) {
-        const startTime = this.hostServices.clock ? this.hostServices.clock.now() : Date.now();
-        const now = () => (this.hostServices.clock ? this.hostServices.clock.now() : Date.now());
+        const startTime = this.now();
+        const now = () => this.now();
         const runId = request.requestId || `run_${Math.random().toString(36).substring(2, 11)}`;
         const validationIssues = getTaskRequestValidationIssues(request);
         if (validationIssues.length > 0) {
@@ -231,23 +243,7 @@ export class IndeRun {
             throw toIndeRunException(error, { runId });
         }
         const providers = [routeSelection.provider, ...routeSelection.fallbackProviders];
-        this.safeEmit({
-            type: "route_decided",
-            runId,
-            timestamp: 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,
-                plannerSource: routeSelection.plannerSource,
-                plannerUnavailableReason: routeSelection.plannerUnavailableReason ?? null
-            }
-        });
+        this.emitRouteDecided(runId, request, routeSelection, providers.length);
         // Defensive only: streaming eligibility is decided by the route planner, which
         // throws with its own rejection reasons when nothing can stream. Reaching here
         // means a planned provider was unregistered between planning and selection.

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

@@ -17,25 +17,23 @@ export interface SharedPlannerModule {
     planRouteJson: (inputJson: string) => string | Promise<string>;
 }
 /**
- * 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.
+ * Coarse, privacy-safe reason the WASM planner produced no route plan. Surfaced
+ * on the resulting `Internal` routing error and in the `console.warn`, so an
+ * operator can tell a missing bundle chunk from a blocked instantiation.
  */
 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.
+ * planner could not produce a plan, and `unavailableReason` then narrows down
+ * why.
  */
 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).
+ * "unavailable" outcome (which the router reports as a routing failure).
  */
 export interface RoutePlanner {
     planRoute(input: SharedPlannerInput): Promise<PlannerOutcome>;
@@ -55,13 +53,14 @@ export interface ProviderRuntimeSnapshot {
  * 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.
+ * be loaded, `planRoute` resolves an "unavailable" outcome, which the engine
+ * turns into an `Internal` routing failure carrying the reason below. There is
+ * no second planner to degrade to — a failure here is a failure to route, not a
+ * quieter route — so this also logs once via `console.warn` to name the cause.
  */
 export declare class WasmRoutePlanner implements RoutePlanner {
     private modulePromise?;
-    private loadFailureReason?;
+    private loadFailure?;
     private hasWarned;
     planRoute(input: SharedPlannerInput): Promise<PlannerOutcome>;
     private loadModule;
@@ -70,7 +69,11 @@ export declare class WasmRoutePlanner implements RoutePlanner {
 }
 /**
  * Describes each provider and evaluates its dynamic capabilities against the
- * host, returning snapshots sorted by provider id for deterministic planning.
+ * host.
+ *
+ * Registration order is passed through untouched: the shared planner ranks
+ * candidates itself and tie-breaks by provider id, so sorting here would only
+ * assert an ordering the planner is free to ignore.
  */
 export declare function collectProviderRuntimeSnapshots(registryProviders: ProviderAdapter[], hostServices: HostServices): Promise<ProviderRuntimeSnapshot[]>;
 /**

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

@@ -1 +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;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAEjF;;;;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,EACtB,eAAe,GAAE,eAAuB,GACvC,kBAAkB,CAuBpB"}
+{"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;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAEjF;;;;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;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACzC,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;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACnD,OAAO,CAAC,aAAa,CAAC,CAAsC;IAC5D,OAAO,CAAC,WAAW,CAAC,CAAqD;IACzE,OAAO,CAAC,SAAS,CAAS;IAEpB,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;YAoBrD,UAAU;YAOV,YAAY;IA0B1B,OAAO,CAAC,QAAQ;CAOjB;AAED;;;;;;;GAOG;AACH,wBAAsB,+BAA+B,CACnD,iBAAiB,EAAE,eAAe,EAAE,EACpC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAapC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,uBAAuB,EAAE,EACpC,aAAa,EAAE,OAAO,EACtB,eAAe,GAAE,eAAuB,GACvC,kBAAkB,CAuBpB"}

package/dist/core/route-planner.js

@@ -4,29 +4,32 @@
  * 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.
+ * be loaded, `planRoute` resolves an "unavailable" outcome, which the engine
+ * turns into an `Internal` routing failure carrying the reason below. There is
+ * no second planner to degrade to — a failure here is a failure to route, not a
+ * quieter route — so this also logs once via `console.warn` to name the cause.
  */
 export class WasmRoutePlanner {
     modulePromise;
-    loadFailureReason;
+    loadFailure;
     hasWarned = false;
     async planRoute(input) {
         const module = await this.loadModule();
         if (!module) {
-            const unavailableReason = this.loadFailureReason ?? "import_failed";
-            this.warnOnce(unavailableReason);
-            return { routePlan: null, source: "unavailable", unavailableReason };
+            // The load path only records why it failed; warning here covers both the
+            // first attempt and every later call served from the memoized promise.
+            const unavailableReason = this.loadFailure?.reason ?? "import_failed";
+            this.warnOnce(unavailableReason, this.loadFailure?.error);
+            return { routePlan: null, unavailableReason };
         }
         try {
             const json = JSON.stringify(input);
             const result = await module.planRouteJson(json);
-            return { routePlan: JSON.parse(result), source: "wasm" };
+            return { routePlan: JSON.parse(result) };
         }
         catch (error) {
             this.warnOnce("plan_failed", error);
-            return { routePlan: null, source: "unavailable", unavailableReason: "plan_failed" };
+            return { routePlan: null, unavailableReason: "plan_failed" };
         }
     }
     async loadModule() {
@@ -41,13 +44,11 @@ export class WasmRoutePlanner {
             mod = (await import("@independo/inderun-route-core-wasm"));
         }
         catch (error) {
-            this.loadFailureReason = "import_failed";
-            this.warnOnce("import_failed", error);
+            this.loadFailure = { reason: "import_failed", error };
             return null;
         }
         if (typeof mod.planRouteJson !== "function") {
-            this.loadFailureReason = "invalid_module_shape";
-            this.warnOnce("invalid_module_shape");
+            this.loadFailure = { reason: "invalid_module_shape" };
             return null;
         }
         if (mod.initSharedCore) {
@@ -55,8 +56,7 @@ export class WasmRoutePlanner {
                 await mod.initSharedCore();
             }
             catch (error) {
-                this.loadFailureReason = "init_failed";
-                this.warnOnce("init_failed", error);
+                this.loadFailure = { reason: "init_failed", error };
                 return null;
             }
         }
@@ -67,15 +67,19 @@ export class WasmRoutePlanner {
             return;
         }
         this.hasWarned = true;
-        console.warn(`[IndeRun] WASM route planner unavailable (${reason}); falling back to local route selection.`, error);
+        console.warn(`[IndeRun] WASM route planner unavailable (${reason}); routing will fail.`, error);
     }
 }
 /**
  * Describes each provider and evaluates its dynamic capabilities against the
- * host, returning snapshots sorted by provider id for deterministic planning.
+ * host.
+ *
+ * Registration order is passed through untouched: the shared planner ranks
+ * candidates itself and tie-breaks by provider id, so sorting here would only
+ * assert an ordering the planner is free to ignore.
  */
 export async function collectProviderRuntimeSnapshots(registryProviders, hostServices) {
-    const snapshots = await Promise.all(registryProviders.map(async (provider) => {
+    return Promise.all(registryProviders.map(async (provider) => {
         const descriptor = provider.describe();
         const capabilities = await provider.capabilities(hostServices);
         return {
@@ -84,7 +88,6 @@ export async function collectProviderRuntimeSnapshots(registryProviders, hostSer
             capabilities: toSharedPlannerCapabilities(capabilities, descriptor, provider)
         };
     }));
-    return snapshots.sort((left, right) => left.descriptor.id.localeCompare(right.descriptor.id));
 }
 /**
  * Assembles the normalized {@link SharedPlannerInput} the shared route core

package/dist/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 InteractionMode, type RoutePlanner, type SharedPlannerRoutePlan, type WasmUnavailableReason } from "./route-planner.js";
+import { type InteractionMode, type RoutePlanner, type SharedPlannerRoutePlan } from "./route-planner.js";
 /**
  * Output structure from the Router containing the chosen provider and a route selection description.
  */
@@ -23,16 +23,6 @@ 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,
@@ -59,35 +49,7 @@ export declare class Router {
      */
     selectRoute(request: TaskRequest, hostServices: HostServices, interactionMode?: InteractionMode): Promise<RouteSelection>;
     private selectFromSharedPlan;
-    private selectFallbackRoute;
     private buildSelectionFromRoutePlan;
-    /**
-     * 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.
-     */
-    private createFallbackPlan;
-    /**
-     * 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.
-     */
-    private inferFallbackFailureCode;
-    /**
-     * 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.
-     */
-    private evaluateFallbackCandidate;
-    private buildFallbackFailureSummary;
     /**
      * 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/core/router.d.ts.map

@@ -1 +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,EAGL,KAAK,eAAe,EAEpB,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;;;;;;;;;;;;;OAaG;IACG,WAAW,CACf,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAuB,GACvC,OAAO,CAAC,cAAc,CAAC;IAoB1B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,2BAA2B;IA2BnC;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAwE1B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IA4FjC,OAAO,CAAC,2BAA2B;IAyCnC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAkBzB"}
+{"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,EAGL,KAAK,eAAe,EAEpB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAE5B,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;CACrB;AAED;;;;GAIG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;gBADP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAqC;IAGxD;;;;;;;;;;;;;OAaG;IACG,WAAW,CACf,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAuB,GACvC,OAAO,CAAC,cAAc,CAAC;IAoB1B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,2BAA2B;IAuBnC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAkBzB"}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@independo/inderun-web",
-  "version": "0.3.0-dev.8",
+  "version": "0.3.0-dev.9",
   "description": "TypeScript/Web SDK for IndeRun.",
   "license": "MIT",
   "author": {
@@ -55,8 +55,8 @@
     "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-dev.9",
+    "@independo/inderun-route-core-wasm": "^0.3.0-dev.9"
   },
   "peerDependencies": {
     "@huggingface/transformers": "^4.0.0"