@pascal-app/nodes 1.0.1 → 1.0.4

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}` | `separator_${string}` | `floor-opening_${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}` | `fence-gate_${string}` | `fence-opening_${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,EAOpB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;;;;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,mwCAAyC,GAC7C,SAAS,GAAG,IAAI,CAyKlB;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,CA+HjG"}

package/dist/item/floorplan.js

@@ -1,6 +1,7 @@
-import { getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
-import { formatLinearMeasurement, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
+import { getBlockFaceFrame, getEffectiveNode, getRoofWallFaceFrame, getScaledDimensions, getWallBodyCenterOffset, getWallLocalFaceZ, roofFacePointToSegment, scriptImages, useLiveTransforms, } from '@pascal-app/core';
+import { formatLinearMeasurement, readFloorplanContext, readFloorplanMetricNotationOverride, } from '@pascal-app/editor';
 import { restingNodePlanFrame } from '../shared/resting-surface-plan';
+import { buildPlanItemSymbol, classifyPlanItem, PLAN_SYMBOL_METADATA_KEY } from './plan-symbols';
 // Plan-space rotation convention used by the legacy `rotatePlanVector`
 // in `editor/src/lib/floorplan/geometry.ts`. This is a CLOCKWISE rotation
 // — the registry-side equivalent of the canonical floor-plan transform
@@ -13,10 +14,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
@@ -27,8 +75,9 @@ function resolveItemTransform(item, ctx, cache = new Map()) {
         const wall = parentNode;
         const wallRotation = -Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
         const wallLocalZ = item.asset.attachTo === 'wall-side'
-            ? ((wall.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
-            : item.position[2];
+            ? getWallLocalFaceZ(parentNode, item.side === 'front' ? 'a' : 'b')
+            : item.position[2] +
+                (item.asset.attachTo === 'wall' ? getWallBodyCenterOffset(parentNode) : 0);
         const [offsetX, offsetY] = rotateVec(item.position[0], wallLocalZ, wallRotation);
         result = {
             x: wall.start[0] + offsetX,
@@ -75,6 +124,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;
@@ -214,13 +275,41 @@ export function buildItemFloorplan(node, ctx) {
         const [rx, ry] = rotateVec(x, y, transform.rotation);
         return [cx + rx, cy + ry];
     });
+    // A sheet (drafting) draws the permit-set symbol — fixtures as labelled
+    // linework, furniture as a light outline — never the sprite or the
+    // editor's amber footprint. Ceiling items and decor draw nothing.
+    if (readFloorplanContext(ctx).drafting) {
+        const planClass = classifyPlanItem(node.asset);
+        const symbol = buildPlanItemSymbol(planClass, {
+            map: (x, y) => {
+                const [rx, ry] = rotateVec(x, y, transform.rotation);
+                return [cx + rx, cy + ry];
+            },
+            width,
+            depth,
+        });
+        // the sheet lays its tags out around fixtures and (more loosely)
+        // furniture; the mark rides on the outline itself, which the sheet's
+        // model / annotation split passes through untouched (it rebuilds groups)
+        const [outline, ...rest] = symbol;
+        if (!outline)
+            return null;
+        const marked = {
+            ...outline,
+            metadata: {
+                ...outline.metadata,
+                [PLAN_SYMBOL_METADATA_KEY]: planClass.kind,
+            },
+        };
+        return { kind: 'group', children: [marked, ...rest] };
+    }
     const isSelected = ctx.viewState?.selected ?? false;
     // Marquee preview — the about-to-be-selected tint every other kind shows.
     const isHighlighted = ctx.viewState?.highlighted ?? false;
     const showSelection = isSelected || isHighlighted;
     const isMoving = ctx.viewState?.moving ?? false;
     const selectedStroke = ctx.viewState?.palette?.selectedStroke ?? '#3b82f6';
-    const floorPlanUrl = node.asset.floorPlanUrl;
+    const floorPlanUrl = scriptImages(node)?.floorPlan ?? node.asset.floorPlanUrl;
     const children = [
         {
             kind: 'polygon',

package/dist/item/index.d.ts

@@ -1,3 +1,4 @@
 export { itemDefinition } from './definition';
+export { getPendingItemModelLoadCount } from './model-loader';
 export { ItemNode } from './schema';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/item/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/item/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAA;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA"}

package/dist/item/index.js

@@ -1,2 +1,3 @@
 export { itemDefinition } from './definition';
+export { getPendingItemModelLoadCount } from './model-loader';
 export { ItemNode } from './schema';

package/dist/item/model-loader.d.ts

@@ -1,5 +1,7 @@
 import { LoadingManager } from 'three';
 import { type GLTF, GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+/** Active item transactions on this host manager, including their retry waits. */
+export declare function getPendingItemModelLoadCount(manager?: LoadingManager): number;
 export type ItemAssetUnavailable = {
     message: string;
     url: string;

package/dist/item/model-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-loader.d.ts","sourceRoot":"","sources":["../../src/item/model-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,cAAc,EAAE,MAAM,OAAO,CAAA;AACpE,OAAO,EAAE,KAAK,IAAI,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAA;AAUhF,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,aAAa,GAAG,YAAY,CAAA;AAEjF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgBrF;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAiB3E;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,oBAAoB,GAAG,IAAI,CAO/E;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,QAE9C;AAED,qBAAa,cAAe,SAAQ,UAAU;IAC5C,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAA;IACpC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;gBAE7B,OAAO,CAAC,EAAE,cAAc,EAAE,aAAa,wBAA0B;IAMpE,IAAI,CACX,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,IAAI;CAwER"}
+{"version":3,"file":"model-loader.d.ts","sourceRoot":"","sources":["../../src/item/model-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,cAAc,EAAE,MAAM,OAAO,CAAA;AAEpE,OAAO,EAAE,KAAK,IAAI,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAA;AAOhF,kFAAkF;AAClF,wBAAgB,4BAA4B,CAAC,OAAO,iBAAwB,GAAG,MAAM,CAEpF;AAMD,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,aAAa,GAAG,YAAY,CAAA;AAEjF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgBrF;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAiB3E;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,oBAAoB,GAAG,IAAI,CAO/E;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,QAE9C;AAED,qBAAa,cAAe,SAAQ,UAAU;IAC5C,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAA;IACpC,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;gBAE7B,OAAO,CAAC,EAAE,cAAc,EAAE,aAAa,wBAA0B;IAOpE,IAAI,CACX,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EAC5B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,IAAI;CA+FR"}