@archie/devtools 0.0.22 → 0.0.24

package/dist/index.mjs

@@ -178,6 +178,36 @@ function babelPluginDndAuto({ types: t }, opts = {}) {
 
 // src/babel-plugin-editor-meta.ts
 import * as nodePath from "path";
+var KIT_SLOT_ATTR = "data-kit-slot";
+var MAX_SLOT_SEGMENTS = 4;
+var NON_BINDING_ATTRS = /* @__PURE__ */ new Set(["__editorMeta", "key", "ref", KIT_SLOT_ATTR]);
+var STRUCTURAL_ATTRS = /* @__PURE__ */ new Set([
+  "id",
+  "htmlFor",
+  "slot",
+  "name",
+  "type",
+  "role",
+  // The camelCase carrier of the SAME durable key as `data-agent-id`: kit
+  // components take `agentId` and render it as the data attribute. Found on the
+  // real corpus (×4) — blocking only the dashed form would have left the prop
+  // form routable, and a durable key with a string-literal usage value sails
+  // straight through the usage-value law.
+  "agentId"
+]);
+function isNonContentAttribute(name) {
+  if (/^on[A-Z]/.test(name)) return true;
+  if (name.startsWith("data-")) return true;
+  return STRUCTURAL_ATTRS.has(name);
+}
+function normalizeSlot(raw) {
+  const value = raw.trim();
+  if (!value) return null;
+  const segments = value.split("/");
+  if (segments.length > MAX_SLOT_SEGMENTS) return null;
+  if (segments.some((segment) => segment.trim() === "")) return null;
+  return value;
+}
 function isPackageImport(src) {
   if (src.startsWith(".") || src.startsWith("/")) return false;
   if (src.startsWith("@")) {
@@ -193,7 +223,8 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
   const {
     fileExclude = /node_modules/,
     instrumentImported = true,
-    includeHostSourceRef = false
+    includeHostSourceRef = false,
+    origin = "screen"
   } = opts;
   function getJSXTagName(el) {
     const { name } = el;
@@ -306,29 +337,275 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return false;
   }
+  function buildPayloadFilter(payload) {
+    return t.callExpression(
+      t.arrowFunctionExpression(
+        [
+          t.objectPattern([
+            t.objectProperty(
+              t.identifier("__editorMeta"),
+              t.identifier("_$em"),
+              false,
+              false
+            ),
+            t.objectProperty(
+              t.stringLiteral(KIT_SLOT_ATTR),
+              t.identifier("_$ks"),
+              false,
+              false
+            ),
+            t.restElement(t.identifier("_$r"))
+          ])
+        ],
+        t.identifier("_$r")
+      ),
+      [t.objectExpression([t.spreadElement(payload)])]
+    );
+  }
   function sanitizeSpreadAttributes(attrs) {
     for (const attr of attrs) {
       if (!t.isJSXSpreadAttribute(attr)) continue;
       if (isMetaStripSpreadExpression(attr.argument)) continue;
-      const origArg = attr.argument;
-      attr.argument = t.callExpression(
-        t.arrowFunctionExpression(
-          [
-            t.objectPattern([
-              t.objectProperty(
-                t.identifier("__editorMeta"),
-                t.identifier("_$em"),
-                false,
-                false
-              ),
-              t.restElement(t.identifier("_$r"))
-            ])
-          ],
-          t.identifier("_$r")
-        ),
-        [t.objectExpression([t.spreadElement(origArg)])]
-      );
+      attr.argument = buildPayloadFilter(attr.argument);
+    }
+  }
+  function consumeKitSlot(attrs) {
+    let slot = null;
+    let found = false;
+    for (const attr of attrs) {
+      if (!t.isJSXAttribute(attr)) continue;
+      if (!t.isJSXIdentifier(attr.name, { name: KIT_SLOT_ATTR })) continue;
+      found = true;
+      if (slot !== null) continue;
+      const { value } = attr;
+      if (t.isStringLiteral(value)) {
+        slot = normalizeSlot(value.value);
+      } else if (t.isJSXExpressionContainer(value) && t.isStringLiteral(value.expression)) {
+        slot = normalizeSlot(value.expression.value);
+      }
+    }
+    if (!found) return { slot: null, found: false, attrs };
+    return {
+      slot,
+      found: true,
+      attrs: attrs.filter(
+        (attr) => !(t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: KIT_SLOT_ATTR }))
+      )
+    };
+  }
+  function getFunctionName(fn) {
+    const node = fn.node;
+    if (t.isFunctionDeclaration(node) && node.id) return node.id.name;
+    if (t.isFunctionExpression(node) && node.id) return node.id.name;
+    const parent = fn.parentPath;
+    if (parent?.isVariableDeclarator() && t.isIdentifier(parent.node.id)) {
+      return parent.node.id.name;
+    }
+    return null;
+  }
+  function buildPropMap(pattern) {
+    const map = /* @__PURE__ */ new Map();
+    for (const prop of pattern.properties) {
+      if (!t.isObjectProperty(prop) || prop.computed) continue;
+      const key = t.isIdentifier(prop.key) ? prop.key.name : t.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      const value = prop.value;
+      if (t.isIdentifier(value)) {
+        map.set(value.name, key);
+      } else if (t.isAssignmentPattern(value) && t.isIdentifier(value.left)) {
+        map.set(value.left.name, key);
+      }
     }
+    return map;
+  }
+  function resolvePropContext(path2) {
+    let fn = path2.getFunctionParent();
+    while (fn) {
+      const [first] = fn.node.params;
+      if (first && t.isObjectPattern(first)) {
+        if (fn.scope.parent !== fn.scope.getProgramParent()) return null;
+        return {
+          componentScope: fn.scope,
+          propMap: buildPropMap(first),
+          componentName: getFunctionName(fn)
+        };
+      }
+      fn = fn.getFunctionParent();
+    }
+    return null;
+  }
+  function resolveProp(name, scope, ctx) {
+    const prop = ctx.propMap.get(name);
+    if (!prop) return null;
+    const binding = scope.getBinding(name);
+    if (!binding) return null;
+    if (binding.scope !== ctx.componentScope) return null;
+    if (!binding.constant) return null;
+    return prop;
+  }
+  function isScopeWithinComponent(scope, ctx) {
+    let current = scope;
+    while (current) {
+      if (current === ctx.componentScope) return true;
+      current = current.parent;
+    }
+    return false;
+  }
+  function resolveLocalConstInit(name, scope, ctx) {
+    const binding = scope.getBinding(name);
+    if (!binding) return null;
+    if (!binding.constant) return null;
+    const declarator = binding.path;
+    if (!declarator.isVariableDeclarator()) return null;
+    if (!isScopeWithinComponent(binding.scope, ctx)) return null;
+    const init = declarator.node.init;
+    if (!init || !t.isExpression(init)) return null;
+    return { init, scope: declarator.scope };
+  }
+  function isStaticStringLiteral(node) {
+    if (t.isStringLiteral(node)) return true;
+    return t.isTemplateLiteral(node) && node.expressions.length === 0;
+  }
+  function collectPropIdentifiers(node, scope, ctx, out = []) {
+    if (!node) return out;
+    const visit = (child) => collectPropIdentifiers(child, scope, ctx, out);
+    if (t.isIdentifier(node)) {
+      const prop = resolveProp(node.name, scope, ctx);
+      if (prop && !out.includes(prop)) out.push(prop);
+      return out;
+    }
+    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+      visit(node.object);
+      if (node.computed) visit(node.property);
+      return out;
+    }
+    if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {
+      visit(node.callee);
+      node.arguments.forEach((arg) => visit(arg));
+      return out;
+    }
+    if (t.isTemplateLiteral(node)) {
+      node.expressions.forEach((expr) => visit(expr));
+      return out;
+    }
+    if (t.isConditionalExpression(node)) {
+      visit(node.test);
+      visit(node.consequent);
+      visit(node.alternate);
+      return out;
+    }
+    if (t.isLogicalExpression(node) || t.isBinaryExpression(node)) {
+      visit(node.left);
+      visit(node.right);
+      return out;
+    }
+    if (t.isUnaryExpression(node) || t.isAwaitExpression(node)) {
+      visit(node.argument);
+      return out;
+    }
+    if (t.isArrayExpression(node)) {
+      node.elements.forEach((el) => visit(el));
+      return out;
+    }
+    if (t.isObjectExpression(node)) {
+      for (const prop of node.properties) {
+        if (t.isObjectProperty(prop)) {
+          if (prop.computed) visit(prop.key);
+          visit(prop.value);
+        } else if (t.isSpreadElement(prop)) {
+          visit(prop.argument);
+        }
+      }
+      return out;
+    }
+    if (t.isSpreadElement(node)) {
+      visit(node.argument);
+      return out;
+    }
+    if (t.isTSAsExpression(node) || t.isTSNonNullExpression(node) || t.isTypeCastExpression(node)) {
+      visit(node.expression);
+      return out;
+    }
+    return out;
+  }
+  function classifyExpression(expr, scope, ctx, hop) {
+    if (t.isIdentifier(expr)) {
+      const prop = resolveProp(expr.name, scope, ctx);
+      if (prop) return { kind: "direct", prop };
+      if (hop > 0) return null;
+      const local = resolveLocalConstInit(expr.name, scope, ctx);
+      if (!local) return null;
+      const inner = classifyExpression(local.init, local.scope, ctx, hop + 1);
+      if (!inner) return null;
+      return { kind: inner.kind === "formatted" ? "formatted" : "derived", prop: inner.prop };
+    }
+    if (t.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??") && isStaticStringLiteral(expr.right)) {
+      const left = classifyExpression(expr.left, scope, ctx, hop);
+      if (!left) return null;
+      return { kind: left.kind === "formatted" ? "formatted" : "derived", prop: left.prop };
+    }
+    const props = collectPropIdentifiers(expr, scope, ctx);
+    return props.length > 0 ? { kind: "formatted", prop: props[0] } : null;
+  }
+  function meaningfulChildren(children) {
+    return children.filter((child) => {
+      if (t.isJSXText(child)) return child.value.trim() !== "";
+      if (t.isJSXExpressionContainer(child)) return !t.isJSXEmptyExpression(child.expression);
+      return true;
+    });
+  }
+  function collectPropBindings(path2, attrs) {
+    const ctx = resolvePropContext(path2);
+    if (!ctx || ctx.propMap.size === 0) return { bindings: [], owner: null };
+    if (ctx.componentName === null) return { bindings: [], owner: null };
+    const scope = path2.scope;
+    const bindings = [];
+    const elementPath = path2.parentPath;
+    if (elementPath && elementPath.isJSXElement()) {
+      const children = meaningfulChildren(elementPath.node.children);
+      const isSoleChild = children.length === 1;
+      for (const child of children) {
+        if (!t.isJSXExpressionContainer(child)) continue;
+        const expression = child.expression;
+        if (t.isJSXEmptyExpression(expression)) continue;
+        const verdict = classifyExpression(expression, scope, ctx, 0);
+        if (!verdict) continue;
+        bindings.push({
+          target: "children",
+          prop: verdict.prop,
+          kind: isSoleChild ? verdict.kind : "formatted"
+        });
+      }
+    }
+    for (const attr of attrs) {
+      if (!t.isJSXAttribute(attr)) continue;
+      const name = t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+      if (NON_BINDING_ATTRS.has(name)) continue;
+      const value = attr.value;
+      if (!t.isJSXExpressionContainer(value)) continue;
+      const expression = value.expression;
+      if (t.isJSXEmptyExpression(expression)) continue;
+      const verdict = classifyExpression(expression, scope, ctx, 0);
+      if (!verdict) continue;
+      bindings.push({
+        target: `attr:${name}`,
+        prop: verdict.prop,
+        // M2b: machine-contract attributes are reported, never offered.
+        kind: isNonContentAttribute(name) ? "formatted" : verdict.kind
+      });
+    }
+    return { bindings, owner: bindings.length > 0 ? ctx.componentName : null };
+  }
+  function propBindingsToAst(bindings) {
+    return t.arrayExpression(
+      bindings.map(
+        (binding) => t.objectExpression([
+          t.objectProperty(t.identifier("target"), t.stringLiteral(binding.target)),
+          t.objectProperty(t.identifier("prop"), t.stringLiteral(binding.prop)),
+          t.objectProperty(t.identifier("kind"), t.stringLiteral(binding.kind))
+        ])
+      )
+    );
   }
   return {
     name: "babel-plugin-editor-meta",
@@ -356,25 +633,13 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
         if (!propsArg || t.isNullLiteral(propsArg)) return;
         if (!t.isExpression(propsArg)) return;
         if (isMetaStripSpreadExpression(propsArg)) return;
-        args[1] = t.callExpression(
-          t.arrowFunctionExpression(
-            [
-              t.objectPattern([
-                t.objectProperty(
-                  t.identifier("__editorMeta"),
-                  t.identifier("_$em"),
-                  false,
-                  false
-                ),
-                t.restElement(t.identifier("_$r"))
-              ])
-            ],
-            t.identifier("_$r")
-          ),
-          [t.objectExpression([t.spreadElement(propsArg)])]
-        );
+        args[1] = buildPayloadFilter(propsArg);
       },
       JSXOpeningElement(path2, state) {
+        const consumed = consumeKitSlot(path2.node.attributes);
+        path2.node.attributes = consumed.attrs;
+        const slot = consumed.slot;
+        const hasSlotAttr = consumed.found;
         const filename = state.filename ?? "";
         if (fileExclude.test(filename)) return;
         const existing = path2.node.attributes.find(
@@ -420,9 +685,11 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
           }
         }
         const nodeId = computeNodeId(file, line, col, componentName);
