@nice-code/action 0.6.2 → 0.6.3

package/build/devtools/browser/index.js

@@ -5516,6 +5516,7 @@ var PREFS_KEY = "__nice-action-devtools-prefs";
 var DOCKED_HEIGHT_DEFAULT = 320;
 var DOCKED_WIDTH_DEFAULT = 420;
 var DETAIL_RATIO_DEFAULT = 0.5;
+var SANS_FONT2 = "ui-sans-serif, system-ui, sans-serif";
 var DOCK_POSITIONS = ["dock-bottom", "dock-top", "dock-left", "dock-right"];
 function isDockPosition(value) {
   return typeof value === "string" && DOCK_POSITIONS.includes(value);
@@ -5526,7 +5527,9 @@ function readPrefs(defaultPosition, initialOpen) {
     isOpen: initialOpen,
     dockedHeight: DOCKED_HEIGHT_DEFAULT,
     dockedWidth: DOCKED_WIDTH_DEFAULT,
-    detailRatio: DETAIL_RATIO_DEFAULT
+    detailRatio: DETAIL_RATIO_DEFAULT,
+    stayOnLatest: true,
+    followLatestOnSelect: true
   };
   try {
     if (typeof localStorage === "undefined")
@@ -5555,15 +5558,23 @@ function getHandlerKey(entry) {
     return "local";
   return `ext:${hop.transport ?? "ext"}`;
 }
+function entriesShareActionInput(a, b) {
+  if (a.actionId !== b.actionId || a.domain !== b.domain)
+    return false;
+  return a.inputHash != null && b.inputHash != null ? a.inputHash === b.inputHash : safeStringify(a.input, 0) === safeStringify(b.input, 0);
+}
 function canGroupWith(a, b) {
-  if (a.status === "running" || b.status === "running")
+  if (!entriesShareActionInput(a, b))
     return false;
   const handlerA = getHandlerKey(a);
   const handlerB = getHandlerKey(b);
   const handlerConflict = handlerA !== "none" && handlerB !== "none" && handlerA !== handlerB;
-  const inputMatch = a.inputHash != null && b.inputHash != null ? a.inputHash === b.inputHash : safeStringify(a.input, 0) === safeStringify(b.input, 0);
+  if (handlerConflict)
+    return false;
+  if (a.status === "running" || b.status === "running")
+    return true;
   const outputMatch = a.outputHash != null && b.outputHash != null ? a.outputHash === b.outputHash : true;
-  return a.actionId === b.actionId && a.domain === b.domain && a.status === b.status && !handlerConflict && inputMatch && outputMatch;
+  return a.status === b.status && outputMatch;
 }
 function groupEntries(entries) {
   const groups = [];
@@ -5596,7 +5607,7 @@ function NiceActionDevtools_Panel({
   useEffect4(() => core.subscribe(setEntries), [core]);
   const groups = useMemo3(() => {
     const byCuid = new Map(entries.map((e) => [e.cuid, e]));
-    const roots = entries.filter((e) => e.status !== "running" && (e.parentCuid == null || !byCuid.has(e.parentCuid)));
+    const roots = entries.filter((e) => e.parentCuid == null || !byCuid.has(e.parentCuid));
     return groupEntries(roots);
   }, [entries]);
   const childEntriesMap = useMemo3(() => {
@@ -5612,16 +5623,6 @@ function NiceActionDevtools_Panel({
     }
     return map;
   }, [entries]);
-  const handleGroupRowClick = (group) => {
-    const repCuid = group.representative.cuid;
-    const allInGroup = [group.representative, ...group.rest];
-    const selectedInGroup = allInGroup.find((e) => e.cuid === selectedCuid) ?? null;
-    if (selectedInGroup != null && selectedCuid !== repCuid) {
-      setSelectedCuid(repCuid);
-    } else {
-      setSelectedCuid(selectedCuid === repCuid ? null : repCuid);
-    }
-  };
   const setPrefs = (update) => {
     setPrefsRaw((prev) => ({ ...prev, ...update }));
   };
@@ -5629,10 +5630,34 @@ function NiceActionDevtools_Panel({
     const timer = setTimeout(() => writePrefs(prefs), 250);
     return () => clearTimeout(timer);
   }, [prefs]);
-  const { position, isOpen, dockedHeight, dockedWidth, detailRatio } = prefs;
+  const { position, isOpen, dockedHeight, dockedWidth, detailRatio, stayOnLatest, followLatestOnSelect } = prefs;
   const dockSide = getDockSide(position);
   const isHorizDock = dockSide === "top" || dockSide === "bottom";
   const dockedSize = isHorizDock ? dockedHeight : dockedWidth;
+  const latestCuid = groups.length > 0 ? groups[0].representative.cuid : null;
+  useEffect4(() => {
+    if (stayOnLatest && latestCuid != null)
+      setSelectedCuid(latestCuid);
+  }, [stayOnLatest, latestCuid]);
+  const applySelection = (next) => {
+    if (next != null && next === latestCuid && followLatestOnSelect) {
+      if (!stayOnLatest)
+        setPrefs({ stayOnLatest: true });
+    } else if (stayOnLatest) {
+      setPrefs({ stayOnLatest: false });
+    }
+    setSelectedCuid(next);
+  };
+  const handleGroupRowClick = (group) => {
+    const repCuid = group.representative.cuid;
+    const allInGroup = [group.representative, ...group.rest];
+    const selectedInGroup = allInGroup.find((e) => e.cuid === selectedCuid) ?? null;
+    if (selectedInGroup != null && selectedCuid !== repCuid) {
+      applySelection(repCuid);
+    } else {
+      applySelection(selectedCuid === repCuid ? null : repCuid);
+    }
+  };
   const selectedEntry = selectedCuid != null ? entries.find((e) => e.cuid === selectedCuid) : null;
   const runningCount = entries.filter((e) => e.status === "running").length;
   const dock = useMemo3(() => getDevtoolsDockCoordinator(), []);
@@ -5716,7 +5741,7 @@ function NiceActionDevtools_Panel({
     selectedCuid,
     onGroupClick: handleGroupRowClick,
     onSubClick: (cuid, isSelected) => {
-      setSelectedCuid(isSelected ? null : cuid);
+      applySelection(isSelected ? null : cuid);
     },
     childEntriesMap
   };
@@ -5748,18 +5773,35 @@ function NiceActionDevtools_Panel({
           minHeight: 0
         },
         children: [
-          /* @__PURE__ */ jsx23("div", {
+          /* @__PURE__ */ jsxs20("div", {
             style: {
               flexGrow: selectedEntry != null ? 1 - detailRatio : 1,
               flexShrink: 1,
               flexBasis: 0,
               minWidth: 0,
-              minHeight: 0
+              minHeight: 0,
+              display: "flex",
+              flexDirection: "column",
+              overflow: "hidden"
             },
-            children: /* @__PURE__ */ jsx23(ActionList, {
-              ...virtualListProps,
-              style: { width: "100%", height: "100%", overflowY: "auto" }
-            })
+            children: [
+              /* @__PURE__ */ jsx23(FollowToggles, {
+                stayOnLatest,
+                onStayOnLatestChange: (next) => setPrefs({ stayOnLatest: next }),
+                followLatestOnSelect,
+                onFollowLatestOnSelectChange: (next) => {
+                  if (next && latestCuid != null && selectedCuid === latestCuid && !stayOnLatest) {
+                    setPrefs({ followLatestOnSelect: next, stayOnLatest: true });
+                  } else {
+                    setPrefs({ followLatestOnSelect: next });
+                  }
+                }
+              }),
+              /* @__PURE__ */ jsx23(ActionList, {
+                ...virtualListProps,
+                style: { width: "100%", flex: 1, minHeight: 0, overflowY: "auto" }
+              })
+            ]
           }),
           selectedEntry != null && /* @__PURE__ */ jsxs20(Fragment11, {
             children: [
@@ -5799,6 +5841,82 @@ function NiceActionDevtools_Panel({
     ]
   });
 }
+function FollowToggles({
+  stayOnLatest,
+  onStayOnLatestChange,
+  followLatestOnSelect,
+  onFollowLatestOnSelectChange
+}) {
+  return /* @__PURE__ */ jsxs20("div", {
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      flexShrink: 0,
+      paddingBottom: "3px",
+      background: DEVTOOL_SECTION_BACKGROUND,
+      borderBottom: `1px solid ${DEVTOOL_LIST_BASE_BACKGROUND}`
+    },
+    children: [
+      /* @__PURE__ */ jsx23(ToggleLabel, {
+        title: "Auto-select the most recent action so the detail pane keeps showing the latest as new actions land",
+        checked: stayOnLatest,
+        onChange: onStayOnLatestChange,
+        children: "Follow latest"
+      }),
+      /* @__PURE__ */ jsxs20("div", {
+        style: { display: "flex", alignItems: "center", paddingLeft: "12px", marginTop: "-4px" },
+        children: [
+          /* @__PURE__ */ jsx23("span", {
+            "aria-hidden": true,
+            style: {
+              color: DEVTOOL_COLOR_TEXT_MUTED,
+              fontFamily: SANS_FONT2,
+              fontSize: "10px",
+              lineHeight: 1
+            },
+            children: "└"
+          }),
+          /* @__PURE__ */ jsx23(ToggleLabel, {
+            title: "When you click the latest action, turn 'Follow latest' back on so the view resumes tracking new actions. Turn this off to pin exactly to the action you click instead.",
+            checked: followLatestOnSelect,
+            onChange: onFollowLatestOnSelectChange,
+            children: "clicking latest re-follows"
+          })
+        ]
+      })
+    ]
+  });
+}
+function ToggleLabel({
+  checked,
+  onChange,
+  title,
+  children
+}) {
+  return /* @__PURE__ */ jsxs20("label", {
+    title,
+    style: {
+      display: "flex",
+      alignItems: "center",
+      gap: "6px",
+      padding: "5px 10px",
+      cursor: "pointer",
+      userSelect: "none",
+      color: checked ? DEVTOOL_COLOR_TEXT_SECONDARY : DEVTOOL_COLOR_TEXT_MUTED,
+      fontSize: "10px",
+      fontFamily: SANS_FONT2
+    },
+    children: [
+      /* @__PURE__ */ jsx23("input", {
+        type: "checkbox",
+        checked,
+        onChange: (e) => onChange(e.target.checked),
+        style: { accentColor: DEVTOOL_COLOR_SEMANTIC_SYSTEM, cursor: "pointer", margin: 0 }
+      }),
+      children
+    ]
+  });
+}
 export {
   NiceActionDevtools,
   ActionDevtoolsCore

package/build/index.js

@@ -1803,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);
@@ -1826,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);
@@ -1856,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)
@@ -1869,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);
   }
 }
 
@@ -1935,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,
@@ -1956,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/action",
-  "version": "0.6.2",
+  "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.2",
-    "@nice-code/error": "0.6.2",
-    "@nice-code/util": "0.6.2",
+    "@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",