@pascal-app/nodes 0.1.1

package/dist/cupola/preview.d.ts

@@ -0,0 +1,13 @@
+import type { CupolaNode } from './schema';
+/**
+ * Translucent ghost of a cupola, used by the placement tool's cursor and
+ * the move-tool preview. Builds geometry through the shared pure builder so
+ * the ghost stays in lockstep with the committed cupola. Raycast disabled
+ * so the preview doesn't intercept the cursor ray feeding the tool.
+ */
+declare const CupolaPreview: ({ node, invalid }: {
+    node: CupolaNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default CupolaPreview;
+//# sourceMappingURL=preview.d.ts.map

package/dist/cupola/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/cupola/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;GAKG;AACH,QAAA,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCAgDhF,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/cupola/preview.js

@@ -0,0 +1,37 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
+import { buildCupolaGeometry } from './geometry';
+/**
+ * Translucent ghost of a cupola, used by the placement tool's cursor and
+ * the move-tool preview. Builds geometry through the shared pure builder so
+ * the ghost stays in lockstep with the committed cupola. Raycast disabled
+ * so the preview doesn't intercept the cursor ray feeding the tool.
+ */
+const CupolaPreview = ({ node, invalid }) => {
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildCupolaGeometry(node), [node.width, node.depth, node.height, node.roofStyle, node.finial]);
+    const material = useMemo(() => new THREE.MeshStandardMaterial({
+        color: invalid ? INVALID_GHOST_COLOR : 0xff_ff_ff,
+        emissive: invalid ? INVALID_GHOST_COLOR : 0x6c_a3_ff,
+        emissiveIntensity: 0.18,
+        roughness: 0.7,
+        metalness: 0.1,
+        transparent: true,
+        opacity: invalid ? 0.4 : 0.35,
+        depthWrite: false,
+        side: THREE.DoubleSide,
+    }), [invalid]);
+    const edgesGeometry = useMemo(() => new THREE.EdgesGeometry(geometry, 25), [geometry]);
+    useEffect(() => () => {
+        geometry.dispose();
+        edgesGeometry.dispose();
+        material.dispose();
+    }, [geometry, edgesGeometry, material]);
+    return (_jsxs("group", { "rotation-y": node.rotation ?? 0, children: [_jsx("mesh", { geometry: geometry, material: material, raycast: () => {
+                    /* disabled — see component-level note */
+                } }), _jsx("lineSegments", { geometry: edgesGeometry, renderOrder: 1000, children: _jsx("lineBasicMaterial", { color: 0x6c_a3_ff, depthTest: false, opacity: 0.95, transparent: true }) })] }));
+};
+export default CupolaPreview;

package/dist/cupola/renderer.d.ts

@@ -0,0 +1,12 @@
+import { type CupolaNode } from '@pascal-app/core';
+/**
+ * Cupola renderer. Same transform stack as the box vent — the cupola is
+ * parented to a roof-segment, so this reads the segment directly and
+ * reproduces the segment-local transform (segment position → rotation →
+ * cupola position → slope tilt → cupola yaw → mesh). No animation.
+ */
+declare const CupolaRenderer: ({ node: storeNode }: {
+    node: CupolaNode;
+}) => import("react").JSX.Element | null;
+export default CupolaRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/cupola/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAqBzB;;;;;GAKG;AACH,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCAqFhE,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/cupola/renderer.js

@@ -0,0 +1,66 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { buildCupolaGeometry } from './geometry';
+const defaultMaterial = new THREE.MeshStandardMaterial({
+    color: 0xff_ff_ff,
+    roughness: 0.7,
+    metalness: 0.2,
+});
+/**
+ * Cupola renderer. Same transform stack as the box vent — the cupola is
+ * parented to a roof-segment, so this reads the segment directly and
+ * reproduces the segment-local transform (segment position → rotation →
+ * cupola position → slope tilt → cupola yaw → mesh). No animation.
+ */
+const CupolaRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'cupola', ref);
+    const handlers = useNodeEvents(storeNode, 'cupola');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
+    const node = overrides ? { ...storeNode, ...overrides } : storeNode;
+    const segment = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildCupolaGeometry(node), [node.width, node.depth, node.height, node.roofStyle, node.finial]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    const surfaceQuat = useMemo(() => {
+        if (!segment)
+            return new THREE.Quaternion();
+        const normal = getAnalyticalNormal(node.position[0] ?? 0, node.position[2] ?? 0, segment);
+        return surfaceQuatFromNormal(normal, new THREE.Quaternion());
+    }, [segment, node.position[0], node.position[2]]);
+    const material = useMemo(() => {
+        if (!textures || (!node.material && !node.materialPreset)) {
+            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        }
+        return node.material
+            ? createMaterial(node.material, shading)
+            : (createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial);
+    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+    const yAxis = useMemo(() => new THREE.Vector3(0, 1, 0), []);
+    const composedQuat = useMemo(() => {
+        const yawQuat = new THREE.Quaternion().setFromAxisAngle(yAxis, node.rotation ?? 0);
+        return new THREE.Quaternion().copy(surfaceQuat).multiply(yawQuat);
+    }, [surfaceQuat, node.rotation, yAxis]);
+    // Map cupola-local geometry into the host segment's local frame (where the
+    // trim cut prisms live) — same pose the inner mesh group is mounted with.
+    const localToSegment = useMemo(() => new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0), composedQuat, new THREE.Vector3(1, 1, 1)), [node.position[0], node.position[1], node.position[2], composedQuat]);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, segment, localToSegment);
+    if (!segment)
+        return null;
+    const segPos = segment.position ?? [0, 0, 0];
+    const segRotY = segment.rotation ?? 0;
+    return (_jsx("group", { position: segPos, "rotation-y": segRotY, children: _jsx("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], quaternion: composedQuat, ref: ref, visible: node.visible, children: _jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "cupola-surface", receiveShadow: true, ...handlers }) }) }));
+};
+export default CupolaRenderer;

package/dist/cupola/schema.d.ts

@@ -0,0 +1,2 @@
+export { CupolaNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/cupola/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/cupola/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/cupola/schema.js

@@ -0,0 +1,3 @@
+// Schema lives in core (referenced by the AnyNode union). Re-export so
+// every cupola-related import stays inside @pascal-app/nodes/cupola.
+export { CupolaNode } from '@pascal-app/core';

package/dist/cupola/tool.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cupola placement tool. Mounts when the palette activates the cupola kind;
+ * listens for `roof:*` events; on click commits a new `CupolaNode` parented
+ * to the targeted segment with segment-local coordinates. Mirrors box-vent.
+ */
+declare const CupolaTool: () => import("react").JSX.Element;
+export default CupolaTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/cupola/tool.tsx"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH,QAAA,MAAM,UAAU,mCAuHf,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/cupola/tool.js

@@ -0,0 +1,105 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { CupolaNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { cupolaDefinition } from './definition';
+import CupolaPreview from './preview';
+const worldPoint = new THREE.Vector3();
+/**
+ * Cupola placement tool. Mounts when the palette activates the cupola kind;
+ * listens for `roof:*` events; on click commits a new `CupolaNode` parented
+ * to the targeted segment with segment-local coordinates. Mirrors box-vent.
+ */
+const CupolaTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    const lastSnapRef = useRef(null);
+    const previewNode = useMemo(() => CupolaNode.parse({
+        ...cupolaDefinition.defaults(),
+        name: 'Cupola',
+        position: [0, 0, 0],
+        rotation: 0,
+    }), []);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const worldToBuildingLocal = (wx, wy, wz) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            if (!buildingObj)
+                return [wx, wy, wz];
+            worldPoint.set(wx, wy, wz);
+            buildingObj.worldToLocal(worldPoint);
+            return [worldPoint.x, worldPoint.y, worldPoint.z];
+        };
+        const updatePreview = (event) => {
+            const wx = event.position[0];
+            const wy = event.position[1];
+            const wz = event.position[2];
+            const sx = Math.round(wx * 20) / 20;
+            const sz = Math.round(wz * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            const hit = resolveRoofSegmentHit(event.node, wx, wy, wz);
+            if (!hit)
+                return;
+            const normal = getAnalyticalNormal(hit.localX, hit.localZ, hit.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0));
+            setPreviewPos(worldToBuildingLocal(wx, wy, wz));
+            publishRoofSurfacePlacementGuides({
+                roof: event.node,
+                segment: hit.segment,
+                center: [hit.localX, hit.localY, hit.localZ],
+                footprint: roofSurfaceFootprintFromNode(previewNode),
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const state = useScene.getState();
+            const cupola = CupolaNode.parse({
+                ...cupolaDefinition.defaults(),
+                name: 'Cupola',
+                roofSegmentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                rotation: 0,
+            });
+            state.createNode(cupola, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [cupola.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(CupolaPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
+                    setPreviewPos(null);
+                    setPreviewSurfaceQuat(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && previewPos && previewSurfaceQuat && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(CupolaPreview, { node: previewNode }) }) }) }))] }));
+};
+export default CupolaTool;

