@nice-code/action 0.6.1 → 0.6.3

package/build/index.js

@@ -965,6 +965,7 @@ class ActionRuntime {
   }
   async handleActionPayload(action, options) {
     if (action.type === "request" /* request */) {
+      const observers = action.context._domain._collectActionObservers();
       let handlerForAction;
       try {
         handlerForAction = this.getHandlerForActionOrThrow(action, options);
@@ -973,6 +974,7 @@ class ActionRuntime {
           context: action.context,
           request: action
         });
+        runningAction2.addUpdateListeners(observers);
         runningAction2._completeWithResult(action.errorResult(castNiceError(err2)));
         return runningAction2;
       }
@@ -980,6 +982,7 @@ class ActionRuntime {
         ...options,
         targetLocalRuntime: this
       });
+      runningAction.addUpdateListeners(observers);
       this._trySetupReturnDispatch(runningAction);
       return runningAction;
     }
@@ -1293,6 +1296,9 @@ class ActionDomainBase {
       this._listeners = this._listeners.filter((l) => l !== listener);
     };
   }
+  _getActionObservers() {
+    return this._listeners;
+  }
 }
 
 // src/ActionDefinition/Domain/ActionDomain.ts
@@ -1309,6 +1315,9 @@ class ActionDomain extends ActionDomainBase {
   get rootDomain() {
     return this._rootDomain;
   }
+  _collectActionObservers() {
+    return [...this._rootDomain._getActionObservers(), ...this._getActionObservers()];
+  }
   _registerRuntime(runtime2) {
     this._rootDomain._registerRuntime(runtime2);
   }
@@ -1794,20 +1803,24 @@ class ConnectionTransportManager {
   addTransport(transport) {
     this._transports.push(transport);
   }
+  getPreferredTransport() {
+    return this._transports[0];
+  }
   async getReadyTransport(routeActionParams) {
-    const initializingWaiters = [];
-    const unavailableTransports = [];
     const action = routeActionParams.action;
+    const candidates = [];
+    const unavailableTransports = [];
     for (const transport of this._transports) {
       const cacheKey = transport.getCacheKey(routeActionParams);
       if (cacheKey != null) {
         const cached = this._cache.get(cacheKey);
         if (cached != null) {
           if (cached instanceof Promise) {
-            initializingWaiters.push(cached);
+            candidates.push(cached);
             continue;
           }
-          return { ...cached, transport };
+          candidates.push(Promise.resolve({ ...cached, transport }));
+          break;
         }
       }
       const statusInfo = transport.getTransport(routeActionParams);
@@ -1817,7 +1830,8 @@ class ConnectionTransportManager {
           this._cache.set(cacheKey, { methods: readyData, transport });
           readyData.addOnDisconnectListener?.(() => this._cache.delete(cacheKey));
         }
-        return { methods: readyData, transport };
+        candidates.push(Promise.resolve({ methods: readyData, transport }));
+        break;
       }
       if (statusInfo.status === "unsupported" /* unsupported */) {
         unavailableTransports.push(transport);
@@ -1847,10 +1861,10 @@ class ConnectionTransportManager {
         if (cacheKey != null) {
           this._cache.set(cacheKey, promise);
         }
-        initializingWaiters.push(promise);
+        candidates.push(promise);
       }
     }
-    if (initializingWaiters.length === 0) {
+    if (candidates.length === 0) {
       if (unavailableTransports.length > 0) {
         throw err_nice_transport.fromId("unsupported" /* unsupported */, {
           transportTypes: unavailableTransports.map((t) => t.type)
@@ -1860,13 +1874,17 @@ class ConnectionTransportManager {
         actionId: action.id
       });
     }
-    try {
-      return await Promise.any(initializingWaiters).then();
-    } catch (e) {
-      throw err_nice_transport.fromId("initialization_failed" /* initialization_failed */, {
-        actionId: action.id
-      }).withOriginError(e);
+    let lastError;
+    for (const candidate of candidates) {
+      try {
+        return await candidate;
+      } catch (e) {
+        lastError = e;
+      }
     }
+    throw err_nice_transport.fromId("initialization_failed" /* initialization_failed */, {
+      actionId: action.id
+    }).withOriginError(lastError);
   }
 }
 
@@ -1926,20 +1944,19 @@ class ActionExternalClientHandler extends ActionHandler {
     const incomingTimeout = config?.timeout ?? this._defaultTimeout;
     const parentCuid = peekHandlerCuid();
     const callSite = action._callSite ?? new Error().stack;
-    const { methods, transport } = await this.transportManager.getReadyTransport({
+    const routeParams = {
       action,
       localClient,
       externalClient: this.externalClient
-    });
-    action.context.addRouteItem({
+    };
+    const preferredTransport = this.transportManager.getPreferredTransport();
+    const routeItem = preferredTransport != null ? {
       runtime: localClient,
-      handler: this.toHandlerRouteItem(transport, {
-        action,
-        localClient,
-        externalClient: this.externalClient
-      }),
+      handler: this.toHandlerRouteItem(preferredTransport, routeParams),
       time: Date.now()
-    });
+    } : undefined;
+    if (routeItem != null)
+      action.context.addRouteItem(routeItem);
     const runningAction = new RunningAction({
       context: action.context,
       request: action,
@@ -1947,23 +1964,37 @@ class ActionExternalClientHandler extends ActionHandler {
       callSite
     });
     localRuntime.registerRunningAction(runningAction);
-    const routeActionParams = {
-      action,
-      runningAction,
-      localClient,
-      externalClient: this.externalClient,
-      timeout: incomingTimeout
-    };
-    if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
-      const runConfig = methods.updateRunConfig(routeActionParams);
-      routeActionParams.timeout = runConfig?.timeout ?? incomingTimeout;
-    }
+    this._dispatchWhenTransportReady(runningAction, routeParams, routeItem, incomingTimeout);
+    return runningAction;
+  }
+  async _dispatchWhenTransportReady(runningAction, routeParams, routeItem, incomingTimeout) {
+    const action = routeParams.action;
     try {
-      methods.sendActionData(routeActionParams);
+      const { methods, transport } = await this.transportManager.getReadyTransport(routeParams);
+      const handlerRouteItem = this.toHandlerRouteItem(transport, routeParams);
+      if (routeItem != null) {
+        routeItem.handler = handlerRouteItem;
+        routeItem.time = Date.now();
+      } else {
+        action.context.addRouteItem({
+          runtime: routeParams.localClient,
+          handler: handlerRouteItem,
+          time: Date.now()
+        });
+      }
+      const sendInput = {
+        ...routeParams,
+        runningAction,
+        timeout: incomingTimeout
+      };
+      if (action.type === "request" /* request */ && methods.updateRunConfig != null) {
+        const runConfig = methods.updateRunConfig(sendInput);
+        sendInput.timeout = runConfig?.timeout ?? incomingTimeout;
+      }
+      methods.sendActionData(sendInput);
     } catch (err3) {
       runningAction._abort(err3);
     }
-    return runningAction;
   }
   async sendReturnPayload(payload, config) {
     const localClient = config.targetLocalRuntime.coordinate;

package/build/types/ActionRuntime/Handler/ExternalClient/ActionExternalClientHandler.d.ts

@@ -27,6 +27,7 @@ export declare class ActionExternalClientHandler extends ActionHandler<EActionHa
     forActionIds<ACT_DOM extends IActionDomain, IDS extends ReadonlyArray<keyof ACT_DOM["actionSchema"] & string>>(domain: ActionDomain<ACT_DOM>, ids: IDS): this;
     _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any, any>) => void): void;
     handleActionRequest<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(action: ActionPayload_Request<DOM, ID>, config?: IHandleActionOptions): Promise<RunningAction<DOM, ID>>;
+    private _dispatchWhenTransportReady;
     /**
      * Dispatch a result or progress payload directly back to the external client via the best
      * available bidirectional transport (WebSocket / Custom). Used for return-path routing when the

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/ConnectionTransportManager.d.ts

@@ -5,5 +5,12 @@ export declare class ConnectionTransportManager {
     private _transports;
     constructor(_cache: TTransportCache);
     addTransport(transport: TransportConnection): void;
+    /**
+     * The highest-priority transport (first declared). Used to label an action's route *before* the
+     * transport has finished connecting — so a still-connecting action shows its (expected) destination
+     * instead of an "unknown" hop. {@link getReadyTransport} still decides the real winner, and the
+     * caller corrects the hop if a lower-priority transport ends up serving the action.
+     */
+    getPreferredTransport(): TransportConnection | undefined;
     getReadyTransport(routeActionParams: ITransportRouteActionParams): Promise<IActionTransportReady>;
 }

package/build/types/devtools/browser/components/OriginChip.d.ts

@@ -0,0 +1,15 @@
+import { ESize } from "../ui_util/size";
+/**
+ * Marks an action that was received from another runtime (a backend push, or an action relayed from
+ * another client) rather than dispatched locally. The chip shows the origin's `envId`; the tooltip
+ * carries the full coordinate. Render it only when {@link getInboundOrigin} returns a value.
+ */
+export declare function OriginChip({ origin, size, subtle, }: {
+    origin: {
+        envId: string;
+        perId?: string;
+        insId?: string;
+    };
+    size?: ESize;
+    subtle?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/build/types/devtools/browser/components/utils.d.ts

@@ -5,6 +5,17 @@ export declare const STATUS_COLOR: Record<TDevtoolsActionStatus, string>;
 export declare const STATUS_THING: Record<TDevtoolsActionStatus, ESemanticThing>;
 export declare const STATUS_SYMBOL: Record<TDevtoolsActionStatus, string>;
 export declare const STATUS_ICON: Record<TDevtoolsActionStatus, LucideIcon>;
+/**
+ * The runtime an action *originated* on, when that differs from the runtime that handled it — i.e. an
+ * inbound action received over a transport (a backend push, or an action relayed from another client),
+ * rather than one dispatched locally. Returns `null` for locally-originated actions (where the origin
+ * matches the handling runtime) and for actions with no known origin.
+ */
+export declare function getInboundOrigin(entry: IDevtoolsActionEntry): {
+    envId: string;
+    perId?: string;
+    insId?: string;
+} | null;
 export declare function safeStringify(value: unknown, indent?: number): string;
 export declare function formatRelativeAge(ms: number): string;
 export declare function formatDuration(entry: IDevtoolsActionEntry): string | null;

package/build/types/devtools/core/devtools_colors.d.ts

@@ -54,6 +54,7 @@ export declare enum ESemanticThing {
     domain = "domain",
     handler_local = "handler_local",
     handler_external = "handler_external",
+    origin = "origin",// runtime an action was received from (inbound / pushed actions)
     age = "age",// non-latest relative-age chip
     io_input = "io_input",
     io_output = "io_output",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/action",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "private": false,
   "type": "module",
   "exports": {
@@ -44,9 +44,9 @@
     "build-types": "tsc --project tsconfig.build.json"
   },
   "dependencies": {
-    "@nice-code/common-errors": "0.6.1",
-    "@nice-code/error": "0.6.1",
-    "@nice-code/util": "0.6.1",
+    "@nice-code/common-errors": "0.6.3",
+    "@nice-code/error": "0.6.3",
+    "@nice-code/util": "0.6.3",
     "@standard-schema/spec": "^1.1.0",
     "@tanstack/react-virtual": "^3.13.26",
     "http-status-codes": "^2.3.0",