@pascal-app/nodes 0.1.1

package/dist/window/definition.js

@@ -0,0 +1,237 @@
+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 { buildWindowFloorplan } from './floorplan';
+import { windowWidthAffordance } from './floorplan-affordances';
+import { windowFloorplanMoveTarget } from './floorplan-move';
+import { windowPaint } from './paint';
+import { windowParametrics } from './parametrics';
+import { WindowNode } from './schema';
+import { windowSlots } from './slots';
+const SIDE_HANDLE_OFFSET = 0.24;
+const HEIGHT_HANDLE_OFFSET = 0.24;
+const MIN_WINDOW_HEIGHT = 0.3;
+const MIN_WINDOW_WIDTH = 0.3;
+// How far the move cross floats off the wall face (+Z, the window's facing
+// normal) so it's grabbable instead of buried in the sash/frame.
+const MOVE_HANDLE_LIFT = 0.12;
+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 readWallHeight(w, scene) {
+    if (!w.wallId)
+        return Number.POSITIVE_INFINITY;
+    const wall = scene.get(w.wallId);
+    return wall?.height ?? Number.POSITIVE_INFINITY;
+}
+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',
+        min: MIN_WINDOW_WIDTH,
+        max: (n, scene) => {
+            // 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 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',
+    };
+}
+// 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',
+        min: MIN_WINDOW_HEIGHT,
+        max: (n, scene) => {
+            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 wall.height - bottom; bottom arrow caps
+            // at top (positive Y room above the floor).
+            const wallH = readWallHeight(n, scene);
+            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',
+    };
+}
+// Press-drag move grip at the window centre, standing in the wall face. Routes
+// through the same move tool as the floating Move button (3D
+// `affordanceTools.move`, 2D `floorplanMoveTarget`) — slide within the wall
+// plane + re-host onto another wall — committing on release, no second click.
+function windowMoveHandle() {
+    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 windowHandles = [
+    windowMoveHandle(),
+    windowWidthHandle('left'),
+    windowWidthHandle('right'),
+    windowHeightHandle('top'),
+    windowHeightHandle('bottom'),
+];
+/**
+ * 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: 1,
+    schema: WindowNode,
+    category: 'structure',
+    // 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' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        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` are re-derived from the surface under
+        // the cursor at preset placement time — see door for the pattern.
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
+        // 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,
+    },
+    parametrics: windowParametrics,
+    handles: windowHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 3,
+    },
+    // Stage C: floor-plan polygon. ctx.parent gives the wall for direction
+    // + thickness — same shape as door.
+    floorplan: buildWindowFloorplan,
+    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'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    // 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' },
+        { 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.',
+    },
+};

package/dist/window/floor-projection.d.ts

@@ -0,0 +1,9 @@
+export declare function WindowFloorProjection({ centerX, centerZ, centerY, floorY, width, rotationY, }: {
+    centerX: number;
+    centerZ: number;
+    centerY: number;
+    floorY: number;
+    width: number;
+    rotationY: number;
+}): import("react").JSX.Element;
+//# sourceMappingURL=floor-projection.d.ts.map

package/dist/window/floor-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-projection.d.ts","sourceRoot":"","sources":["../../src/window/floor-projection.tsx"],"names":[],"mappings":"AA2CA,wBAAgB,qBAAqB,CAAC,EACpC,OAAO,EACP,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,SAAS,GACV,EAAE;IACD,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB,+BAqDA"}

package/dist/window/floor-projection.js

@@ -0,0 +1,84 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useEffect, useMemo } from 'react';
+import { BufferGeometry, Float32BufferAttribute, LineSegments } from 'three';
+import { LineBasicNodeMaterial } from 'three/webgpu';
+/**
+ * Floor "shadow" projection for a window during placement / move.
+ *
+ * Windows sit elevated above the floor, so over open ground (and on a wall)
+ * it's hard to read where the window actually is in plan. This draws its
+ * projection on the floor: a small footprint segment directly below the window
+ * (its plan extent along the wall) plus a DASHED vertical line dropping from the
+ * window centre to that footprint — like a shadow tether. Placement aid only;
+ * never shown on a committed window.
+ *
+ * Rendered in WORLD space (the tool positions the ghost in world space too), so
+ * it's mounted as a sibling of the ghost — NOT inside the ghost's rotated/offset
+ * group. `centerY` is the window centre's world Y; `floorY` is the level floor.
+ */
+const FOOTPRINT_COLOR = 0x38_bd_f8;
+const DROP_COLOR = 0x38_bd_f8;
+const footprintMaterial = new LineBasicNodeMaterial({
+    color: FOOTPRINT_COLOR,
+    transparent: true,
+    opacity: 0.85,
+    depthWrite: false,
+});
+const dropMaterial = new LineBasicNodeMaterial({
+    color: DROP_COLOR,
+    transparent: true,
+    opacity: 0.6,
+    depthWrite: false,
+});
+// Dash geometry for the vertical drop: alternating on/off segments so it reads
+// as a dashed tether without a dashed-line material (unavailable in three/webgpu).
+const DASH = 0.12;
+const GAP = 0.08;
+export function WindowFloorProjection({ centerX, centerZ, centerY, floorY, width, rotationY, }) {
+    // Footprint: a short segment of length `width` along the window's wall axis,
+    // centred under the window on the floor. The window faces `rotationY` about Y
+    // (its width runs along the wall), so the along-wall direction is
+    // (cos, -sin) in XZ.
+    const footprint = useMemo(() => {
+        const half = width / 2;
+        const dirX = Math.cos(rotationY);
+        const dirZ = -Math.sin(rotationY);
+        const position = new Float32BufferAttribute(new Float32Array(6), 3);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', position);
+        const line = new LineSegments(geometry, footprintMaterial);
+        line.frustumCulled = false;
+        line.layers.set(EDITOR_LAYER);
+        line.renderOrder = 1000;
+        line.raycast = () => { };
+        position.setXYZ(0, centerX - dirX * half, floorY + 0.002, centerZ - dirZ * half);
+        position.setXYZ(1, centerX + dirX * half, floorY + 0.002, centerZ + dirZ * half);
+        position.needsUpdate = true;
+        return line;
+    }, [centerX, centerZ, floorY, width, rotationY]);
+    // Dashed vertical tether from the window centre down to the footprint.
+    const drop = useMemo(() => {
+        const span = Math.max(centerY - floorY, 0);
+        const segs = [];
+        let y = floorY;
+        while (y < floorY + span) {
+            const top = Math.min(y + DASH, floorY + span);
+            segs.push(centerX, y, centerZ, centerX, top, centerZ);
+            y += DASH + GAP;
+        }
+        const position = new Float32BufferAttribute(new Float32Array(segs), 3);
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', position);
+        const line = new LineSegments(geometry, dropMaterial);
+        line.frustumCulled = false;
+        line.layers.set(EDITOR_LAYER);
+        line.renderOrder = 1000;
+        line.raycast = () => { };
+        return line;
+    }, [centerX, centerZ, centerY, floorY]);
+    useEffect(() => () => footprint.geometry.dispose(), [footprint]);
+    useEffect(() => () => drop.geometry.dispose(), [drop]);
+    return (_jsxs(_Fragment, { children: [_jsx("primitive", { object: footprint }), _jsx("primitive", { object: drop })] }));
+}

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

@@ -0,0 +1,22 @@
+import { type FloorplanAffordance, type WindowNode } from '@pascal-app/core';
+/**
+ * 2D drag affordance for the window's width side-arrows. Sister to the 3D
+ * `WindowSideArrow` width drag in `packages/editor/src/components/editor/
+ * window-side-handles.tsx` — both anchor at the opposite window edge and
+ * clamp to wall bounds. Mirrors `doorWidthAffordance` 1:1 with the door
+ * type swapped for the window type.
+ *
+ * Payload encodes which edge the user grabbed:
+ *   - `'start'`: arrow at the window 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
+ * windows. The dispatcher snapshots / pauses history at start, so
+ * per-tick scene writes still collapse to one undoable entry on commit.
+ */
+export declare const windowWidthAffordance: FloorplanAffordance<WindowNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAIxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,UAAU,CAwEjE,CAAA"}

package/dist/window/floorplan-affordances.js

@@ -0,0 +1,82 @@
+import { useScene, } from '@pascal-app/core';
+const MIN_WINDOW_WIDTH = 0.3;
+/**
+ * 2D drag affordance for the window's width side-arrows. Sister to the 3D
+ * `WindowSideArrow` width drag in `packages/editor/src/components/editor/
+ * window-side-handles.tsx` — both anchor at the opposite window edge and
+ * clamp to wall bounds. Mirrors `doorWidthAffordance` 1:1 with the door
+ * type swapped for the window type.
+ *
+ * Payload encodes which edge the user grabbed:
+ *   - `'start'`: arrow at the window 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
+ * windows. The dispatcher snapshots / pauses history at start, so
+ * per-tick scene writes still collapse to one undoable entry on commit.
+ */
+export const windowWidthAffordance = {
+    start({ node, payload, nodes, initialPlanPoint }) {
+        const { side } = payload;
+        const windowId = node.id;
+        const wall = node.wallId ? nodes[node.wallId] : undefined;
+        const initialWidth = node.width;
+        const initialWindowX = node.position[0];
+        const initialWindowY = node.position[1];
+        const initialWindowZ = node.position[2];
+        const growDir = side === 'end' ? 1 : -1;
+        const anchorX = side === 'end' ? initialWindowX - initialWidth / 2 : initialWindowX + initialWidth / 2;
+        const wallStart = wall ? wall.start : [0, 0];
+        const wallEnd = wall ? wall.end : [1, 0];
+        const dx = wallEnd[0] - wallStart[0];
+        const dz = wallEnd[1] - wallStart[1];
+        const wallLength = Math.hypot(dx, dz) || 1;
+        const dirX = dx / wallLength;
+        const dirZ = dz / wallLength;
+        const maxWidth = growDir > 0 ? wallLength - anchorX : anchorX;
+        const projectToWallLocalX = (planPoint) => {
+            return (planPoint[0] - wallStart[0]) * dirX + (planPoint[1] - wallStart[1]) * dirZ;
+        };
+        const initialPointerLocalX = projectToWallLocalX(initialPlanPoint);
+        let lastWidth = initialWidth;
+        let lastWindowX = initialWindowX;
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint }) {
+                const currentLocalX = projectToWallLocalX(planPoint);
+                const delta = (currentLocalX - initialPointerLocalX) * growDir;
+                const newWidth = Math.min(Math.max(MIN_WINDOW_WIDTH, initialWidth + delta), Math.max(MIN_WINDOW_WIDTH, maxWidth));
+                const newWindowX = anchorX + growDir * (newWidth / 2);
+                lastWidth = newWidth;
+                lastWindowX = newWindowX;
+                useScene.getState().updateNodes([
+                    {
+                        id: windowId,
+                        data: {
+                            width: newWidth,
+                            position: [newWindowX, initialWindowY, initialWindowZ],
+                        },
+                    },
+                ]);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNodes([
+                    {
+                        id: windowId,
+                        data: {
+                            width: lastWidth,
+                            position: [lastWindowX, initialWindowY, initialWindowZ],
+                        },
+                    },
+                ]);
+            },
+        };
+    },
+};

package/dist/window/floorplan-move.d.ts

@@ -0,0 +1,14 @@
+import { type FloorplanMoveTarget, type WindowNode } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for window. Same shape as door (see
+ * `nodes/src/door/floorplan-move.ts`) — pointer in plan space → snap
+ * to nearest wall → project onto wall axis → snap local-X to 0.5m →
+ * clamp inside wall bounds → commit.
+ *
+ * Window-specific: local Y (vertical position on the wall) is preserved
+ * from the source node — we don't try to reposition the sill from a 2D
+ * pointer (there's no Y signal in plan view). The 3D move tool handles
+ * vertical motion; the 2D move is a horizontal-only re-anchor.
+ */
+export declare const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAgPrE,CAAA"}