package/dist/door/definition.d.ts

@@ -0,0 +1,23 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { DoorNode } from './schema';
+/**
+ * Door — Phase 5 batch kind. Hosted on walls, cuts holes in them,
+ * animated open/close state.
+ *
+ * Capabilities:
+ *  - **No `movable`**: door's move is bespoke wall-bound drag (slide
+ *    along the wall, snap to wall start/end). Capability-driven dispatch
+ *    keeps legacy `MoveDoorTool`.
+ *  - `selectable`, `duplicable`, `deletable` standard.
+ *
+ * Stages:
+ *  - A: registered.
+ *  - B: deferred — door geometry (frame / leaf / glass / hardware /
+ *    segments) is ~800 lines in DoorSystem; extraction is a focused
+ *    session. `def.renderer` (wrap-export of legacy DoorRenderer) +
+ *    `def.system` (DoorSystem + DoorAnimationSystem bundle) hold parity.
+ *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
+ *    `openingPolygons` short-circuits door entries when registered.
+ */
+export declare const doorDefinition: NodeDefinition<typeof DoorNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AAWzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAkInC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA6G1D,CAAA"}

package/dist/door/definition.js

@@ -0,0 +1,257 @@
+import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
+import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
+import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
+import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides';
+import { scaleHandleHeight } from './door-math';
+import { buildDoorFloorplan } from './floorplan';
+import { doorWidthAffordance } from './floorplan-affordances';
+import { doorFloorplanMoveTarget } from './floorplan-move';
+import { doorPaint } from './paint';
+import { doorParametrics } from './parametrics';
+import { DoorNode } from './schema';
+import { doorSlots } from './slots';
+const SIDE_HANDLE_OFFSET = 0.24;
+const HEIGHT_HANDLE_OFFSET = 0.24;
+const MIN_DOOR_HEIGHT = 0.5;
+const MIN_DOOR_WIDTH = 0.3;
+// How far the move cross floats off the wall face (+Z, the door's facing
+// normal) so it's grabbable instead of buried in the leaf/frame.
+const MOVE_HANDLE_LIFT = 0.12;
+function readWallLength(door, scene) {
+    if (!door.wallId)
+        return Number.POSITIVE_INFINITY;
+    const wall = scene.get(door.wallId);
+    if (!wall)
+        return Number.POSITIVE_INFINITY;
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+function readWallHeight(door, scene) {
+    if (!door.wallId)
+        return Number.POSITIVE_INFINITY;
+    const wall = scene.get(door.wallId);
+    return wall?.height ?? Number.POSITIVE_INFINITY;
+}
+// Width arrow on the door-local +X (right) or -X (left) side. Drag grows
+// the door from the anchored OPPOSITE edge; the door's wall-local center
+// re-centers so the anchored edge stays put.
+function doorWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
+        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_DOOR_WIDTH,
+        max: (n, scene) => {
+            // Roof-hosted doors clamp against the face profile (the wall-based
+            // limits read Infinity when wallId is unset).
+            const roofMax = readRoofFaceWidthMax(n, scene, sign);
+            if (roofMax !== null)
+                return Math.max(MIN_DOOR_WIDTH, roofMax);
+            return readWallLength(n, scene);
+        },
+        currentValue: (n) => n.width,
+        onDrag: (node) => publishOpeningResizeGuides(node, false),
+        apply: (initial, newWidth) => {
+            // Anchored edge stays fixed in wall-local coords. Door rotation is
+            // applied by the inner ride group (the renderer mounts a nested
+            // <group> at the door's pose), so the apply math here is in
+            // door-local coords AND the patch.position must be in wall-local
+            // coords. We compute the anchored wall-local point from the
+            // initial node, then derive the new wall-local center from it.
+            const rotY = initial.rotation[1];
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
+            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
+            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
+            return {
+                width: newWidth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+            };
+        },
+        placement: {
+            // door-local: +X axis lives along door's own X. Inner ride group
+            // applies door.rotation, so we sit purely on door-local +X / -X.
+            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), 0, 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+    };
+}
+function doorHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min', // bottom anchored at wall-local Y = position[1] - height/2
+        min: MIN_DOOR_HEIGHT,
+        max: (n, scene) => {
+            const roofMax = readRoofFaceHeightMax(n, scene, 1);
+            if (roofMax !== null)
+                return Math.max(MIN_DOOR_HEIGHT, roofMax);
+            const bottom = n.position[1] - n.height / 2;
+            return Math.max(MIN_DOOR_HEIGHT, readWallHeight(n, scene) - bottom);
+        },
+        currentValue: (n) => n.height,
+        onDrag: (node) => publishOpeningResizeGuides(node, false),
+        apply: (initial, newHeight) => {
+            const bottom = initial.position[1] - initial.height / 2;
+            // Scale the handle so it tracks the door instead of staying glued to a
+            // fixed floor height (shared with the panel's Height slider).
+            return {
+                height: newHeight,
+                position: [initial.position[0], bottom + newHeight / 2, initial.position[2]],
+                handleHeight: scaleHandleHeight(initial.handleHeight, initial.height, newHeight),
+            };
+        },
+        placement: {
+            position: (n) => [0, n.height / 2 + HEIGHT_HANDLE_OFFSET, 0],
+        },
+        portal: 'grandparent',
+    };
+}
+// Press-drag move grip at the door centre, standing in the wall face. Routes
+// through the same move tool as the floating Move button (3D
+// `affordanceTools.move`, 2D `floorplanMoveTarget`) — wall slide + re-host onto
+// another wall — but `engageMoveDrag` commits on release, with no second click.
+function doorMoveHandle() {
+    return {
+        kind: 'tap-action',
+        shape: 'move-cross',
+        plane: 'node-normal',
+        portal: 'grandparent',
+        cursor: 'move',
+        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
+        placement: {
+            position: () => [0, 0, MOVE_HANDLE_LIFT],
+        },
+    };
+}
+const doorHandles = [
+    doorMoveHandle(),
+    doorWidthHandle('left'),
+    doorWidthHandle('right'),
+    doorHeightHandle(),
+];
+/**
+ * Door — Phase 5 batch kind. Hosted on walls, cuts holes in them,
+ * animated open/close state.
+ *
+ * Capabilities:
+ *  - **No `movable`**: door's move is bespoke wall-bound drag (slide
+ *    along the wall, snap to wall start/end). Capability-driven dispatch
+ *    keeps legacy `MoveDoorTool`.
+ *  - `selectable`, `duplicable`, `deletable` standard.
+ *
+ * Stages:
+ *  - A: registered.
+ *  - B: deferred — door geometry (frame / leaf / glass / hardware /
+ *    segments) is ~800 lines in DoorSystem; extraction is a focused
+ *    session. `def.renderer` (wrap-export of legacy DoorRenderer) +
+ *    `def.system` (DoorSystem + DoorAnimationSystem bundle) hold parity.
+ *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
+ *    `openingPolygons` short-circuits door entries when registered.
+ */
+export const doorDefinition = {
+    kind: 'door',
+    snapProfile: 'item',
+    facingIndicator: true,
+    schemaVersion: 1,
+    schema: DoorNode,
+    category: 'structure',
+    surfaceRole: 'joinery',
+    // Leverage the schema's zod `.default()` annotations to compute the
+    // full default shape — door has 40+ fields, listing them inline would
+    // duplicate the schema. Parse a minimal stub, drop id/type, return rest.
+    defaults: () => {
+        const stub = DoorNode.parse({ id: 'door_default', type: 'door' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        wallOpeningPlacement: true,
+        // Doors also host on roof-segment wall faces (base walls under the
+        // roof, gable ends). `buildCut` punches the opening into the
+        // segment's wall brush; `dirtyHandledByOwnSystem` keeps the roof-merge
+        // loop from consuming door dirty marks (DoorSystem owns them and
+        // already cascades to the host via parentId).
+        roofAccessory: {
+            buildCut: (node, hostSegment) => buildRoofWallOpeningCut(node, hostSegment),
+            cutScope: 'wall',
+            dirtyHandledByOwnSystem: true,
+        },
+        // `wallId` / `roofSegmentId` tie the door to its host and are
+        // re-derived from the surface under the cursor when a preset is
+        // placed. Host apps strip these at preset-save time via
+        // `getHostRefFields(def)`.
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
+        // Panel / glass slots painted through the registry. The door system tags
+        // each mesh with its `userData.slotId`; paint writes `node.slots`.
+        slots: () => doorSlots(),
+        paint: doorPaint,
+    },
+    parametrics: doorParametrics,
+    handles: doorHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        // Priority 3 mirrors the legacy DoorSystem (after animation at 2,
+        // before wall mitering at 4).
+        priority: 3,
+    },
+    // Stage C: floor-plan polygon. Needs ctx.parent (the wall) to compute
+    // direction + perpendicular for the cutout footprint.
+    floorplan: buildDoorFloorplan,
+    floorplanDependsOnSiblings: true,
+    // Opening symbols position from `ctx.parent` (the host wall); merge the
+    // walls' live drag overrides so the symbol tracks a wall / group drag in
+    // realtime instead of jumping on commit.
+    floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
+    // Stage D — placement (`def.tool`) + move-on-wall (`def.
+    // affordanceTools.move`). Both ports of the legacy tools at
+    // `editor/components/tools/door/`, relocated into the kind folder and
+    // wired through ToolManager's registry-first dispatch (`def.tool` for
+    // build-mode placement, `getRegistryAffordanceTool` for the move-on-
+    // pick flow). Same legacy semantics: wall-event-driven snap, clamped
+    // wall-local coords, hasWallChildOverlap guard, live mesh updates.
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    // 2D move-on-floorplan handler. When `useEditor.movingNode` is a
+    // door and the floor plan is active, `FloorplanRegistryMoveOverlay`
+    // dispatches to this instead of the generic translate path — pointer
+    // snaps to the nearest wall, projects onto the wall axis, snaps
+    // local-X to 0.5m, clamps inside wall bounds.
+    floorplanMoveTarget: doorFloorplanMoveTarget,
+    // 2D drag affordances. `resize-width` drives the door's two side
+    // arrows — pointer-down on either arrow starts an anchored width drag
+    // (opposite edge stays fixed, clamped to wall bounds).
+    floorplanAffordances: {
+        'resize-width': doorWidthAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place door on wall' },
+        { key: 'R', label: 'Flip side' },
+        { key: 'Alt', label: 'Force place' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Door',
+        description: 'A door cut into a wall. Animated open/close state.',
+        icon: { kind: 'url', src: '/icons/door.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 50,
+    },
+    mcp: {
+        description: 'A door mounted on a wall, with type / dimensions / hardware options.',
+    },
+};

package/dist/door/door-math.d.ts

@@ -0,0 +1,23 @@
+import type { WallNode } from '@pascal-app/core';
+/**
+ * Keep the door handle at the same relative height when the door is resized:
+ * scale it by the height ratio, then clamp to the panel's slider bounds
+ * [0.5, height - 0.1] so it never lands outside the (possibly shrunk) door.
+ * Used by both the height-resize arrow and the panel's Height slider so the
+ * handle tracks the door whichever way it's resized.
+ */
+export declare function scaleHandleHeight(handleHeight: number, oldHeight: number, newHeight: number): number;
+/**
+ * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ */
+export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number): [number, number, number];
+/**
+ * Clamps door center X so it stays fully within wall bounds.
+ * Y is always height/2 — doors sit at floor level.
+ */
+export declare function clampToWall(wallNode: WallNode, localX: number, width: number, height: number): {
+    clampedX: number;
+    clampedY: number;
+};
+export { hasWallChildOverlap } from '../shared/wall-attach-target';
+//# sourceMappingURL=door-math.d.ts.map

package/dist/door/door-math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-math.d.ts","sourceRoot":"","sources":["../../src/door/door-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAU1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAQxC;AAKD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/door/door-math.js

@@ -0,0 +1,38 @@
+/**
+ * Keep the door handle at the same relative height when the door is resized:
+ * scale it by the height ratio, then clamp to the panel's slider bounds
+ * [0.5, height - 0.1] so it never lands outside the (possibly shrunk) door.
+ * Used by both the height-resize arrow and the panel's Height slider so the
+ * handle tracks the door whichever way it's resized.
+ */
+export function scaleHandleHeight(handleHeight, oldHeight, newHeight) {
+    const ratio = oldHeight > 0 ? newHeight / oldHeight : 1;
+    return Math.min(Math.max(handleHeight * ratio, 0.5), Math.max(0.5, newHeight - 0.1));
+}
+/**
+ * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ */
+export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0) {
+    const wallAngle = Math.atan2(wallNode.end[1] - wallNode.start[1], wallNode.end[0] - wallNode.start[0]);
+    return [
+        wallNode.start[0] + localX * Math.cos(wallAngle),
+        slabElevation + localY + levelYOffset,
+        wallNode.start[1] + localX * Math.sin(wallAngle),
+    ];
+}
+/**
+ * Clamps door center X so it stays fully within wall bounds.
+ * Y is always height/2 — doors sit at floor level.
+ */
+export function clampToWall(wallNode, localX, width, height) {
+    const dx = wallNode.end[0] - wallNode.start[0];
+    const dz = wallNode.end[1] - wallNode.start[1];
+    const wallLength = Math.sqrt(dx * dx + dz * dz);
+    const clampedX = Math.max(width / 2, Math.min(wallLength - width / 2, localX));
+    const clampedY = height / 2; // Doors always sit at floor level
+    return { clampedX, clampedY };
+}
+// Wall-child overlap is shared by door + window placement (one source of
+// truth in `shared/wall-attach-target.ts`). Re-exported here so existing
+// `./door-math` importers don't change.
+export { hasWallChildOverlap } from '../shared/wall-attach-target';

package/dist/door/floorplan-affordances.d.ts

@@ -0,0 +1,21 @@
+import { type DoorNode, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * 2D drag affordance for the door's width side-arrows. Sister to the 3D
+ * `DoorSideArrow` width drag in `packages/editor/src/components/editor/
+ * door-side-handles.tsx` — both anchor at the opposite door edge and clamp
+ * to wall bounds.
+ *
+ * Payload encodes which edge the user grabbed:
+ *   - `'start'`: arrow at the door edge closer to `wall.start`. The
+ *     opposite edge (toward `wall.end`) stays fixed.
+ *   - `'end'`: arrow at the edge closer to `wall.end`. The wall-start
+ *     edge stays fixed.
+ *
+ * Uses the scene-write preview pattern (writes directly to `useScene`
+ * each tick): the registry layer's `effectiveNode` only merges live
+ * overrides for walls, so an override-based preview wouldn't show on
+ * doors. The dispatcher snapshots / pauses history at start, so per-tick
+ * scene writes still collapse to one undoable entry on commit.
+ */
+export declare const doorWidthAffordance: FloorplanAffordance<DoorNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/door/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CA6F7D,CAAA"}