Fix reactive dependencies not triggering when intermediate path appears (commontoolsinc#2160)

* Fix reactive dependencies not triggering when intermediate path appears

When watching a path like ["a", "b", "c"], the algorithm would not trigger
if an intermediate segment appeared. For example:

- Before: { a: {} } - path a.b.c is "unreachable" (b doesn't exist)
- After: { a: { b: { x: 1 } } } - b exists but c doesn't

Both cases resolve to `undefined`, so no change was detected. But this is
a structural change that should trigger subscribers, because the path
became "more reachable".

The fix distinguishes three cases:
1. Both paths reachable → compare actual values (original behavior)
2. Reachability changed → trigger (NEW)
3. Neither reachable but different traversal depth → trigger (NEW)

This fixes issues where handlers watching paths through dynamically
appearing keys (like internal.__#0.allCharms) would not fire on first load.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* Format pass

---------

Co-authored-by: Claude <[email protected]>
Co-authored-by: Ben Follington <[email protected]>

Author: 3 people

packages/runner/src/reactive-dependencies.ts

@@ -106,7 +106,6 @@ export function determineTriggeredActions(
       action,
       paths: paths.toReversed(),
     }));
-  subscribers.sort((a, b) => comparePaths(a.paths[0], b.paths[0]));
 
   if (startPath.length > 0) {
     // If we're starting from a specific path, filter the subscribers to only
@@ -160,15 +159,32 @@ export function determineTriggeredActions(
     }
     currentPath = targetPath;
 
-    // Now get the value at the path, `undefined` if that path doesn't exist
-    const beforeValue = beforeLastObject + 1 >= targetPath.length
-      ? beforeValues[targetPath.length]
-      : undefined;
-    const afterValue = afterLastObject + 1 >= targetPath.length
-      ? afterValues[targetPath.length]
-      : undefined;
+    // Check if we could traverse far enough to reach the target path
+    const beforeCanReach = beforeLastObject + 1 >= targetPath.length;
+    const afterCanReach = afterLastObject + 1 >= targetPath.length;
+
+    // Determine if there was a change. We need to trigger if:
+    // 1. Both paths are reachable and the values differ
+    // 2. Reachability changed (one can reach, the other can't)
+    // 3. Neither can reach, but the depth of reachability changed
+    //    (e.g., before we couldn't get past "a", now we can get to "a.b")
+    let hasChanged: boolean;
+    if (beforeCanReach && afterCanReach) {
+      // Both reachable - compare actual values
+      hasChanged = !deepEqual(
+        beforeValues[targetPath.length],
+        afterValues[targetPath.length],
+      );
+    } else if (beforeCanReach !== afterCanReach) {
+      // Reachability changed - definitely a structural change
+      hasChanged = true;
+    } else {
+      // Neither reachable - check if we can traverse to different depths
+      // This detects when intermediate path segments appear/disappear
+      hasChanged = beforeLastObject !== afterLastObject;
+    }
 
-    if (!deepEqual(beforeValue, afterValue)) {
+    if (hasChanged) {
       // If the value changed, trigger the actions
       triggeredActions.push(...current.map(({ action }) => action));
     } else {

packages/runner/test/reactive-dependencies.test.ts

@@ -1613,6 +1613,104 @@ describe("determineTriggeredActions", () => {
     });
   });
 
+  describe("bug: action should trigger when intermediate path appears", () => {
+    it("triggers when intermediate path appears even if final value remains undefined", () => {
+      // Bug scenario:
+      // Action B watches ["a", "b", "c"]
+      // Before: { a: {} } - no 'b' key, so path a.b.c is "unreachable"
+      // After: { a: { b: { x: 1 } } } - 'b' exists but no 'c' key
+      //
+      // In both cases the final value at a.b.c is undefined, BUT:
+      // - Before: we couldn't traverse past 'a' because 'b' doesn't exist
+      // - After: we can traverse to 'b', but 'c' doesn't exist there
+      //
+      // This structural change should trigger the action, because the
+      // "reachability" of the path changed.
+      const actionB = createAction("actionB");
+      const dependencies = new Map<Action, SortedAndCompactPaths>([
+        [actionB, [["a", "b", "c"]]],
+      ]);
+
+      const result = determineTriggeredActions(
+        dependencies,
+        { a: {} },
+        { a: { b: { x: 1 } } },
+      );
+
+      // Action B should trigger because the path structure changed
+      expect(result).toContain(actionB);
+    });
+
+    it("real-world case: triggers when __#0 key appears in internal", () => {
+      // Simplified version of the real bug from production
+      // Action B watches a path through __#0.allCharms
+      // Before: internal doesn't have __#0
+      // After: internal has __#0 (but no allCharms inside)
+      const actionA = createAction("actionA");
+      const actionB = createAction("actionB");
+      const actionC = createAction("actionC");
+
+      const dependencies = new Map<Action, SortedAndCompactPaths>([
+        [actionA, [
+          ["value", "internal", "$NAME"],
+          ["value", "internal", "$alias", "path"],
+          ["value", "internal", "/", "link@1"],
+          ["value", "internal", "cell", "/"],
+        ]],
+        [actionB, [
+          ["value", "internal", "$alias", "path"],
+          ["value", "internal", "/", "link@1"],
+          ["value", "internal", "__#0", "allCharms"],
+          ["value", "internal", "cell", "/"],
+        ]],
+        [actionC, [
+          ["value", "internal", "$alias", "path"],
+          ["value", "internal", "/", "link@1"],
+          ["value", "internal", "__#0", "allCharms"],
+          ["value", "internal", "cell", "/"],
+        ]],
+      ]);
+
+      const before = {
+        value: {
+          internal: {
+            backlinksIndex: { "/": { "link@1": { path: [], id: "of:123" } } },
+            "__#2": { "/": { "link@1": { path: [], id: "of:456" } } },
+            // Note: NO __#0 key
+          },
+        },
+      };
+
+      const after = {
+        value: {
+          internal: {
+            backlinksIndex: { "/": { "link@1": { path: [], id: "of:123" } } },
+            "__#2": { "/": { "link@1": { path: [], id: "of:456" } } },
+            // __#0 now exists! (but doesn't have allCharms)
+            "__#0": {
+              "/": {
+                "link@1": { path: [], id: "of:789", space: "did:key:abc" },
+              },
+            },
+          },
+        },
+      };
+
+      const result = determineTriggeredActions(
+        dependencies,
+        before as JSONValue,
+        after as JSONValue,
+      );
+
+      // Action B and C should trigger because __#0 appeared,
+      // even though allCharms is still undefined in both cases
+      expect(result).toContain(actionB);
+      expect(result).toContain(actionC);
+      // Action A should NOT trigger (none of its paths changed)
+      expect(result).not.toContain(actionA);
+    });
+  });
+
   describe("complex scenarios", () => {
     it("handles multiple actions with different nested dependencies", () => {
       const action1 = createAction("action1");