-        const movable = isMovable(path2);
+        const isKitOrigin = origin === "kit" || hasSlotAttr;
+        const movable = isKitOrigin ? false : isMovable(path2);
         const parentNodeId = getParentNodeId(path2, file);
         const staticPropsObj = extractStaticProps(path2.node.attributes);
+        const { bindings, owner } = collectPropBindings(path2, path2.node.attributes);
         const metaObj = t.objectExpression([
           t.objectProperty(t.identifier("nodeId"), t.stringLiteral(nodeId)),
           t.objectProperty(t.identifier("file"), t.stringLiteral(file)),
@@ -439,6 +706,22 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
             parentNodeId ? t.stringLiteral(parentNodeId) : t.nullLiteral()
           )
         ]);
+        if (slot !== null) {
+          metaObj.properties.push(
+            t.objectProperty(t.identifier("slot"), t.stringLiteral(slot))
+          );
+        }
+        if (bindings.length > 0) {
+          metaObj.properties.push(
+            t.objectProperty(t.identifier("propBindings"), propBindingsToAst(bindings))
+          );
+          metaObj.properties.push(
+            t.objectProperty(
+              t.identifier("propOwner"),
+              owner ? t.stringLiteral(owner) : t.nullLiteral()
+            )
+          );
+        }
         if (isHostElement && includeHostSourceRef) {
           path2.node.attributes.push(
             t.jsxAttribute(
@@ -447,10 +730,11 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
             )
           );
         }
