@jsenv/navi 0.29.309 → 0.29.311

package/dist/dev/jsenv_navi.js

@@ -2866,7 +2866,17 @@ const updateActions = ({
    * - willRunSet: actions that will be run
    * - willPromoteSet: prerun actions that become run-requested
    * - stays*Set: actions that remain in their current state
+   *
+   * A proxy in any of the sets stands for the action it currently targets,
+   * exactly as proxy.run()/rerun()/reset() do: what enters activationWeakSet
+   * is always the target. A proxy kept in there would retarget on its own —
+   * to a never-run child once its params go falsy — and getActivationInfo
+   * would then meet an IDLE member on every later update of the document.
    */
+  prerunSet = resolveActionProxies(prerunSet);
+  runSet = resolveActionProxies(runSet);
+  rerunSet = resolveActionProxies(rerunSet);
+  resetSet = resolveActionProxies(resetSet);
 
   const { runningSet, settledSet } = getActivationInfo();
 
@@ -3088,13 +3098,6 @@ ${lines.join("\n")}`);
   // Step 5: Execute preruns and runs
   {
     const onActionToRunOrPrerun = (actionToPrerunOrRun, isPrerun) => {
-      if (actionToPrerunOrRun.isProxy) {
-        // maybe remove this check once the API is stable because
-        // nothing in the API should allow this to happen
-        throw new Error(
-          `Proxy should not be reach this point, use the underlying action instead`,
-        );
-      }
       const actionSpecificSignal = abortSignalMap.get(actionToPrerunOrRun);
       const effectiveSignal = actionSpecificSignal || abortSignal;
 
@@ -3222,6 +3225,14 @@ ${lines.join("\n")}`);
   };
 };
 
+const resolveActionProxies = (actionSet) => {
+  const resolvedSet = new Set();
+  for (const action of actionSet) {
+    resolvedSet.add(action.isProxy ? action.getCurrentAction() : action);
+  }
+  return resolvedSet;
+};
+
 const NO_PARAMS = { __no_params__: true };
 const mergeActionParams = (currentParams, newParams) => {
   // The order of these two checks is load-bearing. Checking `undefined` first
@@ -26281,6 +26292,22 @@ This prevents cross-test pollution and ensures clean state.`,
             // URL is the source of truth for explicit parameters
             const value = paramSignal.peek();
             if (urlParamValue === undefined) {
+              // An address silent about a persisted search param leaves it
+              // alone: the state already holds what is stored (it starts from
+              // storage and every write goes back to it), and a reset here
+              // would empty the storage as well. Reading the storage back is
+              // not an option either: the write that removes the param from
+              // the address is the one emptying its storage, and this sync can
+              // run before that removal has happened.
+              // A path segment or a pushed param names a place, and an address
+              // without it is the place without it: those follow the address.
+              if (
+                connection.persists &&
+                connection.paramType === "query" &&
+                connection.history !== "push"
+              ) {
+                continue;
+              }
               // No URL parameter - reset signal to its current default value
               // (handles both static fallback and dynamic default cases)
               const defaultValue = connection.getDefaultValue();