@archie/devtools 0.1.4 → 0.1.6

package/README.md

@@ -114,6 +114,21 @@ Consume `@8base-archie/editor-protocol` como fuente única del contrato
 (`Vid`, `NodeMeta`, `LockReason`, los schemas Zod) — ver
 `src/types/editor-meta.ts`, que re-exporta esos tipos en vez de duplicarlos.
 
+### `data-vid` en build de producción
+
+En `vite build` (`command === 'build'`), `archieDevTools()` elimina el
+atributo JSX `data-vid` del código generado — nada en el pipeline de deploy
+lo hace por su cuenta, y el atributo no aporta nada en runtime (la identidad
+sigue disponible vía `__editorMeta.vid`, que no se toca). Solo `vite dev`
+conserva `data-vid` sin cambios: este plugin corre en `transform`, así que
+`vite preview` sirve el `dist/` ya construido por `vite build` y por lo
+tanto NO conserva `data-vid` — es el mismo build de producción, no un
+comando propio de este plugin. Opt-out explícito:
+
+```ts
+archieDevTools({ stripVidsInBuild: false })
+```
+
 ## Local linking
 
 ```bash
@@ -138,3 +153,16 @@ Tests follow a colocated-by-feature convention:
 - small modules keep `*.test.ts(x)` beside the source file
 - larger subsystems may use a local `__tests__/` folder next to the feature
 - `src/client/dnd/design-mode/__tests__/` is the reference pattern for multi-file feature coverage
+
+## Release notes
+
+### 0.1.5
+
+Treats a JSX comment (`{/* ... */}`) as a plain container, not an expression
+one — a container whose only non-element child is a comment now gets
+`containerKind: 'plain'` instead of `'expression'`. **This is coupled to
+archie-code-generation (acg) PR #416**: acg's own container-kind handling
+must already treat `{/* ... */}` the same way before this version is
+deployed, or containers that used to agree between the two will disagree
+once 0.1.5 ships. No code-level gate enforces the pairing — deploy acg #416
+first (or together with this version), not after.

package/dist/{chunk-U4KG6UDY.mjs → chunk-ZG6HZFTJ.mjs}

@@ -182,6 +182,7 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     const allPlain = children.every((c) => {
       if (t.isJSXElement(c)) return true;
       if (t.isJSXText(c)) return c.value.trim() === "";
+      if (t.isJSXExpressionContainer(c) && t.isJSXEmptyExpression(c.expression)) return true;
       return false;
     });
     return allPlain ? "plain" : "expression";

package/dist/client/client.js

@@ -5169,7 +5169,7 @@ function shouldShowGrabFeedback(target, scannedByNodeId) {
   }
   const nodeId = host.getAttribute(DND_NODE_ID_ATTR);
   const scanned = nodeId ? scannedByNodeId.get(nodeId) : null;
-  return !scanned || scanned.draggable === false;
+  return !scanned || !isEligibleForDrag(scanned);
 }
 function isEligibleForDrag(sc) {
   if (sc.draggable === false) return false;
@@ -5179,6 +5179,9 @@ function isEligibleForDrag(sc) {
   // Section, …) carrying the usage's projected meta.
   source === "projected-usage";
 }
+function filterEligibleForDrag(elements) {
+  return elements.filter(isEligibleForDrag);
+}
 function isPointerInEdgeZone(px, py, guard) {
   return px <= guard || py <= guard || px >= window.innerWidth - guard || py >= window.innerHeight - guard;
 }
@@ -5449,7 +5452,12 @@ function scanElements(root, depth = 0, usedNodeIds = /* @__PURE__ */ new Set(),
               eligibilitySource: smallEligibility,
               draggable: false,
               identityOrigin: templateFrameLabel(identityMeta3),
-              editorMeta: surfaceMeta2
+              // `identityMeta` here is already `projectUsageMeta(el) ??
+              // surfaceMeta` (no `ownerMeta` fallback in this branch) — see
+              // the main scan's own `editorMeta: usageMeta ?? surfaceMeta`
+              // below for the full rationale (ARCH-883-KOI
+              // draggable-eligibility parity fix).
+              editorMeta: identityMeta3
             });
           }
         }
