@archie/devtools 0.0.23 → 0.0.25

package/dist/inspector.standalone.js

@@ -274,6 +274,185 @@
         return null
       }
 
+      // ── ARCH-883 F2 — usage chain + instance identity ───────────────────
+      // Vanilla twins of collectEditorMetaChain (fiber-bridge.ts) and
+      // resolveInstanceIdentity (instance-identity.ts). Those files carry the
+      // full rationale; keep the three in step.
+      var MAX_META_CHAIN = 24
+
+      // Every __editorMeta on the fiber return chain, innermost first. The host
+      // needs the FULL metas (staticProps/propBindings/propOwner), not the
+      // narrowed inspectorSource shape: routing a kit-internal node means
+      // finding the USAGE above it and reading the prop value AT that usage.
+      function collectEditorMetaChain(el) {
+        var chain = []
+        var fiber = getFiberFromElement(el)
+        while (fiber && chain.length < MAX_META_CHAIN) {
+          if (fiber.memoizedProps && fiber.memoizedProps.__editorMeta) {
+            var meta = resolveEditorMetaValue(fiber.memoizedProps.__editorMeta)
+            if (meta) chain.push(meta)
+          }
+          fiber = fiber["return"]
+        }
+        return chain
+      }
+
+      var MAX_ROW_ROOT_DEPTH = 12
+      var MAX_KEY_WALK = 40
+
+      // The fiber that OWNS the nearest __editorMeta for `el`. Vanilla twin of
+      // getEditorMetaOwnerFiber (fiber-bridge.ts).
+      function getEditorMetaOwnerFiberFromElement(el) {
+        var fiber = getFiberFromElement(el)
+        while (fiber) {
+          if (fiber.memoizedProps && fiber.memoizedProps.__editorMeta) {
+            return fiber
+          }
+          fiber = fiber["return"]
+        }
+        return null
+      }
+
+      // The SINGLE host element `owner` renders, or null when it renders zero
+      // or several, or crosses a HostPortal (tag 4). Vanilla twin of
+      // getSingleHostElement (fiber-bridge.ts) — conservative by design.
+      function getSingleHostElementFromFiber(owner) {
+        var hosts = []
+        var stack = owner && owner.child ? [owner.child] : []
+        while (stack.length > 0) {
+          var fiber = stack.pop()
+          if (!fiber) continue
+          if (fiber.tag === 4) return null
+          if (
+            typeof fiber.type === "string" &&
+            fiber.stateNode &&
+            fiber.stateNode.nodeType === 1
+          ) {
+            hosts.push(fiber.stateNode)
+            if (hosts.length > 1) return null
+          } else if (fiber.child) {
+            stack.push(fiber.child)
+          }
+          if (fiber.sibling) stack.push(fiber.sibling)
+        }
+        return hosts.length === 1 ? hosts[0] : null
+      }
+
+      // Vanilla twin of projectUsageMeta (useElementScanner.ts): the usage meta
+      // when `el` is the SINGLE host root a component usage renders and that
+      // component destructured its props, so the host fiber carries no meta.
+      function projectUsageMetaFromElement(el) {
+        if (getDirectEditorMetaFromElement(el)) return null
+        var owner = getEditorMetaOwnerFiberFromElement(el)
+        if (!owner) return null
+        if (getSingleHostElementFromFiber(owner) !== el) return null
+        return resolveEditorMetaValue(owner.memoizedProps.__editorMeta)
+      }
+
+      // The nodeId this element carries AS ITS OWN — direct fiber meta, or the
+      // single-host projection. NEVER an inherited ancestor nodeId: walking the
+      // fiber chain here made every UNSTAMPED subtree (any two siblings
+      // rendered by a component the plugin never transformed — anything from
+      // node_modules, and here SVG internals too, since this twin accepts any
+      // element node) look like a repeated collection. Meanwhile a
+      // direct-meta-ONLY rule would make every kit component that destructures
+      // its props look like a singleton — which is the fail-OPEN mistake, and
+      // would write a literal into a mapped usage, changing every row.
+      // See instance-identity.ts for the full rationale.
+      function ownMetaNodeId(el) {
+        if (!el || el.nodeType !== 1) return null
+        var direct = getDirectEditorMetaFromElement(el)
+        if (direct && direct.nodeId) return direct.nodeId
+        var projected = projectUsageMetaFromElement(el)
+        return projected && projected.nodeId ? projected.nodeId : null
+      }
+
+      // The repeated-row boundary above `el`, or null. INNERMOST repetition
+      // wins (a tag inside a card inside a list is identified by the tag's key).
+      function findCollectionWindow(el) {
+        var node = el
+        for (var depth = 0; depth < MAX_ROW_ROOT_DEPTH; depth++) {
+          var parent = node.parentElement
+          if (!parent) return null
+
+          var nodeId = ownMetaNodeId(node)
+          if (nodeId !== null) {
+            var twins = []
+            for (var i = 0; i < parent.children.length; i++) {
+              var child = parent.children[i]
+              if (ownMetaNodeId(child) === nodeId) twins.push(child)
+            }
+            if (twins.length >= 2) {
+              return {
+                rowRoot: node,
+                container: parent,
+                ordinal: twins.indexOf(node),
+              }
+            }
+          }
+
+          node = parent
+        }
+        return null
+      }
+
+      // Nearest React key BETWEEN the row root and the collection container.
+      // Stopping at the container is the point: a keyed ancestor above it
+      // identifies a page, not a row.
+      function keyWithinWindow(rowRoot, container) {
+        var fiber = getFiberFromElement(rowRoot)
+        for (var steps = 0; fiber && steps < MAX_KEY_WALK; steps++) {
+          if (fiber.stateNode === container) return null
+          var key = fiber.key
+          if (typeof key === "string" && key.length > 0) return key
+          if (typeof key === "number") return String(key)
+          fiber = fiber["return"]
+        }
+        return null
+      }
+
+      // WHICH instance of a possibly-repeated node this element is.
+      // `scanOrdinal` is telemetry/UI only — the host must REJECT an intent
+      // with inCollection && fiberKey === null, never fall back to it.
+      function resolveInstanceIdentity(el) {
+        var win = findCollectionWindow(el)
+        if (!win) return { fiberKey: null, scanOrdinal: 0, inCollection: false }
+        return {
+          fiberKey: keyWithinWindow(win.rowRoot, win.container),
+          scanOrdinal: win.ordinal,
+          inCollection: true,
+        }
+      }
+
+      // ARCH-906 — the DURABLE `data-agent-id` anchors on the ANCESTOR chain,
+      // innermost first. This is a DOM-attribute walk, not a fiber walk (no twin
+      // in fiber-bridge.ts to mirror): it reads the semantic anchors the render
+      // stamps (`row:<id>`, `data:<Entity>`, `screen:<slug>`, `job:<id>`) and
+      // forwards them so the host can resolve a slice DATA cell.
+      //
+      // WHY THE ANCESTOR CHAIN, and why it is not `editorInstance`. Clicking a
+      // table cell resolves the INNERMOST collection — the `<td key={c.key}>` map
+      // — so `editorInstance.fiberKey` already carries the FIELD. The ROW it
+      // belongs to lives one level up on `<tr data-agent-id="row:<id>">`, and the
+      // ENTITY on a container above that (`data-agent-id="data:<Entity>"`).
+      // Neither can be the innermost collection key, so the host cannot recover
+      // them from `editorInstance` — it needs the ancestor anchors verbatim.
+      // Strict ancestors only (the selected node's own anchor is already in
+      // `attributes`); the host picks the nearest `row:`/`data:` by namespace.
+      var MAX_ANCHOR_CHAIN = 24
+      function collectAncestorAnchors(el) {
+        var anchors = []
+        var node = el && el.parentElement ? el.parentElement : null
+        for (var depth = 0; node && depth < MAX_ANCHOR_CHAIN; depth++) {
+          if (node.nodeType === 1 && typeof node.getAttribute === "function") {
+            var id = node.getAttribute("data-agent-id")
+            if (typeof id === "string" && id !== "") anchors.push(id)
+          }
+          node = node.parentElement
+        }
+        return anchors
+      }
+
       if (window._inspectorSharedTargetObserver) {
         try {
           window._inspectorSharedTargetObserver.disconnect()
@@ -2061,6 +2240,42 @@
           // this script's version. The slot string is opaque here; validating it
           // against kit-runtime's `slot-vocabulary` is the host's job.
           editorMeta: editorMeta ? editorMeta.meta : null,
+          // ARCH-883 F2 — the two things the host cannot derive from
+          // `editorMeta` alone (SDD §2.9):
+          //
+          //   editorMetaChain: routing a kit-internal node needs the USAGE
+          //     (`<Kit.AuthFrame headline="…"/>` in screens/<slug>.jsx), which
+          //     is NOT the nearest meta — the nearest meta is the <h1> inside
+          //     AuthFrame's own template. The host locates the usage by
+          //     matching `propOwner` against a chain entry's componentName and
+          //     applies the usage-value law to that entry's staticProps. Both
+          //     fields live only on the full meta.
+          //
+          //   editorInstance: WHICH row of a repeated node was clicked. The
+          //     nodeId is a source position and collides across instances; the
+          //     only identity that survives an insert above the edited row is
+          //     React's `key`, which exists on the fiber and nowhere else.
+          //
+          // Both are plain data, so an already-published copy of this script
+          // forwards them through structured clone unchanged.
+          //
+          // The chain starts at the element the meta was FOUND on (the same
+          // element `editorMeta` above describes) — a clicked node with no
+          // fiber of its own would otherwise yield an empty chain while
+          // reporting a meta resolved from its parent. The instance walk starts
+          // at the CLICKED element, so an inner collection wins over an outer
+          // one (a tag inside a card inside a list).
+          editorMetaChain: collectEditorMetaChain(
+            editorMeta ? editorMeta.element : element
+          ),
+          editorInstance: resolveInstanceIdentity(element),
+          // ARCH-906 — the ancestor `data-agent-id` chain (innermost first). A
+          // slice DATA cell needs the ROW id (`row:<id>` on the `<tr>`) and the
+          // ENTITY (`data:<Entity>` above it), neither of which is the innermost
+          // collection key `editorInstance` carries. Plain string data, so an
+          // already-published copy of this script forwards it unchanged through
+          // structured clone; a host that does not read it is unaffected.
+          ancestorAnchors: collectAncestorAnchors(element),
           computedStyles: {
             display: computed.display,
             position: computed.position,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archie/devtools",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "DevTools for Archie generated applications - Route synchronization and editor communication",
   "repository": {
     "type": "git",