+        const metaThunk = t.arrowFunctionExpression([], metaObj);
         path2.node.attributes.push(
           t.jsxAttribute(
             t.jsxIdentifier("__editorMeta"),
-            t.jsxExpressionContainer(metaObj)
+            t.jsxExpressionContainer(metaThunk)
           )
         );
       }

package/dist/inspector.standalone.js

@@ -95,6 +95,28 @@
       var FIBER_KEY_PREFIX = "__reactFiber$"
       var PROPS_KEY_PREFIX = "__reactProps$"
 
+      // ARCH-883 P0-1: babel-plugin-editor-meta.ts (TypeScript context) now
+      // emits __editorMeta as a zero-arg function, not the object literal
+      // directly, so React never writes it into the DOM. Every extraction
+      // site below must invoke the value when it is a function. Mirrors
+      // readEditorMetaValue in fiber-bridge.ts — if this changes, update
+      // that copy to maintain parity.
+      function resolveEditorMetaValue(value) {
+        if (typeof value === "function") {
+          // Each call re-evaluates the plugin-emitted `() => ({...})`
+          // closure and returns a FRESH object literal — never rely on
+          // meta object identity (`===`) across two separate reads, even
+          // within the same render (mirrors readEditorMetaValue in
+          // fiber-bridge.ts).
+          return value()
+        }
+        // Twin parity with fiber-bridge.ts's readEditorMetaValue: only
+        // undefined/null is a miss, not "any falsy value" — __editorMeta is
+        // always an object or a function in practice, so this is a no-op
+        // today, but keeps the two implementations provably equivalent.
+        return value === undefined || value === null ? null : value
+      }
+
       function hasEditorMetaInFiberChain(fiber) {
         var current = fiber
         while (current) {
@@ -195,7 +217,7 @@
         var fiber = getFiberFromElement(el)
         while (fiber) {
           if (fiber.memoizedProps && fiber.memoizedProps.__editorMeta) {
-            return fiber.memoizedProps.__editorMeta
+            return resolveEditorMetaValue(fiber.memoizedProps.__editorMeta)
           }
           fiber = fiber["return"]
         }
@@ -205,7 +227,7 @@
       function getDirectEditorMetaFromElement(el) {
         var fiber = getFiberFromElement(el)
         if (fiber && fiber.memoizedProps && fiber.memoizedProps.__editorMeta) {
-          return fiber.memoizedProps.__editorMeta
+          return resolveEditorMetaValue(fiber.memoizedProps.__editorMeta)
         }
         return null
       }
@@ -231,7 +253,7 @@
             break
           }
           if (current.memoizedProps && current.memoizedProps.__editorMeta) {
-            return current.memoizedProps.__editorMeta
+            return resolveEditorMetaValue(current.memoizedProps.__editorMeta)
           }
           current = current["return"]
         }
