@archie/devtools 0.0.44 → 0.0.46

package/dist/client/client.js

@@ -616,44 +616,6 @@ function getFirstCollision(collisions, property) {
   const [firstCollision] = collisions;
   return property ? firstCollision[property] : firstCollision;
 }
-function centerOfRectangle(rect, left, top) {
-  if (left === void 0) {
-    left = rect.left;
-  }
-  if (top === void 0) {
-    top = rect.top;
-  }
-  return {
-    x: left + rect.width * 0.5,
-    y: top + rect.height * 0.5
-  };
-}
-var closestCenter = (_ref) => {
-  let {
-    collisionRect,
-    droppableRects,
-    droppableContainers
-  } = _ref;
-  const centerRect = centerOfRectangle(collisionRect, collisionRect.left, collisionRect.top);
-  const collisions = [];
-  for (const droppableContainer of droppableContainers) {
-    const {
-      id
-    } = droppableContainer;
-    const rect = droppableRects.get(id);
-    if (rect) {
-      const distBetween = distanceBetween(centerOfRectangle(rect), centerRect);
-      collisions.push({
-        id,
-        data: {
-          droppableContainer,
-          value: distBetween
-        }
-      });
-    }
-  }
-  return collisions.sort(sortCollisionsAsc);
-};
 var closestCorners = (_ref) => {
   let {
     collisionRect,
@@ -5260,9 +5222,12 @@ function ensureUniqueNodeId(base, used) {
   return `${base}::${idx}`;
 }
 var INSERT_NODE_ID_PREFIX = "insert:";
+var INSERT_CHILD_NODE_ID_PREFIX = "insert-child:";
 function resolveStableNodeId(el, used) {
   const persisted = el.getAttribute(DND_NODE_ID_ATTR);
-  if (persisted && persisted.startsWith(INSERT_NODE_ID_PREFIX)) return persisted;
+  if (persisted && (persisted.startsWith(INSERT_NODE_ID_PREFIX) || persisted.startsWith(INSERT_CHILD_NODE_ID_PREFIX))) {
+    return persisted;
+  }
   if (persisted && !used.has(persisted)) return persisted;
   const projected = projectUsageMeta(el);
   if (projected) return ensureUniqueNodeId(projected.nodeId, used);
@@ -5579,9 +5544,29 @@ function useElementScanner(enabled) {
 // src/client/dnd/design-mode/ElementHighlight.tsx
 var import_react7 = require("react");
 var import_jsx_runtime2 = require("react/jsx-runtime");
+function computeLaneKinshipContainerIds({
+  candidateContainerIds,
+  activeContainerId,
+  draggingNodeId,
+  getParentContainerId,
+  getContainerChildren: getContainerChildren2
+}) {
+  const anchorId = activeContainerId ?? getParentContainerId(draggingNodeId);
+  if (!anchorId) return /* @__PURE__ */ new Set();
+  const parentId = getParentContainerId(anchorId);
+  const kin = /* @__PURE__ */ new Set();
+  if (!parentId) return kin;
+  if (candidateContainerIds.has(parentId)) kin.add(parentId);
+  for (const siblingId of getContainerChildren2(parentId)) {
+    if (siblingId === anchorId) continue;
+    if (candidateContainerIds.has(siblingId)) kin.add(siblingId);
+  }
+  return kin;
+}
 var HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
 var HANDLE_HIT_SIZE = 24;
 var HANDLE_KNOB_SIZE = 8;
+var EMPTY_SCROLL_DELTA = { x: NaN, y: NaN };
 var OVERLAY_ROOT_STYLE = {
   position: "fixed",
   inset: 0,
@@ -5655,16 +5640,38 @@ function handlePosition(dir) {
   };
   return positions[dir];
 }
-function getOutlineStyle(rect, isSelected, inspectorTheme) {
+function getSelectedOutlineStyle(rect, inspectorTheme) {
   return {
     ...OUTLINE_BASE_STYLE,
     left: rect.left,
     top: rect.top,
     width: rect.width,
     height: rect.height,
-    border: isSelected ? `2px solid ${inspectorTheme.accent}` : `1px dashed ${inspectorTheme.shared}`,
-    backgroundColor: isSelected ? inspectorTheme.accentSoft : "transparent"
+    border: `2px solid ${inspectorTheme.accent}`,
+    backgroundColor: inspectorTheme.accentSoft
+  };
+}
+function getGuideOutlineStyle(rect, tier, inspectorTheme) {
+  const base = {
+    ...OUTLINE_BASE_STYLE,
+    left: rect.left,
+    top: rect.top,
+    width: rect.width,
+    height: rect.height
   };
+  switch (tier) {
+    case "candidate":
+      return { ...base, border: `1px solid ${inspectorTheme.accent}`, opacity: 0.2 };
+    case "lane-child":
+      return { ...base, border: `1px dashed ${inspectorTheme.accent}`, opacity: 0.45 };
+    case "lane":
+      return {
+        ...base,
+        border: `1.5px solid ${inspectorTheme.accent}`,
+        backgroundColor: inspectorTheme.accentSoft,
+        opacity: 0.75
+      };
+  }
 }
 function getResizeHandleStyle(position) {
   return {
@@ -5688,40 +5695,58 @@ function getLabelStyle(labelLeft, labelTop, labelColor) {
     backgroundColor: labelColor
   };
 }
+function projectDragRect(dragGuide, nodeId, sdx, sdy) {
+  const r = dragGuide.rects.get(nodeId);
+  if (!r) return null;
+  return { left: r.left - sdx, top: r.top - sdy, width: r.width, height: r.height };
+}
 function ElementHighlight({
-  elements,
-  draggingNodeId,
-  activeEl,
-  arrangeSelectedNodeId,
+  selected,
+  dragGuide,
   externalDragActive,
   onResizeHandlePointerDown
 }) {
   const inspectorTheme = useDesignModeStore((s) => s.inspectorTheme);
-  const internalDragInProgress = draggingNodeId !== null;
-  const overlayVisible = arrangeSelectedNodeId !== null || internalDragInProgress;
   const containerRef = (0, import_react7.useRef)(null);
   const rafRef = (0, import_react7.useRef)(0);
+  const lastScrollDeltaRef = (0, import_react7.useRef)(EMPTY_SCROLL_DELTA);
   const syncPositions = (0, import_react7.useCallback)(() => {
     const container = containerRef.current;
     if (!container) return;
-    const outlines = container.querySelectorAll("[data-outline-for]");
-    for (const outline of outlines) {
-      const nodeId = outline.getAttribute("data-outline-for");
-      const el = elements.find((e) => e.nodeId === nodeId);
-      if (!el) continue;
-      const rect = el.element.getBoundingClientRect();
-      outline.style.left = `${rect.left}px`;
-      outline.style.top = `${rect.top}px`;
-      outline.style.width = `${rect.width}px`;
-      outline.style.height = `${rect.height}px`;
-      const label = outline.nextElementSibling;
-      if (label) {
-        label.style.left = `${rect.left}px`;
-        label.style.top = `${rect.top}px`;
+    if (dragGuide) {
+      const sdx = window.scrollX - dragGuide.startScroll.x;
+      const sdy = window.scrollY - dragGuide.startScroll.y;
+      if (sdx === lastScrollDeltaRef.current.x && sdy === lastScrollDeltaRef.current.y) return;
+      lastScrollDeltaRef.current = { x: sdx, y: sdy };
+      const outlines = container.querySelectorAll("[data-guide-for]");
+      for (const outline2 of outlines) {
+        const nodeId = outline2.getAttribute("data-guide-for");
+        const r = dragGuide.rects.get(nodeId);
+        if (!r) continue;
+        outline2.style.left = `${r.left - sdx}px`;
+        outline2.style.top = `${r.top - sdy}px`;
       }
+      return;
     }
-  }, [elements]);
+    if (!selected) return;
+    const rect2 = selected.element.getBoundingClientRect();
+    const outline = container.querySelector("[data-outline-for]");
+    if (outline) {
+      outline.style.left = `${rect2.left}px`;
+      outline.style.top = `${rect2.top}px`;
+      outline.style.width = `${rect2.width}px`;
+      outline.style.height = `${rect2.height}px`;
+    }
+    const label = container.querySelector("[data-drag-handle]");
+    if (label) {
+      label.style.left = `${rect2.left + 12}px`;
+      label.style.top = `${Math.max(0, rect2.top - 20)}px`;
+    }
+  }, [dragGuide, selected]);
+  const loopActive = !externalDragActive && (dragGuide !== null || selected !== null);
   (0, import_react7.useEffect)(() => {
+    if (!loopActive) return;
+    lastScrollDeltaRef.current = EMPTY_SCROLL_DELTA;
     let running = true;
     const loop = () => {
       if (!running) return;
@@ -5733,81 +5758,113 @@ function ElementHighlight({
       running = false;
       cancelAnimationFrame(rafRef.current);
     };
-  }, [syncPositions]);
-  if (!overlayVisible) return null;
-  if (externalDragActive) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-    "div",
-    {
-      ref: containerRef,
-      "data-design-mode-ui": true,
-      style: OVERLAY_ROOT_STYLE,
-      children: elements.map((el) => {
-        if (el.nodeId === draggingNodeId) return null;
-        if (activeEl && activeEl !== el.element && activeEl.contains(el.element)) return null;
-        const isSelected = el.nodeId === arrangeSelectedNodeId;
-        if (!isSelected && !internalDragInProgress) return null;
-        const rect = el.element.getBoundingClientRect();
-        const showLabel = isSelected;
-        const labelTop = isSelected ? Math.max(0, rect.top - 20) : rect.top;
-        const labelLeft = isSelected ? rect.left + 12 : rect.left;
-        return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-            "div",
-            {
-              "data-outline-for": el.nodeId,
-              "data-design-mode-ui": true,
-              style: getOutlineStyle(rect, isSelected, inspectorTheme),
-              children: isSelected && el.draggable && HANDLES.map((dir) => {
-                const pos = handlePosition(dir);
-                return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                  "div",
-                  {
-                    "data-design-mode-ui": true,
-                    "data-resize-handle": dir,
-                    onPointerDown: (e) => {
-                      e.stopPropagation();
-                      onResizeHandlePointerDown?.(e, el.nodeId, dir);
-                    },
-                    style: getResizeHandleStyle(pos),
-                    children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-                      "span",
-                      {
-                        "data-design-mode-ui": true,
-                        style: getResizeKnobStyle(inspectorTheme.accent)
-                      }
-                    )
-                  },
-                  dir
-                );
-              })
-            }
-          ),
-          showLabel && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+  }, [loopActive, syncPositions]);
+  if (!loopActive) return null;
+  if (dragGuide) {
+    const sdx = window.scrollX - dragGuide.startScroll.x;
+    const sdy = window.scrollY - dragGuide.startScroll.y;
+    const { candidateContainerIds, activeContainerId, activeChildIds, draggingNodeId } = dragGuide;
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { ref: containerRef, "data-design-mode-ui": true, style: OVERLAY_ROOT_STYLE, children: [
+      [...candidateContainerIds].map((id) => {
+        if (id === activeContainerId || id === draggingNodeId) return null;
+        const rect2 = projectDragRect(dragGuide, id, sdx, sdy);
+        if (!rect2) return null;
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "div",
+          {
+            "data-guide-for": id,
+            "data-guide-tier": "candidate",
+            "data-design-mode-ui": true,
+            style: getGuideOutlineStyle(rect2, "candidate", inspectorTheme)
+          },
+          `candidate:${id}`
+        );
+      }),
+      activeContainerId !== null && activeChildIds.map((id) => {
+        if (id === draggingNodeId) return null;
+        const rect2 = projectDragRect(dragGuide, id, sdx, sdy);
+        if (!rect2) return null;
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "div",
+          {
+            "data-guide-for": id,
+            "data-guide-tier": "lane-child",
+            "data-design-mode-ui": true,
+            style: getGuideOutlineStyle(rect2, "lane-child", inspectorTheme)
+          },
+          `lane-child:${id}`
+        );
+      }),
+      activeContainerId !== null && activeContainerId !== draggingNodeId && (() => {
+        const rect2 = projectDragRect(dragGuide, activeContainerId, sdx, sdy);
+        if (!rect2) return null;
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "div",
+          {
+            "data-guide-for": activeContainerId,
+            "data-guide-tier": "lane",
+            "data-design-mode-ui": true,
+            style: getGuideOutlineStyle(rect2, "lane", inspectorTheme)
+          },
+          `lane:${activeContainerId}`
+        );
+      })()
+    ] });
+  }
+  if (!selected) return null;
+  const rect = selected.element.getBoundingClientRect();
+  const labelTop = Math.max(0, rect.top - 20);
+  const labelLeft = rect.left + 12;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { ref: containerRef, "data-design-mode-ui": true, style: OVERLAY_ROOT_STYLE, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "div",
+      {
+        "data-outline-for": selected.nodeId,
+        "data-design-mode-ui": true,
+        style: getSelectedOutlineStyle(rect, inspectorTheme),
+        children: selected.draggable && HANDLES.map((dir) => {
+          const pos = handlePosition(dir);
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
             "div",
             {
               "data-design-mode-ui": true,
-              "data-drag-handle": el.nodeId,
-              style: getLabelStyle(
-                labelLeft,
-                labelTop,
-                isSelected ? inspectorTheme.accent : inspectorTheme.hover
-              ),
-              children: [
-                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: LABEL_ICON_STYLE, children: "\u283F" }),
-                el.label,
-                isSelected && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: LABEL_DIMENSIONS_STYLE, children: [
-                  Math.round(rect.width),
-                  "\xD7",
-                  Math.round(rect.height)
-                ] })
-              ]
-            }
-          )
-        ] }, el.nodeId);
-      })
-    }
-  );
+              "data-resize-handle": dir,
+              onPointerDown: (e) => {
+                e.stopPropagation();
+                onResizeHandlePointerDown?.(e, selected.nodeId, dir);
+              },
+              style: getResizeHandleStyle(pos),
+              children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                "span",
+                {
+                  "data-design-mode-ui": true,
+                  style: getResizeKnobStyle(inspectorTheme.accent)
+                }
+              )
+            },
+            dir
+          );
+        })
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+      "div",
+      {
+        "data-design-mode-ui": true,
+        "data-drag-handle": selected.nodeId,
+        style: getLabelStyle(labelLeft, labelTop, inspectorTheme.accent),
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: LABEL_ICON_STYLE, children: "\u283F" }),
+          selected.label,
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: LABEL_DIMENSIONS_STYLE, children: [
+            Math.round(rect.width),
+            "\xD7",
+            Math.round(rect.height)
+          ] })
+        ]
+      }
+    )
+  ] });
 }
 
 // src/client/dnd/design-mode/projection.ts
