@archie/devtools 0.0.26 → 0.0.27

package/dist/chunk-4VGQJ3PW.mjs

@@ -0,0 +1,577 @@
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// src/babel-plugin-editor-meta.ts
+import * as nodePath from "path";
+function meaningfulChildren(t, children) {
+  return children.filter((child) => {
+    if (t.isJSXText(child)) return child.value.trim() !== "";
+    if (t.isJSXExpressionContainer(child)) return !t.isJSXEmptyExpression(child.expression);
+    return true;
+  });
+}
+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("@")) {
+    const slashIdx = src.indexOf("/");
+    if (slashIdx === 1) return false;
+    if (slashIdx > 1) return true;
+    return true;
+  }
+  if (src.startsWith("~/") || src.startsWith("#/")) return false;
+  return true;
+}
+function babelPluginEditorMeta({ types: t }, opts = {}) {
+  const {
+    fileExclude = /node_modules/,
+    instrumentImported = true,
+    includeHostSourceRef = false,
+    origin = "screen"
+  } = opts;
+  function getJSXTagName(el) {
+    const { name } = el;
+    if (t.isJSXIdentifier(name)) return name.name;
+    if (t.isJSXMemberExpression(name)) {
+      const parts = [];
+      let current = name;
+      while (t.isJSXMemberExpression(current)) {
+        parts.unshift(current.property.name);
+        current = current.object;
+      }
+      if (t.isJSXIdentifier(current)) parts.unshift(current.name);
+      return parts.join(".");
+    }
+    return "";
+  }
+  function isHostLikeMemberExpressionName(name) {
+    if (!t.isJSXMemberExpression(name)) return false;
+    const propertyName = name.property.name;
+    return propertyName[0] === propertyName[0].toLowerCase();
+  }
+  function computeNodeId(file, line, col, componentName) {
+    return `${file}:${line}:${col}:${componentName}`;
+  }
+  function isMovable(path2) {
+    const elPath = path2.parentPath;
+    if (!elPath) return false;
+    const parentEl = elPath.parentPath;
+    if (!parentEl || !parentEl.isJSXElement()) return false;
+    const siblings = parentEl.node.children.filter(
+      (c) => t.isJSXElement(c)
+    );
+    return siblings.length >= 2;
+  }
+  function getParentNodeId(path2, file) {
+    const elPath = path2.parentPath;
+    if (!elPath) return null;
+    let ancestor = elPath.parentPath;
+    while (ancestor) {
+      if (ancestor.isJSXElement()) {
+        const opening = ancestor.node.openingElement;
+        const loc = opening.loc?.start;
+        if (loc) {
+          const tag = getJSXTagName(opening);
+          return computeNodeId(file, loc.line, loc.column + 1, tag);
+        }
+        return null;
+      }
+      ancestor = ancestor.parentPath;
+    }
+    return null;
+  }
+  function extractStaticProps(attrs) {
+    const props = [];
+    let hasAny = false;
+    for (const attr of attrs) {
+      if (t.isJSXSpreadAttribute(attr)) continue;
+      if (!t.isJSXAttribute(attr)) continue;
+      const keyName = t.isJSXIdentifier(attr.name) ? attr.name.name : attr.name.name.name;
+      if (keyName === "__editorMeta") continue;
+      let value;
+      if (attr.value === null || attr.value === void 0) {
+        value = t.booleanLiteral(true);
+      } else if (t.isStringLiteral(attr.value)) {
+        value = attr.value;
+      } else if (t.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t.isNumericLiteral(expr)) {
+          value = expr;
+        } else if (t.isBooleanLiteral(expr)) {
+          value = expr;
+        } else if (t.isNullLiteral(expr)) {
+          value = expr;
+        } else if (t.isStringLiteral(expr)) {
+          value = expr;
+        } else {
+          value = t.stringLiteral("__dynamic__");
+        }
+      } else {
+        continue;
+      }
+      props.push(t.objectProperty(t.stringLiteral(keyName), value));
+      hasAny = true;
+    }
+    return hasAny ? t.objectExpression(props) : null;
+  }
+  function isMetaStripSpreadExpression(arg) {
+    if (!t.isCallExpression(arg)) return false;
+    if (!t.isArrowFunctionExpression(arg.callee)) return false;
+    const [firstParam] = arg.callee.params;
+    if (!firstParam || !t.isObjectPattern(firstParam)) return false;
+    return firstParam.properties.some((prop) => {
+      if (!t.isObjectProperty(prop)) return false;
+      if (!t.isIdentifier(prop.key)) return false;
+      return prop.key.name === "__editorMeta";
+    });
+  }
+  function hasTruthyAsChildProp(attrs) {
+    for (const attr of attrs) {
+      if (!t.isJSXAttribute(attr) || !t.isJSXIdentifier(attr.name, { name: "asChild" })) {
+        continue;
+      }
+      if (attr.value == null) return true;
+      if (t.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t.isBooleanLiteral(expr)) return expr.value;
+      }
+      if (t.isStringLiteral(attr.value)) return attr.value.value !== "false";
+      return true;
+    }
+    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;
+      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) && fn.scope.parent === fn.scope.getProgramParent()) {
+        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 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(t, 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",
+    visitor: {
+      CallExpression(path2, state) {
+        const filename = state.filename ?? "";
+        if (fileExclude.test(filename)) return;
+        const callee = path2.node.callee;
+        let isCreateElement = false;
+        let isCloneElement = false;
+        if (t.isIdentifier(callee, { name: "createElement" })) {
+          isCreateElement = true;
+        } else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property, { name: "createElement" })) {
+          isCreateElement = true;
+        } else if (t.isIdentifier(callee, { name: "cloneElement" })) {
+          isCloneElement = true;
+        } else if (t.isMemberExpression(callee) && t.isIdentifier(callee.property, { name: "cloneElement" })) {
+          isCloneElement = true;
+        }
+        if (!isCreateElement && !isCloneElement) return;
+        const args = path2.node.arguments;
+        if (args.length < 2) return;
+        if (isCreateElement && !t.isStringLiteral(args[0])) return;
+        const propsArg = args[1];
+        if (!propsArg || t.isNullLiteral(propsArg)) return;
+        if (!t.isExpression(propsArg)) return;
+        if (isMetaStripSpreadExpression(propsArg)) return;
+        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(
+          (a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name: "__editorMeta" })
+        );
+        if (existing) return;
+        const loc = path2.node.loc?.start;
+        if (!loc) return;
+        const root = state.file.opts.root ?? "";
+        const file = root ? nodePath.relative(root, filename) : filename;
+        const line = loc.line;
+        const col = loc.column + 1;
+        const componentName = getJSXTagName(path2.node);
+        if (!componentName) return;
+        const isHostLikeMemberExpression = isHostLikeMemberExpressionName(path2.node.name);
+        const isHostElement = componentName[0] === componentName[0].toLowerCase();
+        sanitizeSpreadAttributes(path2.node.attributes);
+        if (hasTruthyAsChildProp(path2.node.attributes)) {
+          return;
+        }
+        let rootName = null;
+        if (t.isJSXIdentifier(path2.node.name)) {
+          rootName = path2.node.name.name;
+        } else if (t.isJSXMemberExpression(path2.node.name)) {
+          let cur = path2.node.name;
+          while (t.isJSXMemberExpression(cur)) cur = cur.object;
+          if (t.isJSXIdentifier(cur)) rootName = cur.name;
+        }
+        if (rootName) {
+          const binding = path2.scope.getBinding(rootName);
+          if (binding) {
+            const bp = binding.path;
+            if (bp.isImportSpecifier() || bp.isImportDefaultSpecifier() || bp.isImportNamespaceSpecifier()) {
+              if (!instrumentImported) return;
+              const decl = bp.parentPath;
+              if (decl?.isImportDeclaration()) {
+                const src = decl.node.source.value;
+                if (isPackageImport(src) && !isHostLikeMemberExpression) return;
+              }
+            }
+            const programScope = path2.scope.getProgramParent();
+            if (binding.scope !== programScope) return;
+          }
+        }
+        const nodeId = computeNodeId(file, line, col, componentName);
+        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)),
+          t.objectProperty(t.identifier("line"), t.numericLiteral(line)),
+          t.objectProperty(t.identifier("col"), t.numericLiteral(col)),
+          t.objectProperty(t.identifier("componentName"), t.stringLiteral(componentName)),
+          t.objectProperty(
+            t.identifier("staticProps"),
+            staticPropsObj ?? t.nullLiteral()
+          ),
+          t.objectProperty(t.identifier("movable"), t.booleanLiteral(movable)),
+          t.objectProperty(
+            t.identifier("parentNodeId"),
+            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(
+              t.jsxIdentifier("data-archie-source-ref"),
+              t.stringLiteral(`${file}::${line}::${col}`)
+            )
+          );
+        }
+        const metaThunk = t.arrowFunctionExpression([], metaObj);
+        path2.node.attributes.push(
+          t.jsxAttribute(
+            t.jsxIdentifier("__editorMeta"),
+            t.jsxExpressionContainer(metaThunk)
+          )
+        );
+      }
+    }
+  };
+}
+
+export {
+  __dirname,
+  meaningfulChildren,
+  babelPluginEditorMeta
+};

