@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAiDjE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,EAAE,MA2D3B,CAAA;AAED,OAAO,EACL,iBAAiB,EACjB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,iBAAiB,EACjB,eAAe,GAChB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,iBAAiB,EACjB,uBAAuB,EACvB,gCAAgC,EAChC,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAA;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,KAAK,yBAAyB,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAA;AAC/F,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -19,6 +19,7 @@ import { fenceDefinition } from './fence';
 import { guideDefinition } from './guide';
 import { gutterDefinition } from './gutter';
 import { hvacEquipmentDefinition } from './hvac-equipment';
+import { importedMeshDefinition } from './imported-mesh';
 import { itemDefinition } from './item';
 import { leanToExtensionDefinition } from './lean-to-extension';
 import { levelDefinition } from './level';
@@ -28,6 +29,7 @@ import { measurementDefinition } from './measurement';
 import { pipeFittingDefinition } from './pipe-fitting';
 import { pipeSegmentDefinition } from './pipe-segment';
 import { pipeTrapDefinition } from './pipe-trap';
+import { proceduralItemDefinition } from './procedural-item/definition';
 import { ridgeVentDefinition } from './ridge-vent';
 import { roofDefinition } from './roof';
 import { roofSegmentDefinition } from './roof-segment';
@@ -42,6 +44,7 @@ import { stairDefinition } from './stair';
 import { stairSegmentDefinition } from './stair-segment';
 import { structuralGridDefinition } from './structural-grid';
 import { turbineVentDefinition } from './turbine-vent';
+import { unitDefinition } from './unit';
 import { wallDefinition } from './wall';
 import { windowDefinition } from './window';
 import { zoneDefinition } from './zone';
@@ -79,10 +82,13 @@ export const builtinPlugin = {
         cabinetDefinition,
         cabinetModuleDefinition,
         itemDefinition,
+        proceduralItemDefinition,
+        importedMeshDefinition,
         // Stage A — wrap-exports the legacy renderer + system. Legacy
         // panels / move tools / floorplan branches still serve these.
         columnDefinition,
         elevatorDefinition,
+        unitDefinition,
         roofDefinition,
         roofSegmentDefinition,
         stairDefinition,
@@ -143,6 +149,7 @@ export { fenceDefinition } from './fence';
 export { guideDefinition } from './guide';
 export { gutterDefinition } from './gutter';
 export { hvacEquipmentDefinition } from './hvac-equipment';
+export { importedMeshDefinition } from './imported-mesh';
 export { itemDefinition } from './item';
 export { leanToExtensionDefinition } from './lean-to-extension';
 export { levelDefinition } from './level';
@@ -166,6 +173,7 @@ export { stairDefinition } from './stair';
 export { stairSegmentDefinition } from './stair-segment';
 export { structuralGridDefinition } from './structural-grid';
 export { turbineVentDefinition } from './turbine-vent';
+export { unitDefinition } from './unit';
 export { wallDefinition } from './wall';
 export { windowDefinition } from './window';
 export { zoneDefinition } from './zone';

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

@@ -1,3 +1,11 @@
-import { type FloorplanMoveTarget, type ItemNode } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type CeilingNode, type FloorplanMoveTarget, type ItemNode } from '@pascal-app/core';
 export declare const itemFloorplanMoveTarget: FloorplanMoveTarget<ItemNode>;
+/**
+ * Walk every ceiling under the level and return the first one whose
+ * polygon contains the pointer. Holes are honoured — a point inside a
+ * hole counts as not inside the surface. Slabs are intentionally NOT a
+ * valid target: floor items are parented to the level, not the slab,
+ * because slabs don't carry a `children` field on their schema.
+ */
+export declare function findContainingSurface(point: readonly [number, number], nodes: Record<AnyNodeId, AnyNode>, parentLevelId: AnyNodeId | null, targetKind: 'ceiling'): CeilingNode | null;
 //# sourceMappingURL=floorplan-move.d.ts.map

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,EAKL,KAAK,mBAAmB,EAKxB,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AAsKzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA"}
+{"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"}