@@ -6093,6 +6150,15 @@ var NON_DRAGGABLE_DESCENDANT_TAGS = /* @__PURE__ */ new Set([
   "source",
   "track"
 ]);
+var ARCHIE_INSERTED_ATTR = "data-archie-inserted";
+var INSERT_CHILD_NODE_ID_PREFIX2 = "insert-child:";
+function sealDescendantNodeId(node) {
+  if (node.hasAttribute("data-dnd-node-id")) return;
+  const marker = node.getAttribute(ARCHIE_INSERTED_ATTR);
+  if (!marker) return;
+  if (marker.includes('"') || marker.includes("'")) return;
+  node.setAttribute("data-dnd-node-id", `${INSERT_CHILD_NODE_ID_PREFIX2}${marker}`);
+}
 function markInsertedDescendants(root) {
   const descendants = root.querySelectorAll("*");
   for (const node of descendants) {
@@ -6100,6 +6166,7 @@ function markInsertedDescendants(root) {
     if (NON_DRAGGABLE_DESCENDANT_TAGS.has(tag)) continue;
     node.setAttribute("data-dnd-force-allow", "");
     node.setAttribute("data-dnd-moved", "");
+    sealDescendantNodeId(node);
   }
 }
 
@@ -6601,30 +6668,6 @@ function applyDndCommandPlacement(command, direction, resolveNodeElement) {
   return true;
 }
 
-// src/client/dnd/design-mode/design-mode-collision.ts
-function filterDroppables(droppableContainers, blockedContainerIds) {
-  if (!blockedContainerIds || blockedContainerIds.size === 0) return droppableContainers;
-  return droppableContainers.filter((container) => !blockedContainerIds.has(String(container.id)));
-}
-function getCollisions(detector, args) {
-  return detector(args);
-}
-function createDesignModeCollisionDetection(blockedContainerIds) {
-  return (args) => {
-    const droppableContainers = filterDroppables(args.droppableContainers, blockedContainerIds);
-    if (droppableContainers.length === 0) return [];
-    const scopedArgs = {
-      ...args,
-      droppableContainers
-    };
-    const pointerHits = getCollisions(pointerWithin, scopedArgs);
-    if (pointerHits.length > 0) return pointerHits;
-    const cornerHits = getCollisions(closestCorners, scopedArgs);
-    if (cornerHits.length > 0) return cornerHits;
-    return getCollisions(closestCenter, scopedArgs);
-  };
-}
-
 // src/client/dnd/design-mode/arrange-session.ts
 function serializeArrangeChange(event, index) {
   return {
@@ -6903,9 +6946,9 @@ function useOverlayRefs(undoRequestId, redoRequestId) {
   const lastIntentRef = (0, import_react11.useRef)(null);
   const visualIntentRef = (0, import_react11.useRef)(null);
   const sourceContainerIdRef = (0, import_react11.useRef)(null);
+  const activeLaneContainerIdRef = (0, import_react11.useRef)(null);
   const rowLockedRef = (0, import_react11.useRef)(false);
   const dragSessionAnchorRef = (0, import_react11.useRef)(null);
-  const lockRef = (0, import_react11.useRef)({ containerId: null, isCrossUnlocked: false, exitSince: null, unlockUntilTs: null });
   const targetPlaneRef = (0, import_react11.useRef)("lane");
   const nestCandidateRef = (0, import_react11.useRef)(null);
   const nestTargetRef = (0, import_react11.useRef)(null);
@@ -6915,7 +6958,6 @@ function useOverlayRefs(undoRequestId, redoRequestId) {
   const sourceCommitLaneRef = (0, import_react11.useRef)(null);
   const commitLaneCacheRef = (0, import_react11.useRef)(/* @__PURE__ */ new Map());
   const safeZoneRef = (0, import_react11.useRef)(null);
-  const blockedContainerIdsRef = (0, import_react11.useRef)(/* @__PURE__ */ new Set());
   const historyRef = (0, import_react11.useRef)(new DndCommandHistory());
   const processedUndoIdRef = (0, import_react11.useRef)(undoRequestId);
   const processedRedoIdRef = (0, import_react11.useRef)(redoRequestId);
@@ -6935,9 +6977,9 @@ function useOverlayRefs(undoRequestId, redoRequestId) {
     lastIntentRef,
     visualIntentRef,
     sourceContainerIdRef,
+    activeLaneContainerIdRef,
     rowLockedRef,
     dragSessionAnchorRef,
-    lockRef,
     targetPlaneRef,
     nestCandidateRef,
     nestTargetRef,
@@ -6947,7 +6989,6 @@ function useOverlayRefs(undoRequestId, redoRequestId) {
     sourceCommitLaneRef,
     commitLaneCacheRef,
     safeZoneRef,
-    blockedContainerIdsRef,
     historyRef,
     processedUndoIdRef,
     processedRedoIdRef,
@@ -7215,6 +7256,11 @@ function pointInRect(px, py, r) {
 function pointInExpandedRect(px, py, r, inset) {
   return px >= r.left - inset && px <= r.right + inset && py >= r.top - inset && py <= r.bottom + inset;
 }
+function isInNestZone(px, py, rect) {
+  const relX = (px - rect.left) / rect.width;
+  const relY = (py - rect.top) / rect.height;
+  return relX > NEST_EDGE_FRACTION && relX < 1 - NEST_EDGE_FRACTION && relY > NEST_EDGE_FRACTION && relY < 1 - NEST_EDGE_FRACTION;
+}
 function buildSlotQuadtree(slotIndex) {
   const rects = /* @__PURE__ */ new Map();
   for (const [id, slot] of slotIndex) {
@@ -7257,6 +7303,11 @@ var DragIntentEngine = class {
     __publicField(this, "laneAllowedContainers");
     __publicField(this, "blockedContainerIds");
     __publicField(this, "targetPlane", "lane");
+    // Memoized result of getValidDropContainerIds(). Safe to cache because every
+    // input it reads (containerIndex, slotIndex, activeId, laneAllowedContainers,
+    // blockedContainerIds) is fixed in the constructor and never mutated during
+    // a drag.
+    __publicField(this, "validDropContainerIds", null);
     this.projectionTree = projection.projectionTree;
     this.containerIndex = projection.containerIndex;
     this.slotIndex = projection.slotIndex;
@@ -7293,6 +7344,44 @@ var DragIntentEngine = class {
   getContainerChildren(containerId) {
     return this.containerIndex.get(containerId)?.children ?? [];
   }
+  /**
+   * Every container id this engine would accept as a drop target for the
+   * active node, at the current pointer position or any other — i.e. the
+   * full set `resolvePointerContainer` draws from, not a snapshot of one
+   * resolve() call. Intended for the visual layer to draw a guide that
+   * matches exactly what the engine can land on, without re-deriving the
+   * eligibility rule itself.
+   *
+   * Always queries with `laneLock: true`. That is not an approximation of
+   * the "real" default — it IS the real answer for every reachable caller:
+   *
+   * - With a row lock active (`laneAllowedContainers` set), `isLaneContainer`
+   *   restricts eligibility to that set, so this returns exactly
+   *   `{srcContainerId}` — the ARCH-1071 lock, reproduced faithfully.
+   * - Without a row lock, `laneAllowedContainers` is null and
+   *   `isLaneContainer` returns true unconditionally, so `laneLock`'s value
+   *   makes no difference — passing `true` costs nothing here.
+   * - The engine's own 'nest' plane does call `isEligibleDropContainer` with
+   *   `laneLock: false` (see `peekNestIntent` → `resolvePointerContainer`),
+   *   but that plane is unreachable for a locked drag: `computeAllowNest`
+   *   (useDragVisualLoop.ts) short-circuits `rowLocked` drags before
+   *   `setTargetPlane('nest')` is ever called, so `targetPlane` stays
+   *   'lane' for the drag's whole lifetime. If that guard is ever removed,
+   *   this method will under-report nest-only targets for locked drags —
+   *   keep the two in sync.
+   *
+   * Cached after the first call: every input (containerIndex, slotIndex,
+   * activeId, laneAllowedContainers, blockedContainerIds) is fixed at
+   * construction and never changes for the life of a drag.
+   */
+  getValidDropContainerIds() {
+    if (this.validDropContainerIds) return this.validDropContainerIds;
+    const ids2 = /* @__PURE__ */ new Set();
+    for (const id of this.containerIndex.keys()) {
+      if (this.isEligibleDropContainer(id, true)) ids2.add(id);
+    }
+    return this.validDropContainerIds = ids2;
+  }
   setTargetPlane(plane) {
     this.targetPlane = plane;
   }
@@ -7311,6 +7400,17 @@ var DragIntentEngine = class {
   isInvalidDropContainer(containerId) {
     return containerId === this.activeId || this.isContainerDescendantOf(containerId, this.activeId);
   }
+  /**
+   * The full "can this container accept the active node this drag" predicate.
+   * SINGLE definition — every caller routes through it so no two parts of the
+   * system can disagree about which containers are droppable.
+   */
+  isEligibleDropContainer(containerId, laneLock) {
+    if (this.isInvalidDropContainer(containerId)) return false;
+    if (this.isBlockedContainer(containerId)) return false;
+    if (laneLock && !this.isLaneContainer(containerId)) return false;
+    return this.hasUsableSlots(containerId);
+  }
   /**
    * Resolve the drag intent from the current pointer position.
    *
@@ -7398,9 +7498,7 @@ var DragIntentEngine = class {
       const childNode = this.getNodeRect(childId);
       if (!childNode) continue;
       if (!pointInRect(px, py, childNode)) continue;
-      const relX = (px - childNode.left) / childNode.width;
-      const relY = (py - childNode.top) / childNode.height;
-      if (relX > NEST_EDGE_FRACTION && relX < 1 - NEST_EDGE_FRACTION && relY > NEST_EDGE_FRACTION && relY < 1 - NEST_EDGE_FRACTION) {
+      if (isInNestZone(px, py, childNode)) {
         return {
           containerId: pointerContainerId,
           index: container.children.indexOf(childId),
@@ -7414,11 +7512,8 @@ var DragIntentEngine = class {
   resolvePointerContainer(px, py, laneLock) {
     const pointerContainers = [];
     for (const [id, node] of this.containerIndex) {
-      if (this.isInvalidDropContainer(id)) continue;
-      if (this.isBlockedContainer(id)) continue;
-      if (laneLock && !this.isLaneContainer(id)) continue;
       if (!pointInRect(px, py, node.rect)) continue;
-      if (this.hasUsableSlots(id) === false) continue;
+      if (!this.isEligibleDropContainer(id, laneLock)) continue;
       const r = node.rect;
       const edgeDistX = Math.min(px - r.left, r.right - px);
       const edgeDistY = Math.min(py - r.top, r.bottom - py);
@@ -7435,11 +7530,11 @@ var DragIntentEngine = class {
     let pointerContainerId = pointerContainers[0]?.id ?? null;
     if (!pointerContainerId && this.lastIntent?.mode === "reorder") {
       const lastContainer = this.containerIndex.get(this.lastIntent.containerId);
-      if (lastContainer && !this.isInvalidDropContainer(lastContainer.id) && !this.isBlockedContainer(lastContainer.id) && (!laneLock || this.isLaneContainer(lastContainer.id)) && this.hasUsableSlots(lastContainer.id) && pointInExpandedRect(px, py, lastContainer.rect, LAST_CONTAINER_REENTRY_SLOP_PX)) {
+      if (lastContainer && this.isEligibleDropContainer(lastContainer.id, laneLock) && pointInExpandedRect(px, py, lastContainer.rect, LAST_CONTAINER_REENTRY_SLOP_PX)) {
         pointerContainerId = lastContainer.id;
       }
     }
-    if (this.originContainerId && this.originContainerId !== pointerContainerId && !this.isInvalidDropContainer(this.originContainerId) && !this.isBlockedContainer(this.originContainerId) && (!laneLock || this.isLaneContainer(this.originContainerId)) && this.hasUsableSlots(this.originContainerId)) {
+    if (this.originContainerId && this.originContainerId !== pointerContainerId && this.isEligibleDropContainer(this.originContainerId, laneLock)) {
       const originNode = this.containerIndex.get(this.originContainerId);
       const currentNode = pointerContainerId ? this.containerIndex.get(pointerContainerId) : null;
       const originIsDeeper = originNode && (!currentNode || originNode.depth >= currentNode.depth);
@@ -7852,7 +7947,8 @@ function useDragVisualLoop({
   refs,
   getCommitLaneSnapshot,
   setInsideRect,
-  setDropLine
+  setDropLine,
+  setActiveLaneContainerId
 }) {
   (0, import_react12.useEffect)(() => {
     const engine = refs.engineRef.current;
@@ -7860,6 +7956,11 @@ function useDragVisualLoop({
     if (!activeDrag || !engine || !snapshot) return;
     let rafId;
     const animator = refs.animatorRef.current;
+    const publishActiveLane = (containerId) => {
+      if (refs.activeLaneContainerIdRef.current === containerId) return;
+      refs.activeLaneContainerIdRef.current = containerId;
+      setActiveLaneContainerId(containerId);
+    };
     const setTargetPlane = (nextPlane) => {
       const prevPlane = refs.targetPlaneRef.current;
       if (prevPlane === nextPlane) return;
@@ -7878,6 +7979,7 @@ function useDragVisualLoop({
       const safeZone = refs.safeZoneRef.current;
       if (isPointerBlocked(px, py, safeZone)) {
         setTargetPlane("lane");
+        publishActiveLane(null);
         refs.lastIntentRef.current = null;
         refs.visualIntentRef.current = null;
         refs.nestCandidateRef.current = null;
@@ -7919,6 +8021,7 @@ function useDragVisualLoop({
       let intent = engine.resolve(px, py, window.scrollX, window.scrollY, snapshot.scroll.x, snapshot.scroll.y);
       if (!intent) {
         setTargetPlane("lane");
+        publishActiveLane(null);
         refs.lastIntentRef.current = null;
         refs.visualIntentRef.current = null;
         refs.nestCandidateRef.current = null;
@@ -7944,6 +8047,7 @@ function useDragVisualLoop({
         const targetId = intent.slotId.split("::nest::")[1] ?? "";
         if (!targetId) {
           setTargetPlane("lane");
+          publishActiveLane(null);
           rafId = requestAnimationFrame(tick);
           return;
         }
@@ -7965,12 +8069,14 @@ function useDragVisualLoop({
         };
         refs.visualIntentRef.current = intent;
         refs.lastIntentRef.current = intent;
+        publishActiveLane(intent.containerId);
       } else {
         setTargetPlane("lane");
         refs.nestCandidateRef.current = null;
         refs.nestTargetRef.current = null;
         refs.lastIntentRef.current = intent;
         refs.visualIntentRef.current = intent;
+        publishActiveLane(intent.containerId);
         setInsideRect(null);
         const proj = refs.projectionRef.current;
         const slot = proj.slotIndex.get(intent.slotId);
@@ -8277,7 +8383,8 @@ function useDragLifecycle({
   syncHistoryAvailability,
   resolveNodeElement,
   setInsideRect,
-  setDropLine
+  setDropLine,
+  setActiveLaneContainerId
 }) {
   const [activeDrag, setActiveDrag] = (0, import_react13.useState)(null);
   const clearDragState = (0, import_react13.useCallback)(() => {
@@ -8288,13 +8395,12 @@ function useDragLifecycle({
     refs.snapshotRef.current = null;
     refs.projectionRef.current = EMPTY_PROJECTION;
     refs.engineRef.current = null;
-    refs.blockedContainerIdsRef.current = /* @__PURE__ */ new Set();
     refs.lastIntentRef.current = null;
     refs.visualIntentRef.current = null;
     refs.sourceContainerIdRef.current = null;
+    refs.activeLaneContainerIdRef.current = null;
     refs.rowLockedRef.current = false;
     refs.dragSessionAnchorRef.current = null;
-    refs.lockRef.current = { containerId: null, isCrossUnlocked: false, exitSince: null, unlockUntilTs: null };
     refs.targetPlaneRef.current = "lane";
     refs.nestCandidateRef.current = null;
     refs.nestTargetRef.current = null;
@@ -8305,6 +8411,7 @@ function useDragLifecycle({
     refs.safeZoneRef.current = null;
     setInsideRect(null);
     setDropLine(null);
+    setActiveLaneContainerId(null);
     setActiveDrag(null);
     resume();
   }, [clearCommitLaneCache, resume]);
@@ -8362,7 +8469,6 @@ function useDragLifecycle({
     const sourceCommitLane = getCommitLaneSnapshot(srcContainerId);
     const startPosition = getCurrentCommitPlacement(anchorNodeId, srcContainerId);
     const blockedContainerIds = buildBlockedStructuralContainerIds(proj, refs.nodeMapRef.current, srcContainerId);
-    refs.blockedContainerIdsRef.current = blockedContainerIds;
     const engineOptions = buildDragIntentEngineOptions(anchorScanned.element, srcContainerId, blockedContainerIds);
     refs.rowLockedRef.current = !!engineOptions.laneAllowedContainers;
     refs.engineRef.current = createDragIntentEngine(proj, anchorNodeId, engineOptions);
@@ -8371,7 +8477,6 @@ function useDragLifecycle({
     refs.sourceContainerIdRef.current = srcContainerId;
     refs.sourceCommitLaneRef.current = sourceCommitLane;
     refs.dragSessionAnchorRef.current = anchor;
-    refs.lockRef.current = { containerId: srcContainerId, isCrossUnlocked: true, exitSince: null, unlockUntilTs: null };
     refs.dragStartPositionRef.current = startPosition;
     refs.safeZoneRef.current = resolveSafeZoneRect();
     pause();
@@ -8853,7 +8958,7 @@ function commitExternalDrop(x, y, engine, component, refs, resolveNodeElement, s
     const candidate = postInsertChildren[i];
     const candidateNodeId = candidate.getAttribute(DND_NODE_ID_ATTR);
     if (!candidateNodeId) continue;
-    const isEarlierInsert = candidateNodeId.startsWith("insert:");
+    const isEarlierInsert = candidateNodeId.startsWith("insert:") || candidateNodeId.startsWith("insert-child:");
     if (!isEarlierInsert && !getInspectorRefFromElement(candidate)) continue;
     beforeSiblingEl = candidate;
     beforeSiblingNodeId = candidateNodeId;
@@ -8930,6 +9035,7 @@ function commitExternalDrop(x, y, engine, component, refs, resolveNodeElement, s
 // src/client/dnd/design-mode/DesignModeOverlay.tsx
 var import_jsx_runtime4 = require("react/jsx-runtime");
 var DROP_ANIMATION = { duration: DURATION_MS, easing: EASING };
+var EMPTY_CONTAINER_ID_SET = /* @__PURE__ */ new Set();
 function resizeCursorFromHandle(handle) {
   switch (handle) {
     case "n":
@@ -9217,13 +9323,9 @@ function DesignModeOverlay() {
   const sensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 8 } })
   );
-  const collisionDetection = (0, import_react16.useCallback)(
-    (args) => createDesignModeCollisionDetection(refs.blockedContainerIdsRef.current)(args),
-    []
-    // eslint-disable-line react-hooks/exhaustive-deps -- refs are stable
-  );
   const [insideRect, setInsideRect] = (0, import_react16.useState)(null);
   const [dropLine, setDropLine] = (0, import_react16.useState)(null);
+  const [activeLaneContainerId, setActiveLaneContainerId] = (0, import_react16.useState)(null);
   (0, import_react16.useEffect)(() => {
     if (!enabled) return;
     const fn = (e) => {
@@ -9259,8 +9361,55 @@ function DesignModeOverlay() {
     syncHistoryAvailability,
     resolveNodeElement,
     setInsideRect,
-    setDropLine
+    setDropLine,
+    setActiveLaneContainerId
   });
+  const dropCandidateContainerIds = (0, import_react16.useMemo)(
+    () => activeDrag ? refs.engineRef.current?.getValidDropContainerIds() ?? null : null,
+    [activeDrag]
+    // eslint-disable-line react-hooks/exhaustive-deps -- refs are stable
+  );
+  const laneKinshipContainerIds = (0, import_react16.useMemo)(() => {
+    if (!activeDrag || !dropCandidateContainerIds) return null;
+    const engine = refs.engineRef.current;
+    if (!engine) return null;
+    return computeLaneKinshipContainerIds({
+      candidateContainerIds: dropCandidateContainerIds,
+      activeContainerId: activeLaneContainerId,
+      draggingNodeId: activeDrag.nodeId,
+      getParentContainerId: (id) => engine.getNodeParentContainerId(id),
+      getContainerChildren: (id) => engine.getContainerChildren(id)
+    });
+  }, [activeDrag, activeLaneContainerId, dropCandidateContainerIds]);
+  const visibleCandidateContainerIds = (0, import_react16.useMemo)(() => {
+    if (!laneKinshipContainerIds) return null;
+    const rects = refs.snapshotRef.current?.rects;
+    if (!rects) return laneKinshipContainerIds;
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    const visible = /* @__PURE__ */ new Set();
+    for (const id of laneKinshipContainerIds) {
+      const r = rects.get(id);
+      if (!r) continue;
+      if (r.right < 0 || r.bottom < 0 || r.left > vw || r.top > vh) continue;
+      visible.add(id);
+    }
+    return visible;
+  }, [laneKinshipContainerIds]);
+  const dragGuide = (0, import_react16.useMemo)(() => {
+    if (!activeDrag) return null;
+    const snapshot = refs.snapshotRef.current;
+    if (!snapshot) return null;
+    const activeChildIds = activeLaneContainerId ? refs.engineRef.current?.getContainerChildren(activeLaneContainerId) ?? [] : [];
+    return {
+      rects: snapshot.rects,
+      startScroll: snapshot.scroll,
+      candidateContainerIds: visibleCandidateContainerIds ?? EMPTY_CONTAINER_ID_SET,
+      activeContainerId: activeLaneContainerId,
+      activeChildIds,
+      draggingNodeId: activeDrag.nodeId
+    };
+  }, [activeDrag, activeLaneContainerId, visibleCandidateContainerIds]);
   (0, import_react16.useEffect)(() => {
     if (!enabled || activeDrag) return;
     if (undoRequestId === refs.processedUndoIdRef.current) return;
@@ -9323,7 +9472,7 @@ function DesignModeOverlay() {
     safeZoneRef: refs.safeZoneRef,
     autoScrollStateRef: refs.autoScrollStateRef
   });
-  useDragVisualLoop({ activeDrag, refs, getCommitLaneSnapshot, setInsideRect, setDropLine });
+  useDragVisualLoop({ activeDrag, refs, getCommitLaneSnapshot, setInsideRect, setDropLine, setActiveLaneContainerId });
   useExternalDragLoop({
     externalDrag,
     refs,
@@ -9343,7 +9492,6 @@ function DesignModeOverlay() {
     DndContext,
     {
       sensors,
-      collisionDetection,
       autoScroll: false,
       onDragStart: handleDragStart,
       onDragEnd: handleDragEnd,
@@ -9352,10 +9500,8 @@ function DesignModeOverlay() {
         /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           ElementHighlight,
           {
-            elements,
-            draggingNodeId: activeDrag?.nodeId ?? null,
-            activeEl: refs.activeElRef.current,
-            arrangeSelectedNodeId,
+            selected: arrangeSelectedNodeId ? nodeMap.get(arrangeSelectedNodeId) ?? null : null,
+            dragGuide,
             externalDragActive: externalDrag !== null,
             onResizeHandlePointerDown: handleResizeHandlePointerDown
           }