@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/wall/split-session.js

@@ -0,0 +1,138 @@
+import { getWallCurveLength, planWallDivisions, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { snapWallSplitDistance, WALL_SPLIT_MAX_CUTS, wallSplitAnchors, wallSplitDistances, wallSplitPreview, } from './split-preview';
+import { useWallSplit } from './split-store';
+// Pointer distance (m) within which a 'lines' alignment target catches the cut.
+const ALIGNMENT_TOLERANCE = 0.2;
+const ownsSplit = () => {
+    const { scope } = useInteractionScope.getState();
+    return scope.kind === 'reshaping' && scope.reshape === 'split';
+};
+const currentWall = (draft) => {
+    const wall = useScene.getState().nodes[draft.wallId];
+    return wall?.type === 'wall' ? wall : null;
+};
+const withPreview = (draft, wall) => ({
+    ...draft,
+    preview: wallSplitPreview(useScene.getState().nodes, wall, wallSplitDistances(getWallCurveLength(wall), draft.cuts, draft.distance)),
+});
+let teardown = null;
+/**
+ * A split session: the wall's `reshaping` scope (so the snapping chip and the
+ * kind's HUD hints resolve), one centred cut, and the watchers that end it —
+ * Esc, the wall or its edit rights going away, another interaction, leaving
+ * select mode. Both views render the same draft; either can commit.
+ */
+export function openWallSplit(wall) {
+    if (useScene.getState().readOnly)
+        return;
+    closeWallSplit();
+    useEditor.getState().setMode('select');
+    useInteractionScope
+        .getState()
+        .begin({ kind: 'reshaping', nodeId: wall.id, reshape: 'split', driver: 'tool' });
+    useWallSplit
+        .getState()
+        .setDraft(withPreview({ wallId: wall.id, cuts: 1, distance: getWallCurveLength(wall) / 2, snap: null }, wall));
+    const onKey = (event) => {
+        if (event.key !== 'Escape')
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        closeWallSplit();
+    };
+    const stopScene = useScene.subscribe((state, previous) => {
+        if (state.readOnly || state.nodes[wall.id]?.type !== 'wall')
+            closeWallSplit();
+        else if (state.nodes !== previous.nodes)
+            refreshWallSplit();
+    });
+    const stopScope = useInteractionScope.subscribe(({ scope }) => {
+        if (!(scope.kind === 'reshaping' && scope.reshape === 'split'))
+            closeWallSplit();
+    });
+    const stopEditor = useEditor.subscribe((state) => {
+        if (state.mode !== 'select' ||
+            state.isCaptureMode ||
+            state.isPreviewMode ||
+            state.isFirstPersonMode)
+            closeWallSplit();
+    });
+    const hasWindow = typeof window !== 'undefined';
+    if (hasWindow)
+        window.addEventListener('keydown', onKey, true);
+    teardown = () => {
+        if (hasWindow)
+            window.removeEventListener('keydown', onKey, true);
+        stopScene();
+        stopScope();
+        stopEditor();
+    };
+}
+export function closeWallSplit() {
+    const stop = teardown;
+    teardown = null;
+    stop?.();
+    useWallSplit.getState().setDraft(null);
+    useInteractionScope
+        .getState()
+        .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'split');
+}
+/** Pointer projected onto the wall; Alt (`free`) skips snapping. */
+export function hoverWallSplit(raw, free = false) {
+    const draft = useWallSplit.getState().draft;
+    // Several cuts stay evenly spaced, so the pointer has nothing to move.
+    if (!draft || draft.cuts > 1 || !ownsSplit())
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    const { distance, snap } = free
+        ? { distance: raw, snap: null }
+        : snapWallSplitDistance(wall, raw, {
+            gridStep: isGridSnapActive() ? useEditor.getState().gridSnapStep : null,
+            anchors: isMagneticSnapActive() ? wallSplitAnchors(useScene.getState().nodes, wall) : null,
+            tolerance: ALIGNMENT_TOLERANCE,
+        });
+    if (distance === draft.distance && snap?.kind === draft.snap?.kind)
+        return;
+    useWallSplit.getState().setDraft(withPreview({ ...draft, distance, snap }, wall));
+}
+export function setWallSplitCuts(cuts) {
+    const draft = useWallSplit.getState().draft;
+    if (!draft || !ownsSplit())
+        return;
+    const next = Math.min(WALL_SPLIT_MAX_CUTS, Math.max(1, Math.round(cuts)));
+    if (next === draft.cuts)
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    useWallSplit.getState().setDraft(withPreview({ ...draft, cuts: next }, wall));
+}
+/** Re-plan against the current scene (after an external edit). */
+export function refreshWallSplit() {
+    const draft = useWallSplit.getState().draft;
+    if (!draft)
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    useWallSplit.getState().setDraft(withPreview(draft, wall));
+}
+export function commitWallSplit() {
+    const draft = useWallSplit.getState().draft;
+    const current = useScene.getState();
+    if (!draft || current.readOnly || !ownsSplit())
+        return;
+    const wall = currentWall(draft);
+    if (!wall)
+        return closeWallSplit();
+    const checked = withPreview(draft, wall);
+    if (!checked.preview.valid)
+        return useWallSplit.getState().setDraft(checked);
+    const plan = planWallDivisions(current.nodes, wall.id, checked.preview.distances);
+    runAsSingleSceneHistoryStep(useScene, () => current.applyNodeChanges(plan.changes));
+    closeWallSplit();
+    triggerSFX('sfx:structure-build');
+}

