@archie/devtools 0.0.40 → 0.0.42

package/dist/{chunk-6QB35SLQ.mjs → chunk-O3UMTM4N.mjs}

@@ -78,6 +78,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return "";
   }
+  function isIntrinsicTagName(name) {
+    return t.isJSXIdentifier(name) && /^[a-z]/.test(name.name);
+  }
   function isHostLikeMemberExpressionName(name) {
     if (!t.isJSXMemberExpression(name)) return false;
     const propertyName = name.property.name;
@@ -168,6 +171,18 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return hasAny ? t.objectExpression(props) : null;
   }
+  function describeChildrenText(opening) {
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return null;
+    const element = elementPath.node;
+    if (!element.closingElement) return null;
+    const children = element.children;
+    if (children.length === 0) return "";
+    if (children.length !== 1) return "__dynamic__";
+    const [only] = children;
+    if (!t.isJSXText(only)) return "__dynamic__";
+    return only.value.trim();
+  }
   function isMetaStripSpreadExpression(arg) {
     if (!t.isCallExpression(arg)) return false;
     if (!t.isArrowFunctionExpression(arg.callee)) return false;
@@ -275,6 +290,14 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return map;
   }
+  function restParamName(pattern) {
+    for (const prop of pattern.properties) {
+      if (!t.isRestElement(prop)) continue;
+      if (t.isIdentifier(prop.argument)) return prop.argument.name;
+      return null;
+    }
+    return null;
+  }
   function resolvePropContext(path2) {
     let fn = path2.getFunctionParent();
     while (fn) {
@@ -283,7 +306,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
         return {
           componentScope: fn.scope,
           propMap: buildPropMap(first),
-          componentName: getFunctionName(fn)
+          componentName: getFunctionName(fn),
+          restParam: restParamName(first),
+          componentPath: fn
         };
       }
       fn = fn.getFunctionParent();
@@ -403,12 +428,62 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     const props = collectPropIdentifiers(expr, scope, ctx);
     return props.length > 0 ? { kind: "formatted", prop: props[0] } : null;
   }
