@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/item/floorplan-move.js

@@ -1,103 +1,19 @@
-import { collectAlignmentAnchors, createSceneApi, getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, movingFootprintAnchors, nodeRegistry, resolveSurfacePlacement, roofFacePointToSegment, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { boundsOf, boxCorners, frame, transformPoint } from '@pascal-app/core/procedural-items';
-import { applyFloorplanAlignment, isGridSnapActive, isMagneticSnapActive, useEditor, } from '@pascal-app/editor';
+import { cascadeDirty, clearFaceHostItemFields, collectAlignmentAnchors, collectDescendants, createSceneApi, getBlockFaceFrame, getScaledDimensions, getSurfaceProvider, movingFootprintAnchors, nodeRegistry, resolveSupportSlabPatch, resolveSurfacePlacement, surfaceRegionContainsPoint, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { boundsOf, boxCorners, composeFrames, frame, transformPoint, } from '@pascal-app/core/procedural-items';
+import { applyFloorplanAlignment, isGridSnapActive, isMagneticSnapActive, surfaceAttachmentId, surfaceFramePose, updateSurfaceNode, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
 import { restingNodePlanFrame } from '../shared/resting-surface-plan';
 import { findClosestWallInPlan, snapLocalXToNeighbors } from '../shared/wall-attach-target';
-function rotateVec(x, z, rotationY) {
-    const c = Math.cos(rotationY);
-    const s = Math.sin(rotationY);
-    return [x * c + z * s, -x * s + z * c];
-}
-function resolveItemPlanTransform(item, nodes, cache = new Map()) {
-    const cached = cache.get(item.id);
-    if (cached)
-        return cached;
-    const localRotation = item.rotation[1] ?? 0;
-    let result = {
-        point: [item.position[0], item.position[2]],
-        rotation: localRotation,
+import { resolveItemTransform } from './floorplan';
+function resolveItemPlanTransform(item, nodes) {
+    const pose = resolveItemTransform(item, { resolve: (id) => nodes[id] });
+    return {
+        point: pose ? [pose.x, pose.y] : [item.position[0], item.position[2]],
+        rotation: pose?.rotation ?? item.rotation[1],
     };
-    const parent = item.parentId ? nodes[item.parentId] : null;
-    if (parent?.type === 'wall') {
-        const wallRotation = -Math.atan2(parent.end[1] - parent.start[1], parent.end[0] - parent.start[0]);
-        const wallLocalZ = item.asset.attachTo === 'wall-side'
-            ? ((parent.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
-            : item.position[2];
-        const [offsetX, offsetZ] = rotateVec(item.position[0], wallLocalZ, wallRotation);
-        result = {
-            point: [parent.start[0] + offsetX, parent.start[1] + offsetZ],
-            rotation: wallRotation + localRotation,
-        };
-    }
-    else if (parent?.type === 'cabinet' ||
-        parent?.type === 'cabinet-module' ||
-        parent?.type === 'procedural-item') {
-        const f = restingNodePlanFrame(item, (id) => nodes[id]);
-        result = {
-            point: [f.position[0], f.position[2]],
-            rotation: Math.atan2(f.axes[2][0], f.axes[2][2]),
-        };
-    }
-    else if (parent?.type === 'shelf') {
-        const shelf = parent;
-        const [offsetX, offsetZ] = rotateVec(item.position[0], item.position[2], shelf.rotation[1] ?? 0);
-        result = {
-            point: [shelf.position[0] + offsetX, shelf.position[2] + offsetZ],
-            rotation: (shelf.rotation[1] ?? 0) + localRotation,
-        };
-    }
-    else if (parent?.type === 'item') {
-        const parentTransform = resolveItemPlanTransform(parent, nodes, cache);
-        const [offsetX, offsetZ] = rotateVec(item.position[0], item.position[2], parentTransform.rotation);
-        result = {
-            point: [parentTransform.point[0] + offsetX, parentTransform.point[1] + offsetZ],
-            rotation: parentTransform.rotation + localRotation,
-        };
-    }
-    else if (parent?.type === 'roof-segment') {
-        // Roof-hosted wall item: FACE-LOCAL position mapped through the face
-        // frame, then composed through the segment's and roof's yaw +
-        // position into level-local plan coords — without this the drag seed
-        // jumps off the roof at move start.
-        const segment = parent;
-        const roof = segment.parentId
-            ? nodes[segment.parentId]
-            : undefined;
-        if (roof?.type === 'roof' && item.roofFace) {
-            const frame = getRoofWallFaceFrame(segment, item.roofFace);
-            const segLocal = roofFacePointToSegment(segment, item.roofFace, item.position);
-            const [sx, sz] = rotateVec(segLocal[0], segLocal[2], segment.rotation ?? 0);
-            const [rx, rz] = rotateVec(sx + segment.position[0], sz + segment.position[2], roof.rotation ?? 0);
-            result = {
-                point: [rx + roof.position[0], rz + roof.position[2]],
-                rotation: (roof.rotation ?? 0) + (segment.rotation ?? 0) + frame.yaw + localRotation,
-            };
-        }
-    }
-    else if (parent?.type === 'block' && item.blockFaceId) {
-        const frame = getBlockFaceFrame(parent.topology, item.blockFaceId);
-        if (frame) {
-            const localX = frame.origin[0] +
-                frame.xAxis[0] * item.position[0] +
-                frame.yAxis[0] * item.position[1] +
-                frame.normal[0] * item.position[2];
-            const localZ = frame.origin[2] +
-                frame.xAxis[2] * item.position[0] +
-                frame.yAxis[2] * item.position[1] +
-                frame.normal[2] * item.position[2];
-            const [offsetX, offsetZ] = rotateVec(localX, localZ, parent.rotation ?? 0);
-            result = {
-                point: [parent.position[0] + offsetX, parent.position[2] + offsetZ],
-                rotation: (parent.rotation ?? 0) - Math.atan2(frame.xAxis[2], frame.xAxis[0]) + localRotation,
-            };
-        }
-    }
-    cache.set(item.id, result);
-    return result;
 }
-function resolveItemPlanPoint(item, nodes, cache = new Map()) {
-    return resolveItemPlanTransform(item, nodes, cache).point;
+function resolveItemPlanPoint(item, nodes) {
+    return resolveItemPlanTransform(item, nodes).point;
 }
 function createPlanarMovePointResolver(originalPlanPoint, node) {
     const resolveCursor = createFloorplanCursorResolver({
@@ -211,49 +127,185 @@ function buildWallItemSession(node, startLevelId) {
  * bookkeeping and the item drops out of the level→children DFS the
  * floor-plan layer walks → the polygon stops rendering mid-drag.
  *
- * For the 2D move we just translate `position` in level-local coords and
- * leave the parent as the level (matching the 3D `detachItemSurfaceToFloor`
- * in `use-placement-coordinator.tsx`). Snap to the 0.5m grid unless the
- * user holds Shift.
+ * A host exit converts the pose to the level frame, matching the 3D
+ * `detachItemSurfaceToFloor`; inherited support lift stays out of stored Y.
  */
 function buildFloorItemSession(node, startLevelId, nodes) {
-    const rotationY = node.rotation[1] ?? 0;
-    const resolvePlanPoint = createPlanarMovePointResolver(resolveItemPlanPoint(node, nodes), node);
+    const host = node.parentId ? nodes[node.parentId] : undefined;
+    const hosted = host && host.type !== 'level';
+    const surfaceId = surfaceAttachmentId(node);
+    const hostPose = surfaceFramePose(node.parentId, surfaceId, node, false);
+    const planTransform = resolveItemPlanTransform(node, nodes);
+    const levelFrame = hosted ? restingNodePlanFrame(node, (id) => nodes[id]) : null;
+    const rotationY = levelFrame
+        ? Math.atan2(levelFrame.axes[2][0], levelFrame.axes[2][2])
+        : planTransform.rotation;
+    const levelRotation = [...node.rotation];
+    if (hosted) {
+        if (node.type === 'procedural-item') {
+            // Generated footprints use the query frame; catalog footprints keep their legacy plan mapping.
+            planTransform.point = [levelFrame.position[0], levelFrame.position[2]];
+            const hostFrame = restingNodePlanFrame(host, (id) => nodes[id]);
+            const headingPose = surfaceFramePose(node.parentId, surfaceId, { position: node.position, rotation: [0, node.rotation[1], 0] }, false);
+            levelRotation[1] =
+                headingPose.rotation[1] + Math.atan2(hostFrame.axes[2][0], hostFrame.axes[2][2]);
+        }
+        else {
+            levelRotation.splice(0, 3, hostPose.rotation[0], rotationY, hostPose.rotation[2]);
+        }
+    }
+    if (host?.type === 'block' && node.blockFaceId)
+        levelRotation.splice(0, 3, 0, rotationY, 0);
+    const resolvePlanPoint = createPlanarMovePointResolver(planTransform.point, node);
     // Alignment candidates gathered once — scene is stable during the drag.
     const candidates = collectAlignmentAnchors(nodes, node.id);
+    const scene = createSceneApi(useScene);
+    const bounds = nodeRegistry.get(node.type)?.capabilities.dragBounds?.(node, nodes);
+    const dimensions = bounds?.size ?? getScaledDimensions(node);
+    const localBounds = bounds?.center
+        ? {
+            min: bounds.center.map((v, i) => v - dimensions[i] / 2),
+            max: bounds.center.map((v, i) => v + dimensions[i] / 2),
+        }
+        : {
+            min: [-dimensions[0] / 2, 0, -dimensions[2] / 2],
+            max: [dimensions[0] / 2, dimensions[1], dimensions[2] / 2],
+        };
+    const originalBounds = boundsOf(boxCorners(localBounds.min, localBounds.max).map((p) => transformPoint(frame(hostPose.position, hostPose.rotation), p)));
+    const originalPlacement = hosted
+        ? resolveSurfacePlacement({
+            host,
+            childKind: node.type,
+            childId: node.id,
+            childFootprint: {
+                size: dimensions,
+                rotationY: hostPose.rotation[1],
+                rotation: hostPose.rotation,
+                localBounds,
+            },
+            hit: {
+                point: [
+                    (originalBounds.min[0] + originalBounds.max[0]) / 2,
+                    originalBounds.min[1],
+                    (originalBounds.min[2] + originalBounds.max[2]) / 2,
+                ],
+                normalWorldY: 1,
+            },
+            origin: hostPose.position,
+            scene,
+        })
+        : null;
+    const retainedSurfaceId = hosted && originalPlacement
+        ? getSurfaceProvider(host)
+            .surfaces?.(host, { scene })
+            .find((s) => s.id === (surfaceId ?? originalPlacement.surfaceId))?.id
+        : undefined;
+    const markMoved = () => {
+        for (const id of new Set([
+            ...cascadeDirty(node.id, { scene }),
+            ...collectDescendants(node.id, { scene }),
+        ]))
+            useScene.getState().markDirty(id);
+    };
     let lastPatch = null;
-    return {
+    let lastInput = null;
+    let commitBlocked = false;
+    let lastHostedPatch = {
+        parentId: node.parentId,
+        position: [...node.position],
+        rotation: [...node.rotation],
+        supportSlabId: undefined,
+    };
+    const session = {
         affectedIds: [node.id],
-        apply({ planPoint }) {
+        apply(input) {
+            lastInput = input;
+            commitBlocked = false;
+            const { planPoint } = input;
             const gridSnapped = resolvePlanPoint(planPoint);
             // Figma-style alignment layered on the grid snap, mode-driven (matching 3D):
             // guides are DISPLAYED in every snapping mode; the magnetic pull onto them
             // is applied only in "lines" mode (`applySnap`).
             const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], rotationY), candidates, { applySnap: isMagneticSnapActive() });
-            const host = node.parentId ? nodes[node.parentId] : undefined;
-            if (host?.type === 'cabinet' || host?.type === 'shelf') {
+            const liveHost = host && useScene.getState().nodes[host.id];
+            if (liveHost?.type === 'block' && node.blockFaceId) {
+                const face = getBlockFaceFrame(liveHost.topology, node.blockFaceId);
+                if (face && face.normal[1] > 0.99) {
+                    const hostFrame = restingNodePlanFrame(liveHost, (id) => useScene.getState().nodes[id]);
+                    const surface = composeFrames(hostFrame, {
+                        position: face.origin,
+                        axes: [face.xAxis, face.yAxis, face.normal],
+                    });
+                    const delta = [snapped[0] - surface.position[0], 0, snapped[1] - surface.position[2]];
+                    const uv = surface.axes
+                        .slice(0, 2)
+                        .map((axis) => axis.reduce((sum, v, i) => sum + v * delta[i], 0));
+                    const vertices = new Map(liveHost.topology.vertices.map((v) => [v.id, v.position]));
+                    const polygon = liveHost.topology.faces
+                        .find((f) => f.id === node.blockFaceId)
+                        .vertexIds.map((id) => {
+                        const v = vertices.get(id);
+                        const delta = v.map((value, i) => value - face.origin[i]);
+                        return [face.xAxis, face.yAxis].map((axis) => axis.reduce((sum, value, i) => sum + value * delta[i], 0));
+                    });
+                    if (surfaceRegionContainsPoint({ kind: 'polygon', points: polygon }, uv)) {
+                        lastPatch = {
+                            parentId: liveHost.id,
+                            position: [uv[0], uv[1], node.position[2]],
+                            rotation: [...node.rotation],
+                            supportSlabId: undefined,
+                        };
+                        useLiveNodeOverrides.getState().set(node.id, lastPatch);
+                        markMoved();
+                        return;
+                    }
+                }
+            }
+            if (hosted && liveHost && (liveHost.type !== 'block' || !node.blockFaceId)) {
+                const host = liveHost;
+                const retainedSurface = getSurfaceProvider(host)
+                    .surfaces?.(host, { scene })
+                    .find((s) => s.id === retainedSurfaceId);
                 const hostFrame = restingNodePlanFrame(host, (id) => useScene.getState().nodes[id]);
-                const dx = snapped[0] - hostFrame.position[0];
-                const dz = snapped[1] - hostFrame.position[2];
-                const local = [
-                    dx * hostFrame.axes[0][0] + dz * hostFrame.axes[0][2],
-                    node.position[1],
-                    dx * hostFrame.axes[2][0] + dz * hostFrame.axes[2][2],
-                ];
-                const bounds = nodeRegistry.get(node.type)?.capabilities.dragBounds?.(node, nodes);
-                const dimensions = bounds?.size ?? getScaledDimensions(node);
-                const center = bounds?.center;
-                const localBounds = center
-                    ? {
-                        min: center.map((v, i) => v - dimensions[i] / 2),
-                        max: center.map((v, i) => v + dimensions[i] / 2),
+                if (host.type === 'item') {
+                    const plan = resolveItemTransform(host, {
+                        resolve: (id) => useScene.getState().nodes[id],
+                    });
+                    if (plan) {
+                        hostFrame.position[0] = plan.x;
+                        hostFrame.position[2] = plan.y;
                     }
-                    : undefined;
-                const projected = boundsOf(boxCorners(localBounds?.min ?? [-dimensions[0] / 2, 0, -dimensions[2] / 2], localBounds?.max ?? [dimensions[0] / 2, dimensions[1], dimensions[2] / 2]).map((p) => transformPoint(frame(local, node.rotation), p)));
+                }
+                const surfaceFrame = composeFrames(hostFrame, frame(retainedSurface ? [...retainedSurface.position] : [0, hostPose.position[1], 0], retainedSurface ? [...(retainedSurface.rotation ?? [0, 0, 0])] : [0, 0, 0]));
+                const normal = surfaceFrame.axes[1];
+                const localRotation = originalPlacement?.surfaceLocal?.rotation ?? hostPose.rotation;
+                const bottomOffset = retainedSurface
+                    ? -Math.min(...boxCorners(localBounds.min, localBounds.max).map((p) => transformPoint(frame([0, 0, 0], [...localRotation]), p)[1]))
+                    : 0;
+                const y = surfaceFrame.position[1] +
+                    (bottomOffset -
+                        normal[0] * (snapped[0] - surfaceFrame.position[0]) -
+                        normal[2] * (snapped[1] - surfaceFrame.position[2])) /
+                        normal[1];
+                const delta = [
+                    snapped[0] - hostFrame.position[0],
+                    y - hostFrame.position[1],
+                    snapped[1] - hostFrame.position[2],
+                ];
+                const local = hostFrame.axes.map((axis) => axis.reduce((sum, v, i) => sum + v * delta[i], 0));
+                const projected = boundsOf(boxCorners(localBounds?.min ?? [-dimensions[0] / 2, 0, -dimensions[2] / 2], localBounds?.max ?? [dimensions[0] / 2, dimensions[1], dimensions[2] / 2]).map((p) => transformPoint(frame(local, hostPose.rotation), p)));
+                let occupied = false;
                 const pose = resolveSurfacePlacement({
                     host,
+                    surface: retainedSurface,
                     childKind: node.type,
-                    childFootprint: { size: dimensions, rotationY, rotation: node.rotation, localBounds },
+                    childId: node.id,
+                    childFootprint: {
+                        size: dimensions,
+                        rotationY: hostPose.rotation[1],
+                        rotation: hostPose.rotation,
+                        localBounds,
+                    },
                     hit: {
                         point: [
                             (projected.min[0] + projected.max[0]) / 2,
@@ -264,36 +316,63 @@ function buildFloorItemSession(node, startLevelId, nodes) {
                     },
                     origin: local,
                     scene: createSceneApi(useScene),
+                    onReject: (reason) => {
+                        occupied = reason === 'surface-occupied';
+                    },
                 });
-                if (pose && Math.abs(pose.position[1] - node.position[1]) < 1e-5) {
-                    lastPatch = { parentId: host.id, position: [...pose.position], supportSlabId: undefined };
+                if (occupied) {
+                    commitBlocked = useInteractionScope.getState().ownedSubtree?.creation.rootId === node.id;
+                    lastPatch = lastHostedPatch;
+                    useLiveNodeOverrides.getState().set(node.id, lastPatch);
+                    markMoved();
+                    return;
+                }
+                if (pose &&
+                    (pose.childFrame === 'surface-local' ? pose.surfaceId === surfaceId : surfaceId === null)) {
+                    const stored = pose.childFrame === 'surface-local' ? pose.surfaceLocal : pose;
+                    lastPatch = {
+                        parentId: host.id,
+                        position: [...stored.position],
+                        rotation: [...node.rotation],
+                        supportSlabId: undefined,
+                    };
+                    lastHostedPatch = lastPatch;
                     useLiveNodeOverrides.getState().set(node.id, lastPatch);
-                    useScene.getState().markDirty(node.id);
+                    markMoved();
                     return;
                 }
             }
-            const sourceY = node.position[1];
-            const nextPosition = [snapped[0], sourceY, snapped[1]];
+            const nextPosition = [
+                snapped[0],
+                hosted ? 0 : node.position[1],
+                snapped[1],
+            ];
             lastPatch = {
+                ...(node.blockFaceId ? clearFaceHostItemFields(host) : {}),
                 position: nextPosition,
+                rotation: levelRotation,
                 // Keep parent as the level we resolved at session-start. If
                 // somehow it's null (e.g. orphaned item), fall back to the
                 // existing parent so we don't write `null` and detach.
                 parentId: startLevelId ?? node.parentId,
             };
+            Object.assign(lastPatch, resolveSupportSlabPatch({ ...node, ...lastPatch }, nodes));
             useLiveNodeOverrides.getState().set(node.id, lastPatch);
-            useScene.getState().markDirty(node.id);
+            markMoved();
         },
         canCommit() {
-            return lastPatch !== null;
+            return lastPatch !== null && !commitBlocked;
         },
         commit() {
+            if (lastInput)
+                session.apply(lastInput);
             if (!lastPatch)
                 return;
+            updateSurfaceNode(node.id, lastPatch);
             useLiveNodeOverrides.getState().clear(node.id);
-            useScene.getState().updateNodes([{ id: node.id, data: lastPatch }]);
         },
     };
+    return session;
 }
 /**
  * Ceiling items reparent to whichever ceiling polygon contains the

package/dist/item/floorplan.d.ts

@@ -1,4 +1,26 @@
 import { type FloorplanGeometry, type GeometryContext, type ItemNode } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for item.
+ *
+ * Items can be parented to a wall, ceiling, slab, or another item.
+ * Position is in the parent's local frame, so we walk the parent chain
+ * via `ctx.resolve` to compute the world-space (level-local) transform.
+ *
+ * Mirrors `getItemFloorplanTransform` from editor/lib/floorplan/items.ts
+ * but uses the registry's resolve callback instead of a node map. Logic
+ * is identical so visual output matches the legacy.
+ *
+ * Returns a rotated rectangle of width × depth at the resolved position.
+ * Phase 5 follow-up may render `asset.floorPlanUrl` as a custom image
+ * overlay when present.
+ */
+type Transform = {
+    x: number;
+    y: number;
+    rotation: number;
+};
+export declare function resolveItemTransform(item: ItemNode, ctx: GeometryContext, cache?: Map<`roof_${string}` | `rseg_${string}` | `site_${string}` | `building_${string}` | `level_${string}` | `elevator_${string}` | `unit_${string}` | `zone_${string}` | `block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `slab_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}` | `cabinet_${string}` | `cabinet-module_${string}` | `sseg_${string}` | `bvent_${string}` | `rvent_${string}` | `tvent_${string}` | `cupola_${string}` | `eyebrow-vent_${string}` | `gutter_${string}` | `chimney_${string}` | `solarpanel_${string}` | `skylight_${string}` | `dormer_${string}` | `downspout_${string}`, Transform | null>): Transform | null;
 export declare function buildItemContextualDimensions(node: ItemNode, ctx: GeometryContext): FloorplanGeometry | null;
 export declare function buildItemFloorplan(node: ItemNode, ctx: GeometryContext): FloorplanGeometry | null;
+export {};
 //# sourceMappingURL=floorplan.d.ts.map

package/dist/item/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAkLzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmGjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAIzB;;;;;;;;;;;;;;GAcG;AACH,KAAK,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AA2D3D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,KAAK,0pCAAyC,GAC7C,SAAS,GAAG,IAAI,CAwKlB;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmGjG"}

package/dist/item/floorplan.js

@@ -1,4 +1,4 @@
-import { getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
+import { getBlockFaceFrame, getEffectiveNode, getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
 import { formatLinearMeasurement, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
 import { restingNodePlanFrame } from '../shared/resting-surface-plan';
 // Plan-space rotation convention used by the legacy `rotatePlanVector`
@@ -13,10 +13,57 @@ function rotateVec(x, y, angle) {
     const s = Math.sin(angle);
     return [x * c + y * s, -x * s + y * c];
 }
-function resolveItemTransform(item, ctx, cache = new Map()) {
+function needsFullAncestorFrame(item, ctx) {
+    let id = item.parentId;
+    const visited = new Set([item.id]);
+    while (id && !visited.has(id)) {
+        visited.add(id);
+        const parent = ctx.resolve(id);
+        if (!parent || parent.type === 'level')
+            break;
+        if (![
+            'wall',
+            'ceiling',
+            'roof',
+            'roof-segment',
+            'item',
+            'shelf',
+            'cabinet',
+            'cabinet-module',
+            'procedural-item',
+            'block',
+            'slab',
+        ].includes(parent.type)) {
+            const effective = getEffectiveNode(parent);
+            const live = useLiveTransforms.getState().get(parent.id);
+            const position = live?.position ?? effective.position;
+            const rotation = effective.rotation;
+            // Main's level-local fallback already handles identity plugins directly on a level.
+            if (parent.type === 'column' ||
+                (parent.parentId && ctx.resolve(parent.parentId)?.type !== 'level') ||
+                position?.some((v) => v !== 0) ||
+                live?.rotation ||
+                (Array.isArray(rotation) ? rotation.some((v) => v !== 0) : rotation))
+                return true;
+        }
+        id = parent.parentId;
+    }
+    return false;
+}
+export function resolveItemTransform(item, ctx, cache = new Map()) {
     const cached = cache.get(item.id);
     if (cached !== undefined)
         return cached;
+    if (needsFullAncestorFrame(item, ctx)) {
+        const f = restingNodePlanFrame(item, ctx.resolve);
+        const result = {
+            x: f.position[0],
+            y: f.position[2],
+            rotation: Math.atan2(f.axes[2][0], f.axes[2][2]),
+        };
+        cache.set(item.id, result);
+        return result;
+    }
     const localRotation = item.rotation[1] ?? 0;
     let result = null;
     const parentNode = item.parentId
@@ -75,6 +122,18 @@ function resolveItemTransform(item, ctx, cache = new Map()) {
         // shelf's own entry follows via the layer's effectiveNode override.
         const shelf = parentNode;
         const live = useLiveTransforms.getState().get(shelf.id);
+        if (shelf.parentId &&
+            ['item', 'shelf', 'cabinet', 'cabinet-module', 'procedural-item'].includes(ctx.resolve(shelf.parentId)?.type ?? '')) {
+            const parentT = resolveItemTransform({
+                ...shelf,
+                position: live?.position ?? shelf.position,
+                rotation: [0, live?.rotation ?? shelf.rotation[1], 0],
+            }, ctx, cache);
+            if (!parentT)
+                return null;
+            const [x, y] = rotateVec(item.position[0], item.position[2], parentT.rotation);
+            return { x: parentT.x + x, y: parentT.y + y, rotation: parentT.rotation + localRotation };
+        }
         const shelfX = live?.position[0] ?? shelf.position[0];
         const shelfZ = live?.position[2] ?? shelf.position[2];
         const shelfRotationY = live?.rotation ?? shelf.rotation[1] ?? 0;

package/dist/item/move-tool.d.ts

@@ -26,7 +26,7 @@ import { type PlacementState } from '@pascal-app/editor';
  * and dropped from editor.
  */
 export declare function getInitialState(node: ItemNode, parent?: AnyNode | undefined): PlacementState;
-export declare function MoveItemTool({ node }: {
+export declare function MoveItemTool({ node: source }: {
     node: ItemNode;
 }): import("react").JSX.Element;
 export default MoveItemTool;

package/dist/item/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/item/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAkB,KAAK,QAAQ,EAAY,MAAM,kBAAkB,CAAA;AACxF,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,oBAAoB,CAAA;AAG3B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,MAAM,GAAE,OAAO,GAAG,SAEL,GACZ,cAAc,CA4EhB;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,+BAsDxD;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/item/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,oBAAoB,CAAA;AAI3B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,MAAM,GAAE,OAAO,GAAG,SAEL,GACZ,cAAc,CAiFhB;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,+BAkEhE;AAED,eAAe,YAAY,CAAA"}

package/dist/item/move-tool.js

@@ -1,7 +1,8 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { useScene } from '@pascal-app/core';
+import { canHostSurfaceChild, useScene, } from '@pascal-app/core';
 import { triggerSFX, useDraftNode, useEditor, usePlacementCoordinator, } from '@pascal-app/editor';
+import { useMemo } from 'react';
 import { Vector3 } from 'three';
 /**
  * Phase 5 Stage D — item's registry-driven 3D move affordance.
@@ -78,7 +79,10 @@ export function getInitialState(node, parent = node.parentId
     // handler — which preserves the grab offset — instead of a fresh `enter()`
     // that snaps the item's origin under the cursor. Without this the item
     // teleports the instant it's grabbed.
-    if (parent?.type === 'item' || parent?.type === 'cabinet' || parent?.type === 'procedural-item') {
+    if (parent?.type === 'item' ||
+        parent?.type === 'cabinet' ||
+        parent?.type === 'procedural-item' ||
+        (parent && parent.type !== 'shelf' && canHostSurfaceChild(parent, node.type, node.id))) {
         return {
             surface: 'item-surface',
             wallId: null,
@@ -107,12 +111,16 @@ export function getInitialState(node, parent = node.parentId
         shelfId: null,
     };
 }
-export function MoveItemTool({ node }) {
+export function MoveItemTool({ node: source }) {
+    const node = useMemo(() => source.metadata?.isNew
+        ? (useScene.getState().nodes[source.id] ?? source)
+        : source, [source]);
     const draftNode = useDraftNode();
     const meta = typeof node.metadata === 'object' && node.metadata !== null
         ? node.metadata
         : {};
     const isNew = !!meta.isNew;
+    const isSceneDraft = useMemo(() => isNew && !!useScene.getState().nodes[node.id], [isNew, node.id]);
     const cursor = usePlacementCoordinator({
         asset: node.asset,
         draftNode,
@@ -120,7 +128,7 @@ export function MoveItemTool({ node }) {
         // items create their draft lazily inside the coordinator).
         slots: node.slots,
         // Duplicates start fresh in floor mode; wall/ceiling draft is created lazily by ensureDraft.
-        initialState: isNew
+        initialState: isNew && !isSceneDraft
             ? {
                 surface: 'floor',
                 wallId: null,
@@ -132,9 +140,9 @@ export function MoveItemTool({ node }) {
             : getInitialState(node),
         // Preserve the original item's scale so Y-position calculations use the correct height.
         defaultScale: isNew ? node.scale : undefined,
-        preserveDragOffset: true,
+        preserveDragOffset: !isSceneDraft,
         initDraft: (gridPosition) => {
-            if (isNew) {
+            if (isNew && !isSceneDraft) {
                 // Duplicate: floor items get a draft immediately; wall/ceiling
                 // items are created lazily on surface entry.
                 gridPosition.copy(new Vector3(...node.position));
@@ -144,7 +152,7 @@ export function MoveItemTool({ node }) {
             }
             else {
                 draftNode.adopt(node);
-                gridPosition.copy(new Vector3(...node.position));
+                gridPosition.copy(new Vector3(...draftNode.current.position));
             }
         },
         onCommitted: () => {

package/dist/item/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/item/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAYd,MAAM,kBAAkB,CAAA;AA6ZzB,eAAO,MAAM,YAAY,GAAI,qBAAqB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA4DnE,CAAA;AA+CD,eAAO,MAAM,WAAW,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AA4RD,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/item/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,QAAQ,EAYd,MAAM,kBAAkB,CAAA;AA6ZzB,eAAO,MAAM,YAAY,GAAI,qBAAqB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAmEnE,CAAA;AA+CD,eAAO,MAAM,WAAW,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAUvD,CAAA;AA4RD,eAAe,YAAY,CAAA"}

package/dist/item/renderer.js

@@ -292,8 +292,14 @@ export const ItemRenderer = ({ node: storeNode }) => {
             setSettled(true);
     }, [roomClearPreview, setSettled]);
     const content = (_jsx("group", { position: node.position, ref: ref, rotation: node.rotation, visible: node.visible, children: roomClearPreview ? (_jsx(ClearPreviewModel, { node: node })) : (_jsxs(_Fragment, { children: [_jsx(ModelWithRetry, { node: node, setSettled: setSettled }, node.asset.src ?? 'no-src'), node.children?.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] })) }));
-    if (node.blockFaceId && node.parentId) {
-        return (_jsx(BlockFaceHostFrame, { blockId: node.parentId, faceId: node.blockFaceId, children: content }));
+    // A floor-exit override is still mounted beneath the stored block until commit.
+    const faceNode = liveOverrides?.parentId &&
+        useScene.getState().nodes[liveOverrides.parentId]?.type === 'level' &&
+        useScene.getState().nodes[storeNode.parentId]?.type === 'block'
+        ? storeNode
+        : node;
+    if (faceNode.blockFaceId && faceNode.parentId) {
+        return (_jsx(BlockFaceHostFrame, { blockId: faceNode.parentId, faceId: faceNode.blockFaceId, children: content }));
     }
     if (!node.roofSegmentId)
         return content;

package/dist/level/renderer.js

@@ -7,6 +7,6 @@ export const LevelRenderer = ({ node }) => {
     const ref = useRef(null);
     useRegistry(node.id, node.type, ref);
     const handlers = useNodeEvents(node, 'level');
-    return (_jsx("group", { ref: ref, ...handlers, children: node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) }));
+    return (_jsx("group", { ref: ref, visible: node.visible !== false, ...handlers, children: node.children.map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) }));
 };
 export default LevelRenderer;

package/dist/lineset/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/lineset/tool.tsx"],"names":[],"mappings":"AAwFA,QAAA,MAAM,WAAW,0CA4QhB,CAAA;AAgCD,eAAe,WAAW,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/lineset/tool.tsx"],"names":[],"mappings":"AAwFA,QAAA,MAAM,WAAW,0CA6QhB,CAAA;AAgCD,eAAe,WAAW,CAAA"}

package/dist/lineset/tool.js

@@ -96,6 +96,7 @@ const LinesetTool = () => {
             // mitered polyline run.
             const lineset = LinesetNode.parse({
                 ...linesetDefinition.defaults(),
+                ...useEditor.getState().toolDefaults.lineset,
                 name: 'Lineset',
                 path: [start, end],
             });