package/dist/wall/split-store.d.ts

@@ -0,0 +1,16 @@
+import type { WallNode } from '@pascal-app/core';
+import type { WallSplitPreview, WallSplitSnap } from './split-preview';
+export type WallSplitDraft = {
+    wallId: WallNode['id'];
+    cuts: number;
+    /** The single cut's snapped distance from the wall start; more cuts are evenly spaced. */
+    distance: number;
+    snap: WallSplitSnap;
+    preview: WallSplitPreview;
+};
+/** The open split's cut preview. Every transition lives in `split-session.ts`. */
+export declare const useWallSplit: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    draft: WallSplitDraft | null;
+    setDraft: (draft: WallSplitDraft | null) => void;
+}>>;
+//# sourceMappingURL=split-store.d.ts.map

package/dist/wall/split-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-store.d.ts","sourceRoot":"","sources":["../../src/wall/split-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEtE,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,0FAA0F;IAC1F,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED,kFAAkF;AAClF,eAAO,MAAM,YAAY;WAChB,cAAc,GAAG,IAAI;cAClB,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI;GAI/C,CAAA"}

package/dist/wall/split-store.js

@@ -0,0 +1,6 @@
+import { create } from 'zustand';
+/** The open split's cut preview. Every transition lives in `split-session.ts`. */
+export const useWallSplit = create((set) => ({
+    draft: null,
+    setDraft: (draft) => set({ draft }),
+}));

package/dist/wall/split-tool.d.ts

