@archie/devtools 0.0.40 → 0.0.41

package/dist/inspector.standalone.js

@@ -275,7 +275,31 @@
         while (fiber && chain.length < MAX_META_CHAIN) {
           if (fiber.memoizedProps && fiber.memoizedProps.__editorMeta) {
             var meta = resolveEditorMetaValue(fiber.memoizedProps.__editorMeta)
-            if (meta) chain.push(meta)
+            if (meta) {
+              // ARCH-1367 F6 (host-measured incident, 2026-09-06) — `hostIsSelf`:
+              // TRUE when this chain entry's fiber renders EXACTLY `el` as its
+              // single host element (getSingleHostElementFromFiber), i.e. the
+              // usage and the node are the same DOM element — a `<Button>`
+              // usage whose whole render is this `<button>`. FALSE for a real
+              // ancestor (a `<header>` around it) AND for a usage whose render
+              // is a Fragment/array with siblings (`ThemeGlyphs` = two spans):
+              // that usage does NOT stand for this node alone. The host walks
+              // up from a template root ONLY through `hostIsSelf` entries to
+              // find "the element the user sees"; without this flag it climbed
+              // by name and could resolve one glyph to the whole `ThemeGlyphs`
+              // usage (measured: `const themeIcon = null`). A COPY, so the
+              // shared meta object is never mutated.
+              var host = null
+              try {
+                host = getSingleHostElementFromFiber(fiber)
+              } catch (hostError) {
+                host = null
+              }
+              var entry = {}
+              for (var k in meta) if (Object.prototype.hasOwnProperty.call(meta, k)) entry[k] = meta[k]
+              entry.hostIsSelf = host === el
+              chain.push(entry)
+            }
           }
           fiber = fiber["return"]
         }
@@ -1626,6 +1650,13 @@
             // (`CAPTURE_VIEWPORT` → `VIEWPORT_CAPTURED`). Hosts MUST
             // feature-detect: a frozen earlier inspector has no handler for
             // either message and would never reply.
+            // ARCH-1367 F6 (CR round 3, MAJOR-2) — this build annotates every
+            // `editorMetaChain` entry with `hostIsSelf` and attaches the drop
+            // container's chain to `element-inserted` / arrange-session
+            // inserts. The CDN object is unversioned, so this bit is the ONLY
+            // honest floor a host can check; without it the host refuses a
+            // delete/drop on a kit template root instead of guessing.
+            metaChainHostIsSelf: true,
             rectElementQuery: true,
             // Best-effort by construction — the foreignObject round-trip drops
             // web fonts, cross-origin images and <canvas> pixels, and answers
@@ -3786,7 +3817,68 @@
           return
         }
 
+        // ARCH-1367 F6 — attach the drop container's editor meta chain to a
+        // container descriptor ({selector, nodeId, …}). Shared by the
+        // `element-inserted` relay AND the `arrange-session-changed` relay:
+        // the host builds its insert change from the SESSION snapshot, not
+        // from the one-shot inserted event, so both must carry it. Additive
+        // and fail-open.
+        function attachContainerMetaChain(container) {
+          if (!container || typeof container !== "object") return
+          var containerEl = null
+          if (typeof container.selector === "string" && container.selector) {
+            try {
+              containerEl = _rawDocumentQuerySelector.call(document, container.selector)
+            } catch (selectorError) {
+              containerEl = null
+            }
+          }
+          if (!containerEl && typeof container.nodeId === "string" && container.nodeId) {
+            containerEl = _rawDocumentQuerySelector.call(
+              document,
+              '[data-dnd-node-id="' + container.nodeId.replace(/"/g, '\\"') + '"]'
+            )
+          }
+          if (containerEl) {
+            container.editorMetaChain = collectEditorMetaChain(containerEl)
+          } else {
+            // CR round 4 (archie-app #1820), MAJOR-D — a silent miss here is
+            // indistinguishable, on the host, from an inspector that predates
+            // the chain. Say it, and attach an EMPTY chain so the host can
+            // tell "this inspector tried and could not find the container"
+            // from "no chain at all"; the host fails closed either way.
+            container.editorMetaChain = []
+            inspectorWarn(
+              "[Inspector] drop container not found for meta chain",
+              container.selector || container.nodeId || null
+            )
+          }
+        }
+
         if (detail.type === "element-inserted") {
+          // ARCH-1367 F6 (host-measured incident, 2026-09-06) — the drop
+          // container the DnD runtime reports is the DEEPEST droppable under
+          // the pointer, which for a kit primitive is that primitive's own
+          // TEMPLATE root (`components/ui/button.jsx:8:78:button` when the
+          // drop lands on the theme toggle). The host has no way to see the
+          // USAGE that root stands for (`<IconButton>` in shell-layouts.jsx)
+          // — so it wrote the insert INTO the template, and every button in
+          // the project grew a nested button. The runtime's `element-inserted`
+          // detail carries the container's selector/nodeId only; this is the
+          // one place that can still reach the live element and its fiber
+          // chain, so the chain is attached here — ADDITIVE, the host reads
+          // `container.editorMetaChain` when present and ignores its absence.
+          // Same collector `ELEMENT_SELECTED` uses, so both sides agree.
+          try {
+            attachContainerMetaChain(detail && detail.container)
+          } catch (chainError) {
+            // CR round 5, NIT-5 — a throw must not collapse the "tried and
+            // failed" signal into "no chain at all".
+            if (detail && detail.container && typeof detail.container === "object") {
+              detail.container.editorMetaChain = []
+            }
+            inspectorWarn("[Inspector] element-inserted: container meta chain unavailable", chainError)
+          }
           postMessageToParent({
             type: "ELEMENT_INSERTED",
             payload: detail,
@@ -3795,6 +3887,38 @@
         }
 
         if (detail.type === "arrange-session-changed") {
+          // ARCH-1367 F6 — same chain on every INSERT change of the session
+          // snapshot (this is what the host actually builds its change from).
+          try {
+            var sessionChanges = detail.session && detail.session.changes
+            if (Array.isArray(sessionChanges)) {
+              for (var sc = 0; sc < sessionChanges.length; sc++) {
+                var sessionChange = sessionChanges[sc]
+                if (sessionChange && sessionChange.kind === "insert") {
+                  if (!sessionChange.container || typeof sessionChange.container !== "object") {
+                    sessionChange.container = { nodeId: sessionChange.containerId || null, selector: null }
+                  }
+                  if (!sessionChange.container.nodeId && sessionChange.containerId) {
+                    sessionChange.container.nodeId = sessionChange.containerId
+                  }
+                  attachContainerMetaChain(sessionChange.container)
+                }
+              }
+            }
+          } catch (sessionChainError) {
+            try {
+              var scs = detail.session && detail.session.changes
+              if (Array.isArray(scs)) {
+                for (var sci = 0; sci < scs.length; sci++) {
+                  var scc = scs[sci]
+                  if (scc && scc.kind === "insert" && scc.container && typeof scc.container === "object" && !Array.isArray(scc.container.editorMetaChain)) {
+                    scc.container.editorMetaChain = []
+                  }
+                }
+              }
+            } catch (ignored) {}
+            inspectorWarn("[Inspector] arrange-session-changed: container meta chain unavailable", sessionChainError)
+          }
           postMessageToParent({
             type: "ARRANGE_SESSION_CHANGED",
             session: detail.session,

package/package.json

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