@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/eyebrow-vent/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA+F1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA8DxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA+F1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA+DxE,CAAA"}

package/dist/eyebrow-vent/definition.js

@@ -127,6 +127,7 @@ export const eyebrowVentDefinition = {
     parametrics: eyebrowVentParametrics,
     handles: eyebrowVentHandles,
     floorplan: buildEyebrowVentFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/fence/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAgPpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA0H5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAgPpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA2H5D,CAAA"}

package/dist/fence/definition.js

@@ -256,6 +256,7 @@ export const fenceDefinition = {
         style: 'slat',
     }),
     capabilities: {
+        surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
         surfaces: { sides: { faces: 'all' } },
         duplicable: true,

package/dist/fence/tool.js

@@ -1,12 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { calculateLevelMiters, collectAlignmentAnchors, emitter, getTwoPointFenceCurveTangents, getWallMiterBoundaryPoints, resolveAlignment, sampleFenceSpline, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, snapFenceDraftPoint, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, useSegmentDraftChain, } from '@pascal-app/editor';
+import { CursorSphere, clearPlacementSurface, createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, snapFenceDraftPoint, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, useSegmentDraftChain, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Vector3 } from 'three';
-import { DraftAngleArc, DraftAxisGuides, DraftMeasurementLabel, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
+import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
 const FENCE_PREVIEW_HEIGHT = 1.8;
 const FENCE_PREVIEW_THICKNESS = 0.08;
 // Grid-plane surface publish (pointer-decided): scratch + constant normal so

package/dist/guide/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/guide/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAgD5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/guide/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAiD5D,CAAA"}

package/dist/guide/definition.js

@@ -31,6 +31,7 @@ export const guideDefinition = {
     parametrics: guideParametrics,
     // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
     dirtyTracking: false,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/gutter/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAoHrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA8D9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAoHrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA+D9D,CAAA"}

package/dist/gutter/definition.js

@@ -148,6 +148,7 @@ export const gutterDefinition = {
     handles: gutterHandles,
     floorplan: buildGutterFloorplan,
     floorplanDependsOnSiblings: true,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/hvac-equipment/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,0CAiHtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,0CAwHtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/hvac-equipment/tool.js

@@ -28,10 +28,15 @@ function snap(value, step) {
  */
 const HvacEquipmentTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
+    const toolDefaults = useEditor((s) => s.toolDefaults['hvac-equipment']);
     const [cursor, setCursor] = useState(null);
     const [yaw, setYaw] = useState(0);
     const yawRef = useRef(0);
-    const previewNode = useMemo(() => HvacEquipmentNode.parse({ ...hvacEquipmentDefinition.defaults(), name: 'Furnace' }), []);
+    const previewNode = useMemo(() => HvacEquipmentNode.parse({
+        ...hvacEquipmentDefinition.defaults(),
+        ...toolDefaults,
+        name: 'Furnace',
+    }), [toolDefaults]);
     const ghost = useMemo(() => {
         const group = buildHvacEquipmentGeometry(previewNode);
         group.traverse((child) => {
@@ -67,6 +72,7 @@ const HvacEquipmentTool = () => {
             const position = resolveAligned(event);
             const unit = HvacEquipmentNode.parse({
                 ...hvacEquipmentDefinition.defaults(),
+                ...toolDefaults,
                 name: 'Furnace',
                 position,
                 rotation: yawRef.current,
@@ -110,7 +116,7 @@ const HvacEquipmentTool = () => {
             window.removeEventListener('keydown', onKeyDown, true);
             clearDrawAlignment();
         };
-    }, [activeLevelId]);
+    }, [activeLevelId, toolDefaults]);
     if (!activeLevelId || !cursor)
         return null;
     return (_jsxs(LevelOffsetGroup, { children: [_jsx("group", { position: cursor, rotation: [0, yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [cursor[0], cursor[1] + previewNode.height + 0.4, cursor[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: _jsx("span", { className: "font-medium text-foreground", children: "R/T rotate" }) }) })] }));

package/dist/item/__fixtures__/main-floorplan.d.ts

@@ -0,0 +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=main-floorplan.d.ts.map

package/dist/item/__fixtures__/main-floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-floorplan.d.ts","sourceRoot":"","sources":["../../../src/item/__fixtures__/main-floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,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;AAe3D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,KAAK,0pCAAyC,GAC7C,SAAS,GAAG,IAAI,CA6JlB;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/__fixtures__/main-floorplan.js

@@ -0,0 +1,297 @@
+import { getBlockFaceFrame, 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`
+// in `editor/src/lib/floorplan/geometry.ts`. This is a CLOCKWISE rotation
+// — the registry-side equivalent of the canonical floor-plan transform
+// math. Don't switch to a standard counter-clockwise rotation; the wall
+// items math (wallRotation = -atan2(dy, dx)) is calibrated against this
+// convention, and the legacy item floor-plan stack reads from these
+// offsets across many sites.
+function rotateVec(x, y, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [x * c + y * s, -x * s + y * c];
+}
+export function resolveItemTransform(item, ctx, cache = new Map()) {
+    const cached = cache.get(item.id);
+    if (cached !== undefined)
+        return cached;
+    const localRotation = item.rotation[1] ?? 0;
+    let result = null;
+    const parentNode = item.parentId
+        ? ctx.resolve(item.parentId)
+        : undefined;
+    if (parentNode?.type === 'wall') {
+        // Wall-aligned: rotate item.position by wall's angle, anchor at wall.start.
+        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];
+        const [offsetX, offsetY] = rotateVec(item.position[0], wallLocalZ, wallRotation);
+        result = {
+            x: wall.start[0] + offsetX,
+            y: wall.start[1] + offsetY,
+            rotation: wallRotation + localRotation,
+        };
+    }
+    else if (parentNode?.type === 'item') {
+        // Nested item: recursively resolve parent's transform.
+        const parentT = resolveItemTransform(parentNode, ctx, cache);
+        if (parentT) {
+            const [offsetX, offsetY] = rotateVec(item.position[0], item.position[2], parentT.rotation);
+            result = {
+                x: parentT.x + offsetX,
+                y: parentT.y + offsetY,
+                rotation: parentT.rotation + localRotation,
+            };
+        }
+    }
+    else if (parentNode?.type === 'cabinet' ||
+        parentNode?.type === 'cabinet-module' ||
+        parentNode?.type === 'procedural-item') {
+        const f = restingNodePlanFrame(item, ctx.resolve);
+        result = {
+            x: f.position[0],
+            y: f.position[2],
+            rotation: Math.atan2(f.axes[2][0], f.axes[2][2]),
+        };
+    }
+    else if (parentNode?.type === 'shelf') {
+        // Shelf-hosted item: `item.position` is in shelf-local coords. The
+        // shelf has its own `position` + `rotation[1]` in its parent (level)
+        // frame, so the item's plan-space position composes the shelf's
+        // pose with the item's local offset. Without this branch the
+        // `else` below would treat shelf-local coords as level-local and
+        // the item would render at the wrong spot whenever the shelf is
+        // anywhere other than (0, 0, 0).
+        //
+        // We also check `useLiveTransforms` for the shelf — if the shelf is
+        // mid-move (3D or 2D), its scene-state `position` is still at the
+        // pre-move spot but the live transform carries the cursor-tracked
+        // position. Reading the live value here keeps the hosted item
+        // following the shelf in 2D throughout the drag, mirroring how the
+        // 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;
+        const [offsetX, offsetY] = rotateVec(item.position[0], item.position[2], shelfRotationY);
+        result = {
+            x: shelfX + offsetX,
+            y: shelfZ + offsetY,
+            rotation: shelfRotationY + localRotation,
+        };
+    }
+    else if (parentNode?.type === 'roof-segment') {
+        // Roof-hosted wall item: FACE-LOCAL position mapped through the face
+        // frame, then composed through the segment's and parent roof's poses
+        // into level-local plan coords.
+        const segment = parentNode;
+        const roof = segment.parentId
+            ? ctx.resolve(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 = {
+                x: rx + roof.position[0],
+                y: rz + roof.position[2],
+                rotation: (roof.rotation ?? 0) + (segment.rotation ?? 0) + frame.yaw + localRotation,
+            };
+        }
+    }
+    else if (parentNode?.type === 'block' && item.blockFaceId) {
+        const frame = getBlockFaceFrame(parentNode.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 hostRotation = parentNode.rotation ?? 0;
+            const [offsetX, offsetZ] = rotateVec(localX, localZ, hostRotation);
+            const faceRotation = -Math.atan2(frame.xAxis[2], frame.xAxis[0]);
+            result = {
+                x: parentNode.position[0] + offsetX,
+                y: parentNode.position[2] + offsetZ,
+                rotation: hostRotation + faceRotation + localRotation,
+            };
+        }
+    }
+    else {
+        // Level / slab / ceiling parent — item.position is level-local.
+        result = {
+            x: item.position[0],
+            y: item.position[2],
+            rotation: localRotation,
+        };
+    }
+    cache.set(item.id, result);
+    return result;
+}
+export function buildItemContextualDimensions(node, ctx) {
+    const transform = resolveItemTransform(node, ctx);
+    if (!transform)
+        return null;
+    const [width, , depth] = getScaledDimensions(node);
+    if (width <= 1e-6 || depth <= 1e-6)
+        return null;
+    const centerLocalZ = node.asset.attachTo === 'wall-side' ? depth / 2 : 0;
+    const [centerOffsetX, centerOffsetY] = rotateVec(0, centerLocalZ, transform.rotation);
+    const cx = transform.x + centerOffsetX;
+    const cy = transform.y + centerOffsetY;
+    const halfWidth = width / 2;
+    const halfDepth = depth / 2;
+    const point = (x, y) => {
+        const [rx, ry] = rotateVec(x, y, transform.rotation);
+        return [cx + rx, cy + ry];
+    };
+    const widthNormal = rotateVec(0, -1, transform.rotation);
+    const depthNormal = rotateVec(1, 0, transform.rotation);
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const metricNotation = readFloorplanMetricNotationOverride(ctx) ?? 'meters';
+    const stroke = ctx.viewState?.palette?.selectedStroke ?? '#2563eb';
+    return {
+        kind: 'group',
+        children: [
+            {
+                kind: 'dimension',
+                start: point(-halfWidth, -halfDepth),
+                end: point(halfWidth, -halfDepth),
+                offsetNormal: widthNormal,
+                offsetDistance: 0.28,
+                extensionOvershoot: 0.08,
+                text: formatLinearMeasurement(width, unit, metricNotation),
+                stroke,
+            },
+            {
+                kind: 'dimension',
+                start: point(halfWidth, -halfDepth),
+                end: point(halfWidth, halfDepth),
+                offsetNormal: depthNormal,
+                offsetDistance: 0.28,
+                extensionOvershoot: 0.08,
+                text: formatLinearMeasurement(depth, unit, metricNotation),
+                stroke,
+            },
+        ],
+    };
+}
+export function buildItemFloorplan(node, ctx) {
+    const transform = resolveItemTransform(node, ctx);
+    if (!transform)
+        return null;
+    const [width, , depth] = getScaledDimensions(node);
+    if (width <= 0 || depth <= 0)
+        return null;
+    // Wall-side items are anchored at the mounted wall face; their body extends
+    // depth-ward AWAY from the wall (into the room), so push the footprint centre
+    // a half-depth out along the item's local +Z. After the front/back π flip in
+    // `transform.rotation`, +depth/2 always points off the wall for either side;
+    // a negative offset would lay the footprint across the wall onto the far side.
+    const centerLocalZ = node.asset.attachTo === 'wall-side' ? depth / 2 : 0;
+    const [centerOffsetX, centerOffsetY] = rotateVec(0, centerLocalZ, transform.rotation);
+    const cx = transform.x + centerOffsetX;
+    const cy = transform.y + centerOffsetY;
+    // Rectangle corners in local space, rotated and translated.
+    const halfW = width / 2;
+    const halfD = depth / 2;
+    const corners = [
+        [-halfW, -halfD],
+        [halfW, -halfD],
+        [halfW, halfD],
+        [-halfW, halfD],
+    ];
+    const points = corners.map(([x, y]) => {
+        const [rx, ry] = rotateVec(x, y, transform.rotation);
+        return [cx + rx, cy + ry];
+    });
+    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 children = [
+        {
+            kind: 'polygon',
+            points,
+            // When an asset thumbnail is present, the polygon is a transparent
+            // hit-target — the image carries the visual weight. Without a
+            // thumbnail the polygon needs a light fill to read at all.
+            //
+            // `transparent` (not `none`) so the interior remains hit-testable —
+            // the registry layer's wrapping `<g>` only fires onPointerDown when
+            // the child renders a paintable surface. `fill="none"` would make
+            // clicks pass through to whatever's beneath, breaking selection.
+            fill: floorPlanUrl ? 'transparent' : '#fef3c7',
+            // Selected items read as selected: palette stroke + heavier weight
+            // (the move dot used to be the only cue, and it hides in
+            // multi-selections).
+            stroke: showSelection ? selectedStroke : '#92400e',
+            strokeWidth: showSelection ? 0.035 : 0.012,
+            opacity: 0.85,
+        },
+    ];
+    // Asset thumbnail — top-down PNG capture from the asset modal. Drawn
+    // inside the footprint with the item's rotation applied. Matches the
+    // legacy `FloorplanItemImage` overlay.
+    if (floorPlanUrl) {
+        children.push({
+            kind: 'image',
+            url: floorPlanUrl,
+            center: [cx, cy],
+            width,
+            height: depth,
+            // `rotateVec` (the footprint polygon) applies R(-angle), but the renderer
+            // draws the image with SVG `rotate(+deg)` = R(+angle). Negate so the
+            // sprite rotates the same way as its footprint box (and 3D); otherwise the
+            // two counter-rotate and diverge by 2x the item's rotation.
+            rotation: -transform.rotation,
+        });
+    }
+    // Selection ring ABOVE the thumbnail — the base polygon's selected stroke
+    // sits underneath the image, so re-draw it on top. `fill: none` keeps the
+    // ring click-through; the base polygon owns hit-testing.
+    if (showSelection && floorPlanUrl) {
+        children.push({
+            kind: 'polygon',
+            points,
+            fill: 'none',
+            stroke: selectedStroke,
+            strokeWidth: 0.035,
+            opacity: isSelected ? 0.95 : 0.7,
+        });
+    }
+    // Move handle — orange dot at the item center. Only when selected and not
+    // already moving: during a move the dot sits under the cursor, so a release
+    // over it would re-arm the move (and re-enter edit) instead of committing.
+    if (isSelected && !isMoving) {
+        children.push({
+            kind: 'move-handle',
+            point: [cx, cy],
+        });
+    }
+    return { kind: 'group', children };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA+HnC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAwL1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAOzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA+HnC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAyL1D,CAAA"}

package/dist/item/definition.js

@@ -1,4 +1,5 @@
 import { getScaledDimensions, } from '@pascal-app/core';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
 import { buildItemContextualDimensions, buildItemFloorplan } from './floorplan';
 import { itemFloorplanMoveTarget } from './floorplan-move';
 import { itemPaint } from './paint';
@@ -196,7 +197,7 @@ export const itemDefinition = {
                 },
             },
         },
-        duplicable: true,
+        duplicable: { subtree: 'with-children' },
         deletable: true,
         paint: itemPaint,
         // Items participate in compositions — e.g. "table-with-plants",
@@ -297,6 +298,7 @@ export const itemDefinition = {
     // Stage C: floor-plan polygon. ctx.resolve walks the parent chain
     // (wall / nested item / level) to compute the world-space transform.
     floorplan: buildItemFloorplan,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
     // 2D move-on-floorplan handler. Branches on `asset.attachTo`:
     // wall items snap to walls (like door / window), ceiling items
     // snap to ceiling polygons, floor items snap to slabs. attachTo

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/item/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAGhB,KAAK,mBAAmB,EAKxB,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AAkLzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA;AAoOD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,UAAU,EAAE,SAAS,GACpB,WAAW,GAAG,IAAI,CAwBpB"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/item/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,WAAW,EAMhB,KAAK,mBAAmB,EAKxB,KAAK,QAAQ,EAQd,MAAM,kBAAkB,CAAA;AA+EzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA;AAgaD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,UAAU,EAAE,SAAS,GACpB,WAAW,GAAG,IAAI,CAwBpB"}