@@ -0,0 +1,10 @@
+import { type AnyNode } from '@pascal-app/core';
+/**
+ * The wall's `split` affordance (3D): cut markers, segment lengths and the
+ * pointer binding. The session (`split-session.ts`) owns the scope and draft;
+ * the plan layer renders the same draft.
+ */
+export default function WallSplitTool(_props: {
+    node: AnyNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=split-tool.d.ts.map

package/dist/wall/split-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-tool.d.ts","sourceRoot":"","sources":["../../src/wall/split-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAA6C,MAAM,kBAAkB,CAAA;AAgB1F;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,sCA8J9D"}

package/dist/wall/split-tool.js

@@ -0,0 +1,95 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getWallThickness, sceneRegistry, useScene } from '@pascal-app/core';
+import { DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, NO_RAYCAST, } from '@pascal-app/editor';
+import { BATCHED_LAYER, getSceneTheme, SCENE_LAYER, useViewer } from '@pascal-app/viewer';
+import { useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Raycaster, Vector2 } from 'three';
+import { bindWallSplitPointer } from './split-pointer';
+import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview';
+import { useWallSplit } from './split-store';
+/**
+ * The wall's `split` affordance (3D): cut markers, segment lengths and the
+ * pointer binding. The session (`split-session.ts`) owns the scope and draft;
+ * the plan layer renders the same draft.
+ */
+export default function WallSplitTool(_props) {
+    const draft = useWallSplit((s) => s.draft);
+    const wallId = draft?.wallId;
+    const wall = useScene((s) => (draft ? s.nodes[draft.wallId] : undefined));
+    const unit = useViewer((s) => s.unit);
+    const metricNotation = useViewer((s) => s.metricNotation);
+    const isDark = useViewer((s) => getSceneTheme(s.sceneTheme).appearance === 'dark');
+    const { gl, camera } = useThree();
+    const root = useRef(null);
+    const column = useRef(null);
+    const top = useRef(null);
+    const base = useRef(null);
+    useEffect(() => {
+        if (!wallId)
+            return;
+        const surface = gl.domElement;
+        const raycaster = new Raycaster();
+        raycaster.layers.set(SCENE_LAYER);
+        raycaster.layers.enable(BATCHED_LAYER);
+        const pointer = new Vector2();
+        return bindWallSplitPointer(surface, (event) => {
+            if (event.target !== surface)
+                return null;
+            const current = useScene.getState().nodes[wallId];
+            const object = sceneRegistry.nodes.get(wallId);
+            if (current?.type !== 'wall' || !object?.parent)
+                return null;
+            const rect = surface.getBoundingClientRect();
+            if (!rect.width || !rect.height)
+                return null;
+            pointer.set(((event.clientX - rect.left) / rect.width) * 2 - 1, 1 - ((event.clientY - rect.top) / rect.height) * 2);
+            raycaster.setFromCamera(pointer, camera);
+            object.updateWorldMatrix(true, true);
+            const hit = raycaster.intersectObject(object, true)[0];
+            if (!hit)
+                return null;
+            const local = object.parent.worldToLocal(hit.point.clone());
+            return wallSplitDistance(current, [local.x, local.z]);
+        });
+    }, [wallId, gl, camera]);
+    useFrame(() => {
+        if (!(root.current && column.current && top.current && base.current))
+            return;
+        if (wall?.type !== 'wall' || !draft)
+            return;
+        const object = sceneRegistry.nodes.get(wall.id);
+        if (!object?.parent || !object.geometry) {
+            root.current.visible = false;
+            return;
+        }
+        root.current.visible = true;
+        object.updateWorldMatrix(true, false);
+        root.current.matrix.copy(object.parent.matrixWorld);
+        if (!object.geometry.boundingBox)
+            object.geometry.computeBoundingBox();
+        const bounds = object.geometry.boundingBox;
+        const bottom = object.position.y + (bounds?.min.y ?? 0);
+        const height = bounds ? bounds.max.y - bounds.min.y : (wall.height ?? 3);
+        column.current.position.y = bottom + height / 2;
+        column.current.scale.y = Math.max(0.05, height + 0.05);
+        top.current.position.y = bottom + height + DRAFT_LABEL_Y_OFFSET;
+        base.current.position.y = bottom + 0.01;
+    });
+    if (!draft || wall?.type !== 'wall')
+        return null;
+    const { preview, snap } = draft;
+    const thickness = getWallThickness(wall);
+    const color = wallSplitMarkerColor(preview.valid);
+    const cut = preview.frames[0]?.point;
+    const guide = snap?.kind === 'alignment' && cut
+        ? {
+            x: (snap.anchor[0] + cut.x) / 2,
+            z: (snap.anchor[1] + cut.y) / 2,
+            length: Math.hypot(cut.x - snap.anchor[0], cut.y - snap.anchor[1]),
+            angle: -Math.atan2(cut.y - snap.anchor[1], cut.x - snap.anchor[0]),
+        }
+        : null;
+    return (_jsxs("group", { ref: root, matrixAutoUpdate: false, children: [_jsx("group", { ref: column, children: preview.frames.map(({ point, tangent }, index) => (_jsxs("group", { position: [point.x, 0, point.y], rotation: [0, -Math.atan2(tangent.y, tangent.x), 0], userData: { testId: 'pascal-split-marker', valid: preview.valid }, children: [_jsxs("mesh", { layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 8900, scale: [0.074, 1, thickness + 0.12], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: preview.valid ? '#f7f3ed' : '#faece9', depthTest: false, depthWrite: false, toneMapped: false })] }), _jsxs("mesh", { layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 8910, scale: [0.026, 1.001, thickness + 0.07], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: color, depthTest: false, depthWrite: false, toneMapped: false })] })] }, index))) }), _jsx("group", { ref: top, children: !preview.valid && cut ? (_jsx(DraftMeasurementLabel, { color: color, label: preview.message, position: [cut.x, 0, cut.y], shadowColor: isDark ? '#111111' : '#ffffff' })) : (wallSplitSegmentLabels(wall, preview).map((segment, index) => (_jsx(DraftMeasurementLabel, { color: isDark ? '#ffffff' : '#111111', label: `${formatLinearMeasurement(segment.length, unit, metricNotation)}${segment.count > 1 ? ` × ${segment.count}` : ''}`, position: [segment.midpoint[0], 0, segment.midpoint[1]], shadowColor: isDark ? '#111111' : '#ffffff' }, index)))) }), _jsx("group", { ref: base, children: guide && (_jsxs("mesh", { layers: EDITOR_LAYER, position: [guide.x, 0, guide.z], raycast: NO_RAYCAST, renderOrder: 8890, rotation: [0, guide.angle, 0], scale: [guide.length, 0.01, 0.02], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.8, toneMapped: false, transparent: true })] })) })] }));
+}

