@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/window/definition.edit.js

@@ -0,0 +1,255 @@
+import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
+import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation.js';
+import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime.js';
+import { createOpeningPropertyPreview } from '../shared/opening-property-preview.js';
+import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host.js';
+import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host.js';
+import { scriptedOpeningHandles } from '../shared/scripted-opening-handles.js';
+import { readHostWallCeiling, readHostWallCeilingMaxWidth } from '../shared/wall-opening-ceiling.js';
+import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides.js';
+import { buildWindowContextualDimensions } from './contextual-dimensions.js';
+import { resolveWindowHandlePortalTarget } from './definition.render.js';
+import { buildWindowFloorplan } from './floorplan.js';
+import { windowWidthAffordance } from './floorplan-affordances.js';
+import { windowFloorplanMoveTarget } from './floorplan-move.js';
+import { windowPaint } from './paint.js';
+import { windowParametrics } from './parametrics.js';
+import { WINDOW_CORNER_HINTS, WINDOW_PLACEMENT_HINTS, WINDOW_PLAIN_PLACE_VISIBLE, } from './placement.js';
+const SIDE_HANDLE_OFFSET = 0.24;
+const HEIGHT_HANDLE_OFFSET = 0.24;
+const MIN_WINDOW_HEIGHT = 0.3;
+const MIN_WINDOW_WIDTH = 0.3;
+function readWallLength(w, scene) {
+    const hostId = w.wallId || w.parentId;
+    if (!hostId)
+        return Number.POSITIVE_INFINITY;
+    const wall = scene.get(hostId);
+    if (wall?.type !== 'wall' || !wall.start || !wall.end)
+        return Number.POSITIVE_INFINITY;
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+function resolveDormerHost(window, scene) {
+    const dormerId = window.dormerId ?? window.parentId;
+    if (!dormerId)
+        return null;
+    const dormer = scene.get(dormerId);
+    return dormer?.type === 'dormer' ? dormer : null;
+}
+function readDormerFaceWidthMax(window, scene, localGrowSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallHorizontalBoundsAtHeight(dormer, window.dormerFace ?? 'front', window.position[1] + window.height / 2);
+    const faceGrowSign = Math.cos(window.rotation[1]) >= 0 ? localGrowSign : -localGrowSign;
+    const anchorX = window.position[0] - (faceGrowSign * window.width) / 2;
+    return faceGrowSign > 0 ? bounds.max - anchorX : anchorX - bounds.min;
+}
+function readDormerFaceHeightMax(window, scene, growSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallOpeningVerticalBounds(dormer, window.dormerFace ?? 'front', window.position[0], window.width);
+    const anchorY = window.position[1] - (growSign * window.height) / 2;
+    return growSign > 0 ? bounds.max - anchorY : anchorY - bounds.min;
+}
+function windowWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        // Stand the blade up into the wall face so it reads face-on from the
+        // front instead of edge-on (the window sits on a vertical wall).
+        faceNormal: true,
+        anchor: side === 'right' ? 'min' : 'max',
+        gridSnap: true,
+        min: MIN_WINDOW_WIDTH,
+        max: (n, scene) => {
+            const dormerMax = readDormerFaceWidthMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_WIDTH, dormerMax);
+            // Roof-hosted windows clamp against the face profile.
+            const roofMax = readRoofFaceWidthMax(n, scene, sign);
+            if (roofMax !== null)
+                return Math.max(MIN_WINDOW_WIDTH, roofMax);
+            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'x', sign);
+            if (curtainMax !== undefined)
+                return curtainMax;
+            // rotation[1] = π flips the window, so its visual right edge moves toward lower wall-local S.
+            const growSign = sign * Math.cos(n.rotation[1]) > 0 ? 1 : -1;
+            const fixedEdgeS = n.position[0] - (growSign * n.width) / 2;
+            return Math.max(MIN_WINDOW_WIDTH, readHostWallCeilingMaxWidth(n.wallId || n.parentId, scene, fixedEdgeS, growSign, n.position[1] + n.height / 2, readWallLength(n, scene), n));
+        },
+        currentValue: (n) => n.width,
+        onDrag: (node) => publishOpeningResizeGuides(node, true),
+        apply: (initial, newWidth) => {
+            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;
+            return {
+                width: newWidth,
+                position: [
+                    anchorX + sign * (newWidth / 2) * armX,
+                    initial.position[1],
+                    anchorZ + sign * (newWidth / 2) * armZ,
+                ],
+            };
+        },
+        placement: {
+            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), 0, 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
+    };
+}
+// Window height has two arrows (top + bottom edge) — each anchors at the
+// opposite edge so dragging the top grows the window upward and dragging
+// the bottom grows it downward without the opposite edge moving.
+function windowHeightHandle(edge) {
+    const sign = edge === 'top' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        // top arrow anchors at -Y (bottom stays fixed); bottom at +Y (top stays).
+        anchor: edge === 'top' ? 'min' : 'max',
+        gridSnap: true,
+        min: MIN_WINDOW_HEIGHT,
+        max: (n, scene) => {
+            const dormerMax = readDormerFaceHeightMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_HEIGHT, dormerMax);
+            const roofMax = readRoofFaceHeightMax(n, scene, sign);
+            if (roofMax !== null)
+                return Math.max(MIN_WINDOW_HEIGHT, roofMax);
+            // Maximum: distance from the anchored edge to the wall's allowed bounds. Top arrow caps at the wall's resolved ceiling - bottom;
+            // bottom arrow caps at top (positive Y room above the floor).
+            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', sign);
+            if (curtainMax !== undefined)
+                return curtainMax;
+            const wallH = readHostWallCeiling(n.wallId || n.parentId, scene, n);
+            const anchored = edge === 'top' ? n.position[1] - n.height / 2 : n.position[1] + n.height / 2;
+            return edge === 'top'
+                ? Math.max(MIN_WINDOW_HEIGHT, wallH - anchored)
+                : Math.max(MIN_WINDOW_HEIGHT, anchored);
+        },
+        currentValue: (n) => n.height,
+        onDrag: (node) => publishOpeningResizeGuides(node, true),
+        apply: (initial, newHeight) => {
+            // Anchored edge stays in wall-local Y; opposite edge moves.
+            const anchorY = edge === 'top'
+                ? initial.position[1] - initial.height / 2 // bottom anchored
+                : initial.position[1] + initial.height / 2; // top anchored
+            const newCenterY = anchorY + sign * (newHeight / 2);
+            return {
+                height: newHeight,
+                position: [initial.position[0], newCenterY, initial.position[2]],
+            };
+        },
+        placement: {
+            position: (n) => [0, sign * (n.height / 2 + HEIGHT_HANDLE_OFFSET), 0],
+        },
+        portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
+    };
+}
+function windowRadiusHandle(index) {
+    const corners = [
+        [-1, 1],
+        [1, 1],
+        [1, -1],
+        [-1, -1],
+    ];
+    return {
+        kind: 'corner-radius',
+        corner: corners[index],
+        width: (node) => node.width,
+        height: (node) => node.height,
+        currentValue: (node) => node.openingRadiusMode === 'individual'
+            ? (node.openingCornerRadii[index] ?? 0)
+            : node.cornerRadius,
+        max: (node) => Math.min(node.width, node.height) / 2,
+        apply: (node, radius, _scene, modifiers) => {
+            if (!modifiers.shiftKey) {
+                return { openingShape: 'rounded', openingRadiusMode: 'all', cornerRadius: radius };
+            }
+            const radii = node.openingRadiusMode === 'individual'
+                ? [...node.openingCornerRadii]
+                : [node.cornerRadius, node.cornerRadius, node.cornerRadius, node.cornerRadius];
+            radii[index] = radius;
+            return {
+                openingShape: 'rounded',
+                openingRadiusMode: 'individual',
+                openingCornerRadii: radii,
+            };
+        },
+        createPreview: (node) => createOpeningPropertyPreview(node.id, openingPropertyPreviewHost),
+        visible: (node) => node.openingShape !== 'arch',
+        portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
+    };
+}
+const windowHandles = [
+    windowWidthHandle('left'),
+    windowWidthHandle('right'),
+    windowHeightHandle('top'),
+    windowHeightHandle('bottom'),
+    windowRadiusHandle(0),
+    windowRadiusHandle(1),
+    windowRadiusHandle(2),
+    windowRadiusHandle(3),
+];
+export const windowEditContribution = {
+    snapProfile: 'item',
+    facingIndicator: true,
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildWindowContextualDimensions,
+            schedule: buildWindowFloorplanSchedule,
+            // Swap a casement's hinge side from the action bar, in 2D and 3D.
+            actionMenu: { actions: () => import('./actions.js') },
+        },
+    },
+    capabilities: {
+        paint: windowPaint,
+    },
+    parametrics: windowParametrics,
+    handles: (node) => node.source
+        ? scriptedOpeningHandles(node, windowWidthHandle, () => windowHeightHandle('top'))
+        : windowHandles,
+    preview: () => import('./preview.js'),
+    // Stage C: floor-plan polygon. ctx.parent gives the wall for direction
+    // + thickness — same shape as door.
+    floorplan: buildWindowFloorplan,
+    computeFloorplanLevelData: computeWindowFloorplanLevelData,
+    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 + move-on-wall. Same recipe as door. See
+    // `nodes/src/window/{tool,move-tool,window-math}.ts`.
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    // 2D move-on-floorplan handler — same shape as door.
+    floorplanMoveTarget: windowFloorplanMoveTarget,
+    // 2D drag affordances. `resize-width` drives the window's two side
+    // arrows — pointer-down on either arrow starts an anchored width drag
+    // (opposite edge stays fixed, clamped to wall bounds). Mirrors the
+    // door wiring.
+    floorplanAffordances: {
+        'resize-width': windowWidthAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place window on wall', visible: WINDOW_PLAIN_PLACE_VISIBLE },
+        ...WINDOW_CORNER_HINTS,
+        ...WINDOW_PLACEMENT_HINTS,
+        { key: 'R', label: 'Flip side' },
+        { key: 'Alt', label: 'Force place' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/window/definition.js

@@ -1,338 +1,5 @@
-import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, windowSlots, } from '@pascal-app/core';
-import { NEW_WINDOW_FRAME_THICKNESS } from '@pascal-app/core/building';
-import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
-import { windowBatchable } from '../shared/node-batch/batchable.js';
-import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation.js';
-import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime.js';
-import { createOpeningPropertyPreview } from '../shared/opening-property-preview.js';
-import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host.js';
-import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host.js';
-import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
-import { scriptedOpeningHandles } from '../shared/scripted-opening-handles.js';
-import { readHostWallCeiling } from '../shared/wall-opening-ceiling.js';
-import { openingSeenFromOutside } from '../wall/exterior.js';
-import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides.js';
-import { buildWindowContextualDimensions } from './contextual-dimensions.js';
-import { buildWindowFloorplan } from './floorplan.js';
-import { windowWidthAffordance } from './floorplan-affordances.js';
-import { windowFloorplanMoveTarget } from './floorplan-move.js';
-import { windowMechanism } from './mechanism.js';
-import { windowPaint } from './paint.js';
-import { windowParametrics } from './parametrics.js';
-import { WINDOW_CORNER_HINTS, WINDOW_PLACEMENT_HINTS, WINDOW_PLAIN_PLACE_VISIBLE, } from './placement.js';
-import { WindowNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.24;
-const HEIGHT_HANDLE_OFFSET = 0.24;
-const MIN_WINDOW_HEIGHT = 0.3;
-const MIN_WINDOW_WIDTH = 0.3;
-export function resolveWindowHandlePortalTarget(window, scene) {
-    const parentId = window.parentId;
-    if (!parentId)
-        return null;
-    const grandparentId = scene.get(parentId)
-        ?.parentId;
-    if (!grandparentId)
-        return null;
-    if (window.dormerId !== parentId)
-        return grandparentId;
-    return (scene.get(grandparentId)?.parentId ??
-        grandparentId);
-}
-function readWallLength(w, scene) {
-    if (!w.wallId)
-        return Number.POSITIVE_INFINITY;
-    const wall = scene.get(w.wallId);
-    if (!wall)
-        return Number.POSITIVE_INFINITY;
-    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
-}
-function resolveDormerHost(window, scene) {
-    const dormerId = window.dormerId ?? window.parentId;
-    if (!dormerId)
-        return null;
-    const dormer = scene.get(dormerId);
-    return dormer?.type === 'dormer' ? dormer : null;
-}
-function readDormerFaceWidthMax(window, scene, localGrowSign) {
-    const dormer = resolveDormerHost(window, scene);
-    if (!dormer)
-        return null;
-    const bounds = getDormerWallHorizontalBoundsAtHeight(dormer, window.dormerFace ?? 'front', window.position[1] + window.height / 2);
-    const faceGrowSign = Math.cos(window.rotation[1]) >= 0 ? localGrowSign : -localGrowSign;
-    const anchorX = window.position[0] - (faceGrowSign * window.width) / 2;
-    return faceGrowSign > 0 ? bounds.max - anchorX : anchorX - bounds.min;
-}
-function readDormerFaceHeightMax(window, scene, growSign) {
-    const dormer = resolveDormerHost(window, scene);
-    if (!dormer)
-        return null;
-    const bounds = getDormerWallOpeningVerticalBounds(dormer, window.dormerFace ?? 'front', window.position[0], window.width);
-    const anchorY = window.position[1] - (growSign * window.height) / 2;
-    return growSign > 0 ? bounds.max - anchorY : anchorY - bounds.min;
-}
-function windowWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        // Stand the blade up into the wall face so it reads face-on from the
-        // front instead of edge-on (the window sits on a vertical wall).
-        faceNormal: true,
-        anchor: side === 'right' ? 'min' : 'max',
-        gridSnap: true,
-        min: MIN_WINDOW_WIDTH,
-        max: (n, scene) => {
-            const dormerMax = readDormerFaceWidthMax(n, scene, sign);
-            if (dormerMax !== null)
-                return Math.max(MIN_WINDOW_WIDTH, dormerMax);
-            // Roof-hosted windows 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_WINDOW_WIDTH, roofMax);
-            return curtainOpeningResizeMax(n, scene.nodes(), 'x', sign) ?? readWallLength(n, scene);
-        },
-        currentValue: (n) => n.width,
-        onDrag: (node) => publishOpeningResizeGuides(node, true),
-        apply: (initial, newWidth) => {
-            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;
-            return {
-                width: newWidth,
-                position: [
-                    anchorX + sign * (newWidth / 2) * armX,
-                    initial.position[1],
-                    anchorZ + sign * (newWidth / 2) * armZ,
-                ],
-            };
-        },
-        placement: {
-            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), 0, 0],
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-        portal: 'grandparent',
-        portalTarget: resolveWindowHandlePortalTarget,
-    };
-}
-// Window height has two arrows (top + bottom edge) — each anchors at the
-// opposite edge so dragging the top grows the window upward and dragging
-// the bottom grows it downward without the opposite edge moving.
-function windowHeightHandle(edge) {
-    const sign = edge === 'top' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        // top arrow anchors at -Y (bottom stays fixed); bottom at +Y (top stays).
-        anchor: edge === 'top' ? 'min' : 'max',
-        gridSnap: true,
-        min: MIN_WINDOW_HEIGHT,
-        max: (n, scene) => {
-            const dormerMax = readDormerFaceHeightMax(n, scene, sign);
-            if (dormerMax !== null)
-                return Math.max(MIN_WINDOW_HEIGHT, dormerMax);
-            const roofMax = readRoofFaceHeightMax(n, scene, sign);
-            if (roofMax !== null)
-                return Math.max(MIN_WINDOW_HEIGHT, roofMax);
-            // Maximum: distance from the anchored edge to the wall's allowed Y
-            // bounds. Top arrow caps at the wall's resolved ceiling - bottom;
-            // bottom arrow caps at top (positive Y room above the floor).
-            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', sign);
-            if (curtainMax !== undefined)
-                return curtainMax;
-            const wallH = readHostWallCeiling(n.wallId, scene, n);
-            const anchored = edge === 'top' ? n.position[1] - n.height / 2 : n.position[1] + n.height / 2;
-            return edge === 'top'
-                ? Math.max(MIN_WINDOW_HEIGHT, wallH - anchored)
-                : Math.max(MIN_WINDOW_HEIGHT, anchored);
-        },
-        currentValue: (n) => n.height,
-        onDrag: (node) => publishOpeningResizeGuides(node, true),
-        apply: (initial, newHeight) => {
-            // Anchored edge stays in wall-local Y; opposite edge moves.
-            const anchorY = edge === 'top'
-                ? initial.position[1] - initial.height / 2 // bottom anchored
-                : initial.position[1] + initial.height / 2; // top anchored
-            const newCenterY = anchorY + sign * (newHeight / 2);
-            return {
-                height: newHeight,
-                position: [initial.position[0], newCenterY, initial.position[2]],
-            };
-        },
-        placement: {
-            position: (n) => [0, sign * (n.height / 2 + HEIGHT_HANDLE_OFFSET), 0],
-        },
-        portal: 'grandparent',
-        portalTarget: resolveWindowHandlePortalTarget,
-    };
-}
-function windowRadiusHandle(index) {
-    const corners = [
-        [-1, 1],
-        [1, 1],
-        [1, -1],
-        [-1, -1],
-    ];
-    return {
-        kind: 'corner-radius',
-        corner: corners[index],
-        width: (node) => node.width,
-        height: (node) => node.height,
-        currentValue: (node) => node.openingRadiusMode === 'individual'
-            ? (node.openingCornerRadii[index] ?? 0)
-            : node.cornerRadius,
-        max: (node) => Math.min(node.width, node.height) / 2,
-        apply: (node, radius, _scene, modifiers) => {
-            if (!modifiers.shiftKey) {
-                return { openingShape: 'rounded', openingRadiusMode: 'all', cornerRadius: radius };
-            }
-            const radii = node.openingRadiusMode === 'individual'
-                ? [...node.openingCornerRadii]
-                : [node.cornerRadius, node.cornerRadius, node.cornerRadius, node.cornerRadius];
-            radii[index] = radius;
-            return {
-                openingShape: 'rounded',
-                openingRadiusMode: 'individual',
-                openingCornerRadii: radii,
-            };
-        },
-        createPreview: (node) => createOpeningPropertyPreview(node.id, openingPropertyPreviewHost),
-        visible: (node) => node.openingShape !== 'arch',
-        portal: 'grandparent',
-        portalTarget: resolveWindowHandlePortalTarget,
-    };
-}
-const windowHandles = [
-    windowWidthHandle('left'),
-    windowWidthHandle('right'),
-    windowHeightHandle('top'),
-    windowHeightHandle('bottom'),
-    windowRadiusHandle(0),
-    windowRadiusHandle(1),
-    windowRadiusHandle(2),
-    windowRadiusHandle(3),
-];
-/**
- * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
- * cuts holes in them, animated open/close state for opening windows.
- *
- * Stages:
- *  - A: registered.
- *  - B: deferred — window geometry ~800 lines; extraction is a focused
- *    session. `def.renderer` + `def.system` wrap-export legacy.
- *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
- *    `openingPolygons` short-circuits window entries when registered.
- */
-export const windowDefinition = {
-    kind: 'window',
-    snapProfile: 'item',
-    facingIndicator: true,
-    schemaVersion: 4,
-    schema: WindowNode,
-    category: 'structure',
-    extensions: {
-        'pascal:editor/floorplan': {
-            contextualDimensions: buildWindowContextualDimensions,
-            schedule: buildWindowFloorplanSchedule,
-            // Swap a casement's hinge side from the action bar, in 2D and 3D.
-            actionMenu: { actions: () => import('./actions.js') },
-        },
-    },
-    // Same schema-driven defaults trick as door: parse a stub, strip
-    // id/type. Window also has many fields with zod `.default()` set.
-    defaults: () => {
-        const stub = WindowNode.parse({
-            id: 'window_default',
-            type: 'window',
-            frameThickness: NEW_WINDOW_FRAME_THICKNESS,
-            casingFaceA: true,
-            casingFaceB: true,
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        reveal: { phase: 'openings', style: 'cut' },
-        exterior: openingSeenFromOutside,
-        revealOnEdit: ['position', 'width', 'height', 'openingShape', 'windowType'],
-        batchable: windowBatchable,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        wallOpeningPlacement: true,
-        // Windows also host on roof-segment wall faces (base walls under the
-        // roof, gable ends) — same wiring as door; see the door capability
-        // for why `dirtyHandledByOwnSystem` is required.
-        roofAccessory: {
-            buildCut: (node, hostSegment) => buildRoofWallOpeningCut(node, hostSegment),
-            cutScope: 'wall',
-            dirtyHandledByOwnSystem: true,
-        },
-        // `wallId` / `roofSegmentId` / `dormerId` are re-derived from the surface under
-        // the cursor at preset placement time — see door for the pattern.
-        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace', 'dormerId', 'dormerFace'],
-        // Frame / glass slots painted through the registry. The window system tags
-        // each mesh with its `userData.slotId`; paint writes `node.slots`.
-        slots: () => windowSlots(),
-        paint: windowPaint,
-        mechanism: windowMechanism,
-    },
-    parametrics: windowParametrics,
-    handles: (node) => node.source
-        ? scriptedOpeningHandles(node, windowWidthHandle, () => windowHeightHandle('top'))
-        : windowHandles,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    system: {
-        module: () => import('./system.js'),
-        priority: 3,
-    },
-    // Stage C: floor-plan polygon. ctx.parent gives the wall for direction
-    // + thickness — same shape as door.
-    floorplan: buildWindowFloorplan,
-    computeFloorplanLevelData: computeWindowFloorplanLevelData,
-    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 + move-on-wall. Same recipe as door. See
-    // `nodes/src/window/{tool,move-tool,window-math}.ts`.
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    // 2D move-on-floorplan handler — same shape as door.
-    floorplanMoveTarget: windowFloorplanMoveTarget,
-    // 2D drag affordances. `resize-width` drives the window's two side
-    // arrows — pointer-down on either arrow starts an anchored width drag
-    // (opposite edge stays fixed, clamped to wall bounds). Mirrors the
-    // door wiring.
-    floorplanAffordances: {
-        'resize-width': windowWidthAffordance,
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place window on wall', visible: WINDOW_PLAIN_PLACE_VISIBLE },
-        ...WINDOW_CORNER_HINTS,
-        ...WINDOW_PLACEMENT_HINTS,
-        { key: 'R', label: 'Flip side' },
-        { key: 'Alt', label: 'Force place' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Window',
-        description: 'A window cut into a wall. Animated open/close for opening windows.',
-        icon: { kind: 'url', src: '/icons/window.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 60,
-    },
-    mcp: {
-        description: 'A window mounted on a wall, with type / dimensions / opening options.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { windowEditContribution } from './definition.edit.js';
+import { windowRenderDefinition } from './definition.render.js';
+export const windowDefinition = composeNodeDefinition(windowRenderDefinition, windowEditContribution);
+export { resolveWindowHandlePortalTarget } from './definition.render.js';

package/dist/window/definition.render.d.ts

@@ -0,0 +1,8 @@
+import type { AnyNodeId, SceneApi, WindowNode as WindowNodeType } from '@pascal-app/core';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { WindowNode } from './schema.js';
+export declare function resolveWindowHandlePortalTarget(window: WindowNodeType, scene: Pick<SceneApi, 'get'>): AnyNodeId | null;
+export declare const windowRenderDefinition: NodeRenderDefinition<typeof WindowNode> & {
+    kind: 'window';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/window/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/window/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAET,QAAQ,EACR,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAKzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AAED,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAAC,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAgE5F,CAAA"}