@@ -5524,7 +5532,29 @@ function scanElements(root, depth = 0, usedNodeIds = /* @__PURE__ */ new Set(),
         containerStrategy,
         eligibilitySource: inferredEligibility,
         identityOrigin: templateFrameLabel(identityMeta2),
-        editorMeta: surfaceMeta
+        // `usageMeta ?? surfaceMeta`, NOT `identityMeta` (which also falls
+        // back to `ownerMeta`): `isEligibleForDrag` (`isNonDraggableNodeMeta`)
+        // reads THIS field to gate the actual drag start, and `surfaceMeta`
+        // names the kit TEMPLATE's own meta (`isKitOrigin: true`) for any
+        // kit-rendered host — even one this scan just correctly computed
+        // `draggable: true` for via the SAME `usageMeta` projection above (a
+        // `<Kit.Card>` usage's single host root). Storing `surfaceMeta` here
+        // silently re-refused every such drag at gesture start (ARCH-883-KOI
+        // draggable-eligibility parity fix). Falling back to `identityMeta`
+        // instead of `usageMeta` would overcorrect: `ownerMeta` (a STRUCTURAL
+        // ancestor's meta, borrowed only for `sourceMetaNodeId` on an
+        // inferred-sortable-descendant with no meta of its own) is not this
+        // element's own identity and must not leak into its eligibility/lock
+        // reporting — `scanner-ast-first.test.ts`'s "free of structural owner
+        // meta contamination" pins `editorMeta` staying `undefined` there.
+        //
+        // A meta-less host projected by `computeUsageMeta` onto its component
+        // usage (e.g. `<MetricCard label="x"/>`'s host, `fiber-bridge.ts`)
+        // inherits that usage's own `containerKind` — usually `'none'` for a
+        // self-closing usage — so a drop INTO it now correctly refuses
+        // CONTAINER_NOT_PLAIN: the host is a component instance, not a plain
+        // JSX container in the user's own file, matching acg.
+        editorMeta: usageMeta ?? surfaceMeta
       });
       if (!isSvgRoot) results.push(...scanElements(el, depth + 1, usedNodeIds, seenResolvedHosts, resolvedUnreported));
     } else {
@@ -5548,7 +5578,8 @@ function buildMovedElementEntry(el, usedNodeIds) {
   const parentEl = el.parentElement;
   const surfaceMeta = getDirectEditorMeta(el) ?? void 0;
   const ownerMeta = getEditorMeta(el);
-  const identityMeta2 = projectUsageMeta(el) ?? ownerMeta ?? surfaceMeta;
+  const usageMeta = projectUsageMeta(el);
+  const identityMeta2 = usageMeta ?? ownerMeta ?? surfaceMeta;
   const selector = getUniqueSelector(el);
   const eligibility = isInspectorEligible(el);
   return {
@@ -5569,7 +5600,11 @@ function buildMovedElementEntry(el, usedNodeIds) {
     containerStrategy: parentEl && isFlexOrGridParent(parentEl) ? resolveContainerStrategy(parentEl) : null,
     eligibilitySource: eligibility ?? "force-allow",
     identityOrigin: templateFrameLabel(identityMeta2),
-    editorMeta: surfaceMeta
+    // `usageMeta ?? surfaceMeta`, NOT `identityMeta` — same fix, same reason
+    // as the main scan's own `editorMeta` (see there): `ownerMeta` is a
+    // structural ancestor's meta borrowed only for `sourceMetaNodeId`/
+    // `draggable`, and must not leak into eligibility/lock reporting.
+    editorMeta: usageMeta ?? surfaceMeta
   };
 }
 function useElementScanner(enabled) {
@@ -8303,6 +8338,7 @@ function useDragVisualLoop({
 
 // src/client/dnd/design-mode/useDragLifecycle.ts
 var import_react13 = require("react");
+var GATE_REJECT = "GATE_REJECT";
 function emitRefused(code, cause, vid) {
   dispatchRuntimeEvent({
     type: "drag-refused",
@@ -8323,6 +8359,41 @@ function buildDragIntentEngineOptions(anchorElement, srcContainerId, blockedCont
     blockedContainerIds
   };
 }
+function resolveDragEndRefusal(params) {
+  if (!params.hasDragSession || params.blockedByGuard) return { kind: "silent" };
+  if (!params.hasActiveElement || !params.hasSourcePosition) {
+    return {
+      kind: "refuse",
+      code: GATE_REJECT,
+      cause: "Drag ended with no resolvable source position for the dragged node."
+    };
+  }
+  if (!params.hasNestTarget && !params.intentValid) {
+    return {
+      kind: "refuse",
+      code: GATE_REJECT,
+      cause: "No droppable target was resolved under the pointer for this drag."
+    };
+  }
+  return { kind: "continue" };
+}
+function resolveDragEndBranch(params) {
+  if (!params.dropTargetExistsInMap) return { kind: "refuse", reason: "drop-target-missing" };
+  if (!params.dropTargetIsDroppable) return { kind: "refuse", reason: "drop-target-not-droppable" };
+  if (params.hasNestTarget) {
+    if (params.nestIsSelfOrDescendant) return { kind: "refuse", reason: "nest-self-or-descendant" };
+    if (params.nestIsAncestor) return { kind: "refuse", reason: "nest-ancestor" };
+    if (!params.nestHasCommitNodeId) return { kind: "refuse", reason: "nest-no-commit-node" };
+    return { kind: "nest" };
+  }
+  if (params.intentIsReorder) {
+    if (!params.hasResolvedReorder || !params.resolvedReorderMatchesIntent) {
+      return { kind: "refuse", reason: "stale-reorder" };
+    }
+    return { kind: "reorder" };
+  }
+  return { kind: "refuse", reason: "no-move" };
+}
 function buildRuntimeIdentityLocal(nodeId, resolveNodeElement, effectiveLaneSnapshot) {
   if (!nodeId) return null;
   const element = resolveNodeElement(nodeId);
@@ -8576,7 +8647,7 @@ function useDragLifecycle({
         draggable: found.draggable
       });
       emitRefused(
-        resolveRefusalCode(found.editorMeta, "GATE_REJECT"),
+        resolveRefusalCode(found.editorMeta, GATE_REJECT),
         "Node is not draggable (dynamic render, chrome, or kit-origin).",
         resolveVidForScannedNode(activeId, refs.nodeMapRef.current, found.element)
       );
@@ -8605,7 +8676,7 @@ function useDragLifecycle({
     const anchorScanned = refs.nodeMapRef.current.get(anchor.anchorNodeId) ?? found;
     if (!anchorScanned || !isEligibleForDrag(anchorScanned)) {
       emitRefused(
-        resolveRefusalCode(anchorScanned?.editorMeta, "GATE_REJECT"),
+        resolveRefusalCode(anchorScanned?.editorMeta, GATE_REJECT),
         "Resolved drag anchor is not draggable.",
         resolveVidForScannedNode(
           anchor.anchorNodeId,
@@ -8695,90 +8766,131 @@ function useDragLifecycle({
     const intentHasContainer = intent ? refs.projectionRef.current.containerIndex.has(intent.containerId) : false;
     const intentHasSlot = intent ? intent.mode === "nest" || refs.projectionRef.current.slotIndex.has(intent.slotId) : false;
     const intentValid = !!intent && intentHasContainer && intentHasSlot;
-    if (!blockedByGuard && activeEl && sourcePos && (nestTarget || intentValid)) {
-      const dropTargetId = nestTarget?.nodeId ?? intent?.containerId;
-      if (dropTargetId && !refs.nodeMapRef.current.has(dropTargetId)) {
-        clearDragState();
-        syncHistoryAvailability();
-        return;
-      }
-      if (dropTargetId && !refs.droppableContainerIdsRef.current?.has(dropTargetId)) {
-        const targetContainerEl = resolveNodeElement(dropTargetId);
-        const targetMeta = refs.nodeMapRef.current.get(dropTargetId)?.editorMeta;
-        emitRefused(
-          resolveRefusalCode(targetMeta, "CONTAINER_NOT_PLAIN"),
-          "Drop target is outside the droppable set for this node.",
-          resolveVidForScannedNode(dropTargetId, refs.nodeMapRef.current, targetContainerEl)
-        );
-        clearDragState();
-        syncHistoryAvailability();
-        return;
-      }
-      let command = null;
-      if (nestTarget) {
-        if (!activeEl.contains(nestTarget.element) && !nestTarget.element.contains(activeEl) && sourcePos?.commitNodeId) {
-          const nestPlacement = resolveAppendCommitPlacement(
-            nestTarget.element,
-            sourcePos.commitNodeId,
-            nestTarget.nodeId
+    const anchorVid = () => resolveVidForScannedNode(anchorNodeId, refs.nodeMapRef.current, activeEl);
+    const gate = resolveDragEndRefusal({
+      hasDragSession: !!dragSession,
+      blockedByGuard,
+      hasActiveElement: !!activeEl,
+      hasSourcePosition: !!sourcePos,
+      hasNestTarget: !!nestTarget,
+      intentValid
+    });
+    if (gate.kind === "silent") {
+      clearDragState();
+      syncHistoryAvailability();
+      return;
+    }
+    if (gate.kind === "refuse") {
+      emitRefused(gate.code, gate.cause, anchorVid());
+      clearDragState();
+      syncHistoryAvailability();
+      return;
+    }
+    const el = activeEl;
+    const pos = sourcePos;
+    const dropTargetId = nestTarget?.nodeId ?? intent?.containerId;
+    const resolvedReorder = refs.resolvedReorderRef.current;
+    const branch = resolveDragEndBranch({
+      dropTargetExistsInMap: refs.nodeMapRef.current.has(dropTargetId),
+      dropTargetIsDroppable: !!refs.droppableContainerIdsRef.current?.has(dropTargetId),
+      hasNestTarget: !!nestTarget,
+      nestIsSelfOrDescendant: !!nestTarget && el.contains(nestTarget.element),
+      nestIsAncestor: !!nestTarget && nestTarget.element.contains(el),
+      nestHasCommitNodeId: !!pos.commitNodeId,
+      intentIsReorder: intentValid && intent?.mode === "reorder",
+      hasResolvedReorder: !!resolvedReorder,
+      resolvedReorderMatchesIntent: !!resolvedReorder && !!intent && resolvedReorder.visual.containerId === intent.containerId
+    });
+    if (branch.kind === "refuse") {
+      switch (branch.reason) {
+        case "drop-target-missing":
+          emitRefused(
+            "VID_NOT_FOUND",
+            "Drop target no longer exists.",
+            resolveVidForScannedNodeStrict(dropTargetId, refs.nodeMapRef.current)
           );
-          command = {
-            type: classifyCommandType(sourcePos, nestPlacement, true),
-            nodeId: anchorNodeId,
-            commitNodeId: sourcePos.commitNodeId,
-            from: sourcePos,
-            to: nestPlacement,
-            at: Date.now()
-          };
-        }
-      } else if (intentValid && intent.mode === "reorder") {
-        const resolvedReorder = refs.resolvedReorderRef.current;
-        if (!resolvedReorder || resolvedReorder.visual.containerId !== intent.containerId) {
-          clearDragState();
-          syncHistoryAvailability();
-          return;
-        }
-        const targetPlacement = resolvedReorder.commit;
-        command = {
-          type: classifyCommandType(sourcePos, targetPlacement, false),
-          nodeId: anchorNodeId,
-          commitNodeId: targetPlacement.commitNodeId,
-          from: sourcePos,
-          to: targetPlacement,
-          at: Date.now()
-        };
-      }
-      if (command) {
-        const anchorEl = resolveNodeElement(anchorNodeId) ?? activeEl;
-        const selectedEl = resolveNodeElement(selectedNodeId) ?? anchorEl;
-        const nodeKey = getNodeKeyFromElement(anchorEl);
-        const inspRef = getInspectorRefFromElement(anchorEl);
-        const selectedNodeKey = getNodeKeyFromElement(selectedEl);
-        const selectedInspectorRef = getInspectorRefFromElement(selectedEl);
-        const sourceLaneSnapshot = refs.sourceCommitLaneRef.current ?? getCommitLaneSnapshot(command.from.laneContainerId);
-        const targetLaneSnapshot = command.to.laneContainerId === command.from.laneContainerId ? sourceLaneSnapshot : getCommitLaneSnapshot(command.to.laneContainerId);
-        const committed = refs.historyRef.current.execute(command, applyCommand);
-        if (committed) {
-          activeEl.setAttribute("data-dnd-moved", "");
-          selectElement(null);
-          recordCommittedMove({
-            command,
-            anchorNodeId,
-            selectedNodeId,
-            anchorEl,
-            selectedEl,
-            nodeKey,
-            inspRef,
-            selectedNodeKey,
-            selectedInspectorRef,
-            sourceLaneSnapshot,
-            targetLaneSnapshot,
-            resolveNodeElement,
-            recordMoveChange,
-            nodeMap: refs.nodeMapRef.current
-          });
+          break;
+        case "drop-target-not-droppable": {
+          const targetMeta = refs.nodeMapRef.current.get(dropTargetId)?.editorMeta;
+          emitRefused(
+            resolveRefusalCode(targetMeta, "CONTAINER_NOT_PLAIN"),
+            "Drop target is outside the droppable set for this node.",
+            resolveVidForScannedNode(dropTargetId, refs.nodeMapRef.current, resolveNodeElement(dropTargetId))
+          );
+          break;
         }
+        case "nest-self-or-descendant":
+          emitRefused(GATE_REJECT, "Cannot nest an element into itself or its own descendant.", anchorVid());
+          break;
+        case "nest-ancestor":
+          emitRefused(GATE_REJECT, "Cannot nest an element into its own ancestor.", anchorVid());
+          break;
+        case "nest-no-commit-node":
+          emitRefused(GATE_REJECT, "Cannot resolve the dragged node's source position for nesting.", anchorVid());
+          break;
+        case "stale-reorder":
+          emitRefused(GATE_REJECT, "Resolved reorder placement no longer matches the drag intent.", anchorVid());
+          break;
+        case "no-move":
+          emitRefused(GATE_REJECT, "Could not build a move for the resolved drag intent.", anchorVid());
+          break;
       }
+      clearDragState();
+      syncHistoryAvailability();
+      return;
+    }
+    const command = branch.kind === "nest" ? (() => {
+      const target = nestTarget;
+      const nestPlacement = resolveAppendCommitPlacement(target.element, pos.commitNodeId, target.nodeId);
+      return {
+        type: classifyCommandType(pos, nestPlacement, true),
+        nodeId: anchorNodeId,
+        commitNodeId: pos.commitNodeId,
+        from: pos,
+        to: nestPlacement,
+        at: Date.now()
+      };
+    })() : (() => {
+      const targetPlacement = resolvedReorder.commit;
+      return {
+        type: classifyCommandType(pos, targetPlacement, false),
+        nodeId: anchorNodeId,
+        commitNodeId: targetPlacement.commitNodeId,
+        from: pos,
+        to: targetPlacement,
+        at: Date.now()
+      };
+    })();
+    const anchorEl = resolveNodeElement(anchorNodeId) ?? el;
+    const selectedEl = resolveNodeElement(selectedNodeId) ?? anchorEl;
+    const nodeKey = getNodeKeyFromElement(anchorEl);
+    const inspRef = getInspectorRefFromElement(anchorEl);
+    const selectedNodeKey = getNodeKeyFromElement(selectedEl);
+    const selectedInspectorRef = getInspectorRefFromElement(selectedEl);
+    const sourceLaneSnapshot = refs.sourceCommitLaneRef.current ?? getCommitLaneSnapshot(command.from.laneContainerId);
+    const targetLaneSnapshot = command.to.laneContainerId === command.from.laneContainerId ? sourceLaneSnapshot : getCommitLaneSnapshot(command.to.laneContainerId);
+    const committed = refs.historyRef.current.execute(command, applyCommand);
+    if (committed) {
+      el.setAttribute("data-dnd-moved", "");
+      selectElement(null);
+      recordCommittedMove({
+        command,
+        anchorNodeId,
+        selectedNodeId,
+        anchorEl,
+        selectedEl,
+        nodeKey,
+        inspRef,
+        selectedNodeKey,
+        selectedInspectorRef,
+        sourceLaneSnapshot,
+        targetLaneSnapshot,
+        resolveNodeElement,
+        recordMoveChange,
+        nodeMap: refs.nodeMapRef.current
+      });
+    } else {
+      emitRefused(GATE_REJECT, "The resolved move could not be applied.", anchorVid());
     }
     clearDragState();
     syncHistoryAvailability();
@@ -9317,7 +9429,7 @@ function HitArea({
     "div",
     {
       ref: divRef,
-      "data-design-mode-ui": true,
+      "data-design-mode-ui": "hit-area",
       style: { position: "fixed", left, top, width, height, zIndex: 99998, cursor },
       onPointerMove: (e) => {
         if (!isSelected || isDragging) {
@@ -9408,9 +9520,7 @@ function DesignModeOverlay() {
   const draggableElements = (0, import_react16.useMemo)(() => {
     if (elements.length === 0) return [];
     const projection = buildProjection(elements);
-    return collectDraggableAnchors(elements, projection, nodeMap).filter(
-      (el) => el.draggable !== false
-    );
+    return filterEligibleForDrag(collectDraggableAnchors(elements, projection, nodeMap));
   }, [elements, nodeMap]);
   const arrangeHitAreaElement = (0, import_react16.useMemo)(() => {
     if (!arrangeSelectedNodeId) return null;
@@ -10020,7 +10130,7 @@ function isPreviewOrigin(origin) {
 var DEFAULT_SCRIPT_ID = "archie-inspector-script";
 var R2_INSPECTOR_BASE_URL = "https://pub-bf238c278d9644b39ec34ecaca1d315c.r2.dev";
 function readBuildVersion() {
-  return "0.1.4" ? "0.1.4" : null;
+  return "0.1.6" ? "0.1.6" : null;
 }
 var REMOTE_INSPECTOR_VERSION = readBuildVersion();
 var isRemoteInspectorUrlVersioned = REMOTE_INSPECTOR_VERSION !== null;