package/dist/wall/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAkCA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAyChD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAoCA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAyChD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/wall/system.js

@@ -4,6 +4,8 @@ import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
 import { timeSpan, WallCutout, WallSystem } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
 import { useEffect } from 'react';
+import { curtainWallGeometryAdapter } from './curtain-wall-adapter';
+import { getCurtainAwareWallMaterials } from './curtain-wall-materials';
 import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data';
 import { wallTreatmentProudOffsets } from './treatments';
 import { WallBatchSystem } from './wall-batch-system';
@@ -93,6 +95,6 @@ const WallTreatmentMiterSystem = () => {
  *    draw calls instead of one per wall face run.
  */
 const WallSystems = () => {
-    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, {}), _jsx(WallCutout, {}), _jsx(WallBatchSystem, {})] }));
+    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, { geometryAdapter: curtainWallGeometryAdapter }), _jsx(WallCutout, { materialResolver: getCurtainAwareWallMaterials }), _jsx(WallBatchSystem, {})] }));
 };
 export default WallSystems;

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA6bA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAuf5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAs7BA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAS5B,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/wall/tool.js

@@ -1,11 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
-import { CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, createWallOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, } from '@pascal-app/editor';
+import { CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, createWallOnCurrentLevel, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
 import { DoubleSide, Vector3 } from 'three';
-import { DraftAngleArc, DraftAxisGuides, DraftMeasurementLabel, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
+import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
+import { useWallDrawingMode, useWallDrawingModeKeys } from './drawing-mode';
+import RectangleWallTool from './rectangle-tool';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
  *
@@ -289,7 +291,7 @@ function getBelowLevelWalls() {
         .sort((a, b) => b.level - a.level)[0];
     return getLevelWalls(belowLevel?.id ?? null, nodes);
 }
-export const WallTool = () => {
+const LineWallTool = () => {
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
@@ -331,9 +333,6 @@ export const WallTool = () => {
     const [axisGuide, setAxisGuide] = useState(null);
     const measurementColor = isDark ? '#ffffff' : '#111111';
     const measurementShadowColor = isDark ? '#111111' : '#ffffff';
-    // Clear preset-seeded defaults on deactivation so a later manual wall draw
-    // isn't built with a stale preset's parameters. Unmount-only.
-    useEffect(() => () => useEditor.getState().setToolDefaults('wall', null), []);
     useEffect(() => {
         let gridPosition = [0, 0];
         let previousWallEnd = null;
@@ -382,6 +381,7 @@ export const WallTool = () => {
         const pointedSurfaceFor = (event) => event.nativeEvent?.target instanceof HTMLCanvasElement
             ? resolvePointerSupportSurface(cameraRef.current, event.position, {
                 includeNodeTopSurfaces: true,
+                pointerRay: event.nativeEvent.ray,
             })
             : null;
         const snappedWallConstructionPlane = (targetWallIds, walls) => {
@@ -679,4 +679,12 @@ export const WallTool = () => {
     }, [unit, metricNotation]);
     return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
 };
+export const WallTool = () => {
+    // Clear preset-seeded defaults on deactivation so a later manual wall draw
+    // isn't built with a stale preset's parameters. Unmount-only.
+    useEffect(() => () => useEditor.getState().setToolDefaults('wall', null), []);
+    useWallDrawingModeKeys();
+    const mode = useWallDrawingMode((s) => s.mode);
+    return mode === 'rectangle' ? _jsx(RectangleWallTool, {}) : _jsx(LineWallTool, {});
+};
 export default WallTool;

package/dist/wall/wall-batch-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AAkGnE,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAKnD;AA6BD,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AA+BtF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAW5E;AAMD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAsFD,eAAO,MAAM,eAAe,YAmE3B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAyI3D"}
+{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AAkGnE,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAKnD;AA6BD,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AAiCtF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAW5E;AAMD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAsFD,eAAO,MAAM,eAAe,YAmE3B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAyI3D"}

package/dist/wall/wall-batch-system.js

@@ -103,6 +103,9 @@ function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
         return null;
     if (node.visible === false)
         return null;
+    // Curtain walls use a separate caster that excludes their transparent panes.
+    if (node.wallType === 'curtain')
+        return null;
     const mesh = sceneRegistry.nodes.get(nodeId);
     if (!mesh?.visible)
         return null;

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAqBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAQrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AA0JD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAwBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAQrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AAwMD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAsG9D,CAAA"}

package/dist/window/definition.js

@@ -1,6 +1,9 @@
 import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits';
 import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
+import { createOpeningPropertyPreview } from '../shared/opening-property-preview';
+import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
 import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
 import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
@@ -82,7 +85,7 @@ function windowWidthHandle(side) {
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_WINDOW_WIDTH, roofMax);
-            return readWallLength(n, scene);
+            return curtainOpeningResizeMax(n, scene.nodes(), 'x', sign) ?? readWallLength(n, scene);
         },
         currentValue: (n) => n.width,
         onDrag: (node) => publishOpeningResizeGuides(node, true),
@@ -131,6 +134,9 @@ function windowHeightHandle(edge) {
             // 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);
             const anchored = edge === 'top' ? n.position[1] - n.height / 2 : n.position[1] + n.height / 2;
             return edge === 'top'
@@ -157,11 +163,51 @@ function windowHeightHandle(edge) {
         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,
@@ -217,6 +263,7 @@ export const windowDefinition = {
     },
     parametrics: windowParametrics,
     handles: windowHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

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

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

package/dist/window/floorplan-affordances.js

@@ -1,4 +1,6 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getWallCurveLength, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { curtainOpeningLimits } from '../shared/curtain-opening-limits';
+import { projectPlanPointToWallLocalX } from '../shared/wall-attach-target';
 const MIN_WINDOW_WIDTH = 0.3;
 /**
  * 2D drag affordance for the window's width side-arrows. Sister to the 3D
@@ -27,16 +29,12 @@ export const windowWidthAffordance = {
         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 wallLength = wall ? getWallCurveLength(wall) : 1;
+        const limits = curtainOpeningLimits(node, nodes);
+        const margin = limits?.margin ?? 0;
+        const maxWidth = growDir > 0 ? (limits?.length ?? wallLength) - margin - anchorX : anchorX - margin;
         const projectToWallLocalX = (planPoint) => {
-            return (planPoint[0] - wallStart[0]) * dirX + (planPoint[1] - wallStart[1]) * dirZ;
+            return wall ? projectPlanPointToWallLocalX(wall, planPoint) : planPoint[0];
         };
         const initialPointerLocalX = projectToWallLocalX(initialPlanPoint);
         let lastWidth = initialWidth;

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAiBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAiEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAoyClD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAiBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAkEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAiyClD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/window/move-tool.js

@@ -4,6 +4,7 @@ import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelea
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
 import { LineBasicNodeMaterial } from 'three/webgpu';
+import { commitOpeningMove } from '../shared/commit-opening-move';
 import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
 import { beginOpeningMoveHistorySession } from '../shared/opening-move-history';
@@ -493,14 +494,13 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: original.visible,
                 });
                 history.commitStep(() => {
-                    useScene.getState().updateNode(movingWindowNode.id, {
+                    commitOpeningMove(movingWindowNode.id, {
                         position: [target.clampedX, target.clampedY, 0],
                         rotation: [0, target.itemRotation, 0],
                         side: target.side,
                         parentId: target.wallId,
                         wallId: target.wallId,
                         roofSegmentId: undefined,
-                        metadata: {},
                         visible: true,
                     });
                 });
@@ -736,7 +736,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: original.visible,
                 });
                 history.commitStep(() => {
-                    useScene.getState().updateNode(movingWindowNode.id, {
+                    commitOpeningMove(movingWindowNode.id, {
                         position: target.position,
                         rotation,
                         side,
@@ -746,7 +746,6 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         wallId: undefined,
                         roofSegmentId: undefined,
                         roofFace: undefined,
-                        metadata: {},
                         visible: true,
                     });
                 });
@@ -937,7 +936,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: original.visible,
                 });
                 history.commitStep(() => {
-                    useScene.getState().updateNode(movingWindowNode.id, {
+                    commitOpeningMove(movingWindowNode.id, {
                         position: target.position,
                         rotation: [0, 0, 0],
                         side: 'front',
@@ -945,7 +944,6 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         wallId: undefined,
                         roofSegmentId: segmentId,
                         roofFace: target.face.id,
-                        metadata: {},
                         visible: true,
                     });
                 });

package/dist/window/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA6FA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA21BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AAwFA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA20BlC"}