@@ -252,6 +274,156 @@
         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,
+        }
+      }
+
       if (window._inspectorSharedTargetObserver) {
         try {
           window._inspectorSharedTargetObserver.disconnect()
@@ -864,9 +1036,14 @@
       postMessageToParent({
         type: "INSPECTOR_SCRIPT_LOADED",
         timestamp: Date.now(),
-        version: "2.1.0",
+        version: "2.1.1",
         protocolVersion: 1,
         capabilities: {
+          // 2.1.1: function-valued __editorMeta props are invoked before any
+          // postMessage, so meta payloads stay structured-cloneable. Hosts can
+          // gate on this bit to confirm the deployed CDN artifact carries the
+          // fix (the 2.1.0 URL is overwritten in place on publish).
+          functionValuedEditorMeta: true,
           inspect: true,
           dndMove: true,
           dndResize: true,
@@ -2020,7 +2197,49 @@
             : null,
           attributes: attributes,
           inspectorSource: inspectorInfo,
+          // ARCH-883 F1 — FORWARD THE META WHOLE. The plugin now also emits
+          // `slot`, `propBindings` and `propOwner` (SDD §2.3/§2.6) and the editor
+          // host routes edits off them; field-picking here would silently strip
+          // them and turn every kit-internal edit into a gap. `inspectorSource`
+          // above is the deliberately narrow structure — this one is not.
+          //
+          // Unlike P0-1 this needs no deploy ordering: the extra keys are plain
+          // data, so an already-published standalone.js forwards them unchanged
+          // through `postMessage`'s structured clone. Whether a given PAGE has
+          // them depends on the plugin that built it, which the host resolves via
+          // `deriveEditorCapabilities(kitRuntimeVersion)` (SDD §2.5) — never from
+          // 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),
           computedStyles: {
             display: computed.display,
             position: computed.position,