package/dist/client/client.js

@@ -4098,6 +4098,19 @@ function dispatchRuntimeEvent(detail) {
   if (typeof window === "undefined") return;
   window.dispatchEvent(new CustomEvent(DND_RUNTIME_EVENT, { detail }));
 }
+function resolveRowBinding(el) {
+  let node = el;
+  for (let depth = 0; node && depth < MAX_ROW_BINDING_ANCESTOR_DEPTH; depth += 1) {
+    const rowId = node.getAttribute("data-agent-row");
+    if (rowId !== null && rowId !== "") {
+      const entity = node.getAttribute("data-agent-entity");
+      return entity ? { entity, rowId } : null;
+    }
+    node = node.parentElement;
+  }
+  return null;
+}
+var MAX_ROW_BINDING_ANCESTOR_DEPTH = 12;
 function mergeInspectorTheme(theme) {
   return {
     ...DEFAULT_INSPECTOR_THEME,
@@ -4484,16 +4497,6 @@ function createCommitLaneIdentitySnapshot(params) {
     committable: true
   };
 }
-function hasSafeOccurrenceIdentities(lane, duplicateNodeKey) {
-  const effectiveNodeIds = lane.commitNodeIds.filter(
-    (commitNodeId) => lane.nodeKeysByCommitNodeId.get(commitNodeId) === duplicateNodeKey
-  ).map(
-    (commitNodeId) => lane.effectiveNodeIdsByCommitNodeId.get(commitNodeId) ?? null
-  );
-  return effectiveNodeIds.length > 1 && effectiveNodeIds.every(
-    (effectiveNodeId) => typeof effectiveNodeId === "string" && effectiveNodeId.length > 0
-  ) && new Set(effectiveNodeIds).size === effectiveNodeIds.length;
-}
 function buildLanePersistenceDiagnostics(params) {
   const duplicateNodeKeys = detectDuplicateSourceBackedNodeKeys(
     buildNodeKeysFromCommitIds(
@@ -4504,24 +4507,10 @@ function buildLanePersistenceDiagnostics(params) {
   if (duplicateNodeKeys.length === 0) {
     return null;
   }
-  const safeDuplicateNodeKeys = duplicateNodeKeys.filter(
-    (nodeKey) => hasSafeOccurrenceIdentities(params.lane, nodeKey)
-  );
-  if (safeDuplicateNodeKeys.length === duplicateNodeKeys.length) {
-    return {
-      notes: safeDuplicateNodeKeys.map(
-        (nodeKey) => `Arrange lane ${params.lane.laneContainerId} repeats source-backed nodeKey ${nodeKey}, but runtime assigned explicit occurrence identities for each commit root.`
-      )
-    };
-  }
   return {
-    structurallyUnsafe: true,
-    blockedReasons: duplicateNodeKeys.map(
-      (nodeKey) => `Arrange lane ${params.lane.laneContainerId} contains multiple commit roots with the same source-backed nodeKey (${nodeKey}), so local save is unsafe.`
-    ),
-    notes: [
-      `Lane ${params.lane.laneContainerId} duplicates source-backed nodeKeys: ${duplicateNodeKeys.join(", ")}`
-    ]
+    notes: duplicateNodeKeys.map(
+      (nodeKey) => `Arrange lane ${params.lane.laneContainerId} repeats source-backed nodeKey ${nodeKey}, but runtime assigned explicit occurrence identities for each commit root.`
+    )
   };
 }
 function removeCommitNodeId(commitNodeIds, commitNodeId) {
@@ -4736,6 +4725,7 @@ var useDesignModeStore = create((set, get) => ({
     beforeSibling,
     afterSibling,
     diagnostics,
+    binding,
     componentName,
     before,
     after
@@ -4762,6 +4752,7 @@ var useDesignModeStore = create((set, get) => ({
       beforeSibling: beforeSibling ?? null,
       afterSibling: afterSibling ?? null,
       diagnostics: diagnostics ?? null,
+      binding: binding ?? null,
       payload: { before, after },
       at: now
     };
@@ -6451,6 +6442,8 @@ function serializeArrangeChange(event, index) {
     sourceBeforeSibling: event.kind === "move" ? event.sourceBeforeSibling : void 0,
     sourceAfterSibling: event.kind === "move" ? event.sourceAfterSibling : void 0,
     diagnostics: event.kind === "move" ? event.diagnostics : void 0,
+    // ARCH-1065 D17 — which slice row this move addresses.
+    binding: event.kind === "move" ? event.binding : void 0,
     // Insert-specific fields
     displayName: event.kind === "insert" ? event.displayName : void 0,
     html: event.kind === "insert" ? event.html : void 0,
@@ -7981,6 +7974,7 @@ function recordCommittedMove(args) {
   });
   const componentName = getEditorMeta(anchorEl)?.componentName;
   const operationId = `${command.at}:${anchorNodeId}`;
+  const binding = resolveRowBinding(selectedEl);
   const beforePayload = buildMovePayloadWithEffectiveIdentities({
     placement: command.from,
     containerIdentity: sourceContainerIdentity,
@@ -8010,6 +8004,7 @@ function recordCommittedMove(args) {
     sourceBeforeSibling: sourceBeforeSiblingIdentity,
     sourceAfterSibling: sourceAfterSiblingIdentity,
     diagnostics,
+    binding,
     container: containerIdentity,
     beforeSibling: beforeSiblingIdentity,
     afterSibling: afterSiblingIdentity,