+  function unwrapSanitizedSpread(arg) {
+    if (!t.isCallExpression(arg)) return arg;
+    if (!isMetaStripSpreadExpression(arg)) return arg;
+    if (arg.arguments.length !== 1) return arg;
+    const [payload] = arg.arguments;
+    if (!t.isObjectExpression(payload) || payload.properties.length !== 1) return arg;
+    const [only] = payload.properties;
+    if (!t.isSpreadElement(only)) return arg;
+    return only.argument;
+  }
+  function forwardsOwnerRestChildren(opening, ctx) {
+    if (ctx.restParam === null) return false;
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return false;
+    if (meaningfulChildren(t, elementPath.node.children).length > 0) return false;
+    let spreadsRest = 0;
+    for (const attr of opening.node.attributes) {
+      if (t.isJSXAttribute(attr)) {
+        if (t.isJSXIdentifier(attr.name, { name: "children" })) return false;
+        continue;
+      }
+      if (!t.isJSXSpreadAttribute(attr)) continue;
+      const payload = unwrapSanitizedSpread(attr.argument);
+      if (!t.isIdentifier(payload, { name: ctx.restParam })) return false;
+      spreadsRest += 1;
+    }
+    if (spreadsRest !== 1) return false;
+    const binding = opening.scope.getBinding(ctx.restParam);
+    if (!binding) return false;
+    if (binding.scope !== ctx.componentScope) return false;
+    return binding.constant;
+  }
+  const restForwarderCounts = /* @__PURE__ */ new WeakMap();
+  function countRestForwarders(ctx) {
+    const cached = restForwarderCounts.get(ctx.componentPath.node);
+    if (cached !== void 0) return cached;
+    let count = 0;
+    ctx.componentPath.traverse({
+      JSXOpeningElement(inner) {
+        if (forwardsOwnerRestChildren(inner, ctx)) count += 1;
+      }
+    });
+    restForwarderCounts.set(ctx.componentPath.node, count);
+    return count;
+  }
   function collectPropBindings(path2, attrs) {
     const ctx = resolvePropContext(path2);
-    if (!ctx || ctx.propMap.size === 0) return { bindings: [], owner: null };
+    if (!ctx || ctx.propMap.size === 0 && ctx.restParam === null) {
+      return { bindings: [], owner: null };
+    }
     if (ctx.componentName === null) return { bindings: [], owner: null };
     const scope = path2.scope;
     const bindings = [];
+    if (forwardsOwnerRestChildren(path2, ctx) && countRestForwarders(ctx) === 1) {
+      bindings.push({ target: "children", prop: "children", kind: "direct" });
+    }
     const elementPath = path2.parentPath;
     if (elementPath && elementPath.isJSXElement()) {
       const children = meaningfulChildren(t, elementPath.node.children);
@@ -510,7 +585,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
           return;
         }
         let rootName = null;
-        if (t.isJSXIdentifier(path2.node.name)) {
+        if (isIntrinsicTagName(path2.node.name)) {
+          rootName = null;
+        } else if (t.isJSXIdentifier(path2.node.name)) {
           rootName = path2.node.name.name;
         } else if (t.isJSXMemberExpression(path2.node.name)) {
           let cur = path2.node.name;
@@ -572,6 +649,15 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
             t.objectProperty(t.identifier("slot"), t.stringLiteral(slot))
           );
         }
+        if (!isHostElement) {
+          const childrenText = describeChildrenText(path2);
+          metaObj.properties.push(
+            t.objectProperty(
+              t.identifier("childrenText"),
+              childrenText === null ? t.nullLiteral() : t.stringLiteral(childrenText)
+            )
+          );
+        }
         if (bindings.length > 0) {
           metaObj.properties.push(
             t.objectProperty(t.identifier("propBindings"), propBindingsToAst(bindings))

package/dist/collection-binding.mjs

@@ -1,6 +1,6 @@
 import {
   meaningfulChildren
-} from "./chunk-6QB35SLQ.mjs";
+} from "./chunk-O3UMTM4N.mjs";
 
 // src/babel-plugin-collection-binding.ts
 import { VISITOR_KEYS } from "@babel/types";

package/dist/index.d.mts

@@ -12,6 +12,7 @@ import { types, PluginObj } from '@babel/core';
  *   nodeId, file, line, col, componentName, staticProps, movable, parentNodeId
  *   + (ARCH-883 F1) slot, propBindings, propOwner
  *   + (ARCH-883-KOI) origin
+ *   + (ARCH-1444) childrenText — non-host elements only
  *
  * At runtime the Fiber bridge reads `memoizedProps.__editorMeta` to resolve
  * element identity without any DOM attributes.
@@ -169,6 +170,17 @@ declare function babelPluginEditorMeta({ types: t }: {
  * `id`/`htmlFor`/`name`/`type`/`role`/`slot`) are downgraded to `formatted` by the
  * PRODUCER, because no usage value could make them a text edit. The consumer does
  * not need to re-derive that list; it only needs the allowlist above.
+ *
+ * ARCH-1443: `{ target: 'children', prop: 'children', kind: 'direct' }` is emitted
+ * for an element that forwards its component's props REST and renders no children
+ * of its own — the shape EVERY ejected shadcn-style primitive has
+ * (`({ className, ...p }) => <h3 className={…} {...p} />`). Nothing about the
+ * allowlist changes: the usage value of `children` is the JSX children written at
+ * the usage site (`<CardTitle>Cómo funciona</CardTitle>`), and the same
+ * usage-value law applies to it — plain text is writable, a nested element or a
+ * computed expression is a gap. The producer refuses whenever more than one
+ * element in the component forwards the rest, since one `children` prop cannot
+ * name which of them an edit is about.
  */
 interface PropBinding {
     /**
@@ -216,6 +228,38 @@ interface EditorMeta {
     componentName: string;
     /** Safely serializable literal prop values. Dynamic expressions are "__dynamic__". */
     staticProps: Record<string, unknown> | null;
+    /**
+     * ARCH-1444 — the SHAPE of this element's JSX children, and their text when
+     * that text is plain. `staticProps` is built from ATTRIBUTES only, so without
+     * this field the `children` prop is the one binding target whose value at the
+     * usage a consumer cannot see — and the usage-value law above ("plain text is
+     * writable, a nested element or a computed expression is a gap") is stated in
+     * terms of exactly that value.
+     *
+     *   `null`          — the element is SELF-CLOSING: no children container at
+     *                     all. NOT the same as `''` (`<X></X>`), which can take a
+     *                     text write; `<X />` cannot without a structural rewrite.
+     *   `''`            — an empty children container.
+     *   `'__dynamic__'` — anything that is not exactly one JSXText child: an
+     *                     expression container, a nested element, a comment, or
+     *                     several children. Same sentinel as `staticProps`.
+     *   any other string— the sole JSXText child, TRIMMED (JSX itself trims
+     *                     leading/trailing whitespace-with-newlines, so the
+     *                     trimmed form is what renders). A newline that SURVIVES
+     *                     the trim is real multi-line content: a consumer that
+     *                     writes by splicing must refuse it, because replacing it
+     *                     with one line deletes source lines and invalidates every
+     *                     anchor below.
+     *
+     * Emitted for NON-HOST elements only — a usage is always a component tag, and
+     * stamping every `<div>` would be weight for an answer nothing asks.
+     *
+     * ABSENT (`undefined`) on a host element and on every bundle built before this
+     * change. Absence is NOT "no children": it means the page cannot answer the
+     * question, and a consumer must gap the edit rather than assume (the same law
+     * `origin`'s docstring states at length).
+     */
+    childrenText?: string | null;
     /**
      * Whether the JSX node is in a reorderable position (2+ siblings).
      *

package/dist/index.d.ts

@@ -12,6 +12,7 @@ import { types, PluginObj } from '@babel/core';
  *   nodeId, file, line, col, componentName, staticProps, movable, parentNodeId
  *   + (ARCH-883 F1) slot, propBindings, propOwner
  *   + (ARCH-883-KOI) origin
+ *   + (ARCH-1444) childrenText — non-host elements only
  *
  * At runtime the Fiber bridge reads `memoizedProps.__editorMeta` to resolve
  * element identity without any DOM attributes.
@@ -169,6 +170,17 @@ declare function babelPluginEditorMeta({ types: t }: {
  * `id`/`htmlFor`/`name`/`type`/`role`/`slot`) are downgraded to `formatted` by the
  * PRODUCER, because no usage value could make them a text edit. The consumer does
  * not need to re-derive that list; it only needs the allowlist above.
+ *
+ * ARCH-1443: `{ target: 'children', prop: 'children', kind: 'direct' }` is emitted
+ * for an element that forwards its component's props REST and renders no children
+ * of its own — the shape EVERY ejected shadcn-style primitive has
+ * (`({ className, ...p }) => <h3 className={…} {...p} />`). Nothing about the
+ * allowlist changes: the usage value of `children` is the JSX children written at
+ * the usage site (`<CardTitle>Cómo funciona</CardTitle>`), and the same
+ * usage-value law applies to it — plain text is writable, a nested element or a
+ * computed expression is a gap. The producer refuses whenever more than one
+ * element in the component forwards the rest, since one `children` prop cannot
+ * name which of them an edit is about.
  */
 interface PropBinding {
     /**
@@ -216,6 +228,38 @@ interface EditorMeta {
     componentName: string;
     /** Safely serializable literal prop values. Dynamic expressions are "__dynamic__". */
     staticProps: Record<string, unknown> | null;
+    /**
+     * ARCH-1444 — the SHAPE of this element's JSX children, and their text when
+     * that text is plain. `staticProps` is built from ATTRIBUTES only, so without
+     * this field the `children` prop is the one binding target whose value at the
+     * usage a consumer cannot see — and the usage-value law above ("plain text is
+     * writable, a nested element or a computed expression is a gap") is stated in
+     * terms of exactly that value.
+     *
+     *   `null`          — the element is SELF-CLOSING: no children container at
+     *                     all. NOT the same as `''` (`<X></X>`), which can take a
+     *                     text write; `<X />` cannot without a structural rewrite.
+     *   `''`            — an empty children container.
+     *   `'__dynamic__'` — anything that is not exactly one JSXText child: an
+     *                     expression container, a nested element, a comment, or
+     *                     several children. Same sentinel as `staticProps`.
+     *   any other string— the sole JSXText child, TRIMMED (JSX itself trims
+     *                     leading/trailing whitespace-with-newlines, so the
+     *                     trimmed form is what renders). A newline that SURVIVES
+     *                     the trim is real multi-line content: a consumer that
+     *                     writes by splicing must refuse it, because replacing it
+     *                     with one line deletes source lines and invalidates every
+     *                     anchor below.
+     *
+     * Emitted for NON-HOST elements only — a usage is always a component tag, and
+     * stamping every `<div>` would be weight for an answer nothing asks.
+     *
+     * ABSENT (`undefined`) on a host element and on every bundle built before this
+     * change. Absence is NOT "no children": it means the page cannot answer the
+     * question, and a consumer must gap the edit rather than assume (the same law
+     * `origin`'s docstring states at length).
+     */
+    childrenText?: string | null;
     /**
      * Whether the JSX node is in a reorderable position (2+ siblings).
      *

package/dist/index.js

@@ -277,6 +277,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return "";
   }
+  function isIntrinsicTagName(name) {
+    return t.isJSXIdentifier(name) && /^[a-z]/.test(name.name);
+  }
   function isHostLikeMemberExpressionName(name) {
     if (!t.isJSXMemberExpression(name)) return false;
     const propertyName = name.property.name;
@@ -367,6 +370,18 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return hasAny ? t.objectExpression(props) : null;
   }
+  function describeChildrenText(opening) {
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return null;
+    const element = elementPath.node;
+    if (!element.closingElement) return null;
+    const children = element.children;
+    if (children.length === 0) return "";
+    if (children.length !== 1) return "__dynamic__";
+    const [only] = children;
+    if (!t.isJSXText(only)) return "__dynamic__";
+    return only.value.trim();
+  }
   function isMetaStripSpreadExpression(arg) {
     if (!t.isCallExpression(arg)) return false;
     if (!t.isArrowFunctionExpression(arg.callee)) return false;
@@ -474,6 +489,14 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return map;
   }
+  function restParamName(pattern) {
+    for (const prop of pattern.properties) {
+      if (!t.isRestElement(prop)) continue;
+      if (t.isIdentifier(prop.argument)) return prop.argument.name;
+      return null;
+    }
+    return null;
+  }
   function resolvePropContext(path) {
     let fn = path.getFunctionParent();
     while (fn) {
@@ -482,7 +505,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
         return {
           componentScope: fn.scope,
           propMap: buildPropMap(first),
-          componentName: getFunctionName(fn)
+          componentName: getFunctionName(fn),
+          restParam: restParamName(first),
+          componentPath: fn
         };
       }
       fn = fn.getFunctionParent();
@@ -602,12 +627,62 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     const props = collectPropIdentifiers(expr, scope, ctx);
     return props.length > 0 ? { kind: "formatted", prop: props[0] } : null;
   }
+  function unwrapSanitizedSpread(arg) {
+    if (!t.isCallExpression(arg)) return arg;
+    if (!isMetaStripSpreadExpression(arg)) return arg;
+    if (arg.arguments.length !== 1) return arg;
+    const [payload] = arg.arguments;
+    if (!t.isObjectExpression(payload) || payload.properties.length !== 1) return arg;
+    const [only] = payload.properties;
+    if (!t.isSpreadElement(only)) return arg;
+    return only.argument;
+  }
+  function forwardsOwnerRestChildren(opening, ctx) {
+    if (ctx.restParam === null) return false;
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return false;
+    if (meaningfulChildren(t, elementPath.node.children).length > 0) return false;
+    let spreadsRest = 0;
+    for (const attr of opening.node.attributes) {
+      if (t.isJSXAttribute(attr)) {
+        if (t.isJSXIdentifier(attr.name, { name: "children" })) return false;
+        continue;
+      }
+      if (!t.isJSXSpreadAttribute(attr)) continue;
+      const payload = unwrapSanitizedSpread(attr.argument);
+      if (!t.isIdentifier(payload, { name: ctx.restParam })) return false;
+      spreadsRest += 1;
+    }
+    if (spreadsRest !== 1) return false;
+    const binding = opening.scope.getBinding(ctx.restParam);
+    if (!binding) return false;
+    if (binding.scope !== ctx.componentScope) return false;
+    return binding.constant;
+  }
+  const restForwarderCounts = /* @__PURE__ */ new WeakMap();
+  function countRestForwarders(ctx) {
+    const cached = restForwarderCounts.get(ctx.componentPath.node);
+    if (cached !== void 0) return cached;
+    let count = 0;
+    ctx.componentPath.traverse({
+      JSXOpeningElement(inner) {
+        if (forwardsOwnerRestChildren(inner, ctx)) count += 1;
+      }
+    });
+    restForwarderCounts.set(ctx.componentPath.node, count);
+    return count;
+  }
   function collectPropBindings(path, attrs) {
     const ctx = resolvePropContext(path);
-    if (!ctx || ctx.propMap.size === 0) return { bindings: [], owner: null };
+    if (!ctx || ctx.propMap.size === 0 && ctx.restParam === null) {
+      return { bindings: [], owner: null };
+    }
     if (ctx.componentName === null) return { bindings: [], owner: null };
     const scope = path.scope;
     const bindings = [];
+    if (forwardsOwnerRestChildren(path, ctx) && countRestForwarders(ctx) === 1) {
+      bindings.push({ target: "children", prop: "children", kind: "direct" });
+    }
     const elementPath = path.parentPath;
     if (elementPath && elementPath.isJSXElement()) {
       const children = meaningfulChildren(t, elementPath.node.children);
@@ -709,7 +784,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
           return;
         }
         let rootName = null;
-        if (t.isJSXIdentifier(path.node.name)) {
+        if (isIntrinsicTagName(path.node.name)) {
+          rootName = null;
+        } else if (t.isJSXIdentifier(path.node.name)) {
           rootName = path.node.name.name;
         } else if (t.isJSXMemberExpression(path.node.name)) {
           let cur = path.node.name;
@@ -771,6 +848,15 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
             t.objectProperty(t.identifier("slot"), t.stringLiteral(slot))
           );
         }
+        if (!isHostElement) {
+          const childrenText = describeChildrenText(path);
+          metaObj.properties.push(
+            t.objectProperty(
+              t.identifier("childrenText"),
+              childrenText === null ? t.nullLiteral() : t.stringLiteral(childrenText)
+            )
+          );
+        }
         if (bindings.length > 0) {
           metaObj.properties.push(
             t.objectProperty(t.identifier("propBindings"), propBindingsToAst(bindings))

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   __dirname,
   babelPluginEditorMeta
-} from "./chunk-6QB35SLQ.mjs";
+} from "./chunk-O3UMTM4N.mjs";
 
 // src/index.ts
 import { readFileSync } from "fs";

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.42",
   "description": "DevTools for Archie generated applications - Route synchronization and editor communication",
   "repository": {
     "type": "git",