@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/wall/rectangle-tool.js

@@ -0,0 +1,147 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, useScene, wallRectangleCorners, } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, isMagneticSnapActive, markToolCancelConsumed, NO_RAYCAST, publishHorizontalConstructionPlane, resolveEventConstructionPlane, snapWallDraftPointDetailed, triggerSFX, useEditor, useInteractionScope, useLinearDisplay, useRegistryToolContext, useWallSnapIndicator, } from '@pascal-app/editor';
+import { getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useState } from 'react';
+import { DoubleSide } from 'three';
+import { createWallRectangle } from './rectangle-command';
+export default function RectangleWallTool() {
+    const { activeLevelId, isCameraDragging } = useRegistryToolContext();
+    const canvas = useThree((s) => s.gl.domElement);
+    const { isImperial } = useLinearDisplay('m', 2);
+    const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
+    const measurementColor = isDark ? '#ffffff' : '#111111';
+    const measurementShadowColor = isDark ? '#111111' : '#ffffff';
+    const defaults = useEditor((s) => s.toolDefaults.wall);
+    const [draft, setDraft] = useState(null);
+    const [message, setMessage] = useState('');
+    const [cursor, setCursor] = useState(null);
+    const levelHeight = useScene((s) => activeLevelId && s.nodes[activeLevelId]?.type === 'level' ? s.nodes[activeLevelId].height : 3);
+    const height = typeof defaults?.height === 'number' ? defaults.height : (levelHeight ?? 3);
+    const thickness = typeof defaults?.thickness === 'number' ? defaults.thickness : 0.1;
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        setDraft(null);
+        setMessage('');
+        let start = null;
+        let end = null;
+        let plane = null;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'wall' });
+        const pointFor = (e) => {
+            const result = snapWallDraftPointDetailed({
+                point: [e.localPosition[0], e.localPosition[2]],
+                walls: Object.values(useScene.getState().nodes).filter((n) => n.type === 'wall' && n.parentId === activeLevelId),
+                magnetic: isMagneticSnapActive(),
+            });
+            useWallSnapIndicator.getState().set(result.snap
+                ? {
+                    x: result.point[0],
+                    z: result.point[1],
+                    kind: result.snap,
+                    wallIds: result.targetWallIds,
+                }
+                : null);
+            return result.point;
+        };
+        const move = (e) => {
+            if (e.nativeEvent.target !== canvas || isCameraDragging())
+                return;
+            const point = pointFor(e);
+            const hoverPlane = plane ?? resolveEventConstructionPlane(e, null);
+            if (plane)
+                publishHorizontalConstructionPlane(e, plane);
+            setCursor([point[0], hoverPlane.localY, point[1]]);
+            setMessage('');
+            if (!start)
+                return;
+            // The line draft's tick: once per snapped corner position.
+            if (end && (end[0] !== point[0] || end[1] !== point[1]))
+                triggerSFX('sfx:grid-snap');
+            end = point;
+            setDraft({ start, end: point, y: hoverPlane.localY });
+        };
+        const leave = () => {
+            setCursor(null);
+            useWallSnapIndicator.getState().clear();
+        };
+        const cancel = () => {
+            if (start)
+                markToolCancelConsumed();
+            start = null;
+            end = null;
+            plane = null;
+            setDraft(null);
+            setMessage('');
+            leave();
+            clearPlacementSurface();
+        };
+        const click = (e) => {
+            if (e.nativeEvent.target !== canvas || e.nativeEvent.button !== 0 || isCameraDragging())
+                return;
+            const point = pointFor(e);
+            if (!start) {
+                start = point;
+                end = point;
+                plane = resolveEventConstructionPlane(e, null);
+                publishHorizontalConstructionPlane(e, plane);
+                setCursor([point[0], plane.localY, point[1]]);
+                setDraft({ start, end: point, y: plane.localY });
+                setMessage('');
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            try {
+                createWallRectangle(activeLevelId, start, point, useEditor.getState().toolDefaults.wall ?? {}, {
+                    constructionElevation: plane?.elevation,
+                    preferredSupportSlabId: plane?.supportSlabId,
+                    constructionHeight: height,
+                });
+                cancel();
+                triggerSFX('sfx:structure-build');
+            }
+            catch (error) {
+                setMessage(error.message);
+            }
+        };
+        emitter.on('grid:move', move);
+        emitter.on('grid:click', click);
+        emitter.on('tool:cancel', cancel);
+        canvas.addEventListener('pointerleave', leave);
+        return () => {
+            emitter.off('grid:move', move);
+            emitter.off('grid:click', click);
+            emitter.off('tool:cancel', cancel);
+            canvas.removeEventListener('pointerleave', leave);
+            useWallSnapIndicator.getState().clear();
+            clearPlacementSurface();
+            useInteractionScope.getState().endIf((s) => s.kind === 'drafting' && s.tool === 'wall');
+        };
+    }, [activeLevelId, height, canvas, isCameraDragging]);
+    const corners = draft ? wallRectangleCorners(draft.start, draft.end) : [];
+    const unit = isImperial ? 'imperial' : 'metric';
+    // Label the two sides meeting at the cursor corner, as the floor plan does.
+    const cursorIndex = draft
+        ? corners.findIndex(([x, z]) => x === draft.end[0] && z === draft.end[1])
+        : -1;
+    const sideLabels = draft && cursorIndex >= 0
+        ? [cursorIndex + 3, cursorIndex].map((side) => {
+            const a = corners[side % 4];
+            const b = corners[(side + 1) % 4];
+            return {
+                label: formatLinearMeasurement(Math.hypot(b[0] - a[0], b[1] - a[1]), unit),
+                position: [
+                    (a[0] + b[0]) / 2,
+                    draft.y + height + DRAFT_LABEL_Y_OFFSET,
+                    (a[1] + b[1]) / 2,
+                ],
+            };
+        })
+        : [];
+    return (_jsxs("group", { children: [_jsx(CursorSphere, { name: "rectangle-wall-cursor", height: height, position: cursor ?? [0, 0, 0], visible: !!cursor }), corners.map((a, i) => {
+                const b = corners[(i + 1) % 4];
+                return (_jsxs("mesh", { layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 1, position: [(a[0] + b[0]) / 2, draft.y + height / 2, (a[1] + b[1]) / 2], rotation: [0, -Math.atan2(b[1] - a[1], b[0] - a[0]), 0], children: [_jsx("boxGeometry", { args: [Math.hypot(b[0] - a[0], b[1] - a[1]), height, thickness] }), _jsx("meshBasicMaterial", { color: message ? '#ef4444' : '#818cf8', depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }, i));
+            }), draft && message ? (_jsx(DraftMeasurementLabel, { color: "#ef4444", label: message, position: [draft.end[0], draft.y + height + DRAFT_LABEL_Y_OFFSET, draft.end[1]], shadowColor: measurementShadowColor })) : (sideLabels.map((side, index) => (_jsx(DraftMeasurementLabel, { color: measurementColor, label: side.label, position: side.position, shadowColor: measurementShadowColor }, index))))] }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAsCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA4IjD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAuCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAyJjD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/renderer.js

@@ -1,10 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { hiddenWallPointerEventsHeld, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { getVisibleWallMaterials, NodeRenderer, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { NodeRenderer, SHADOW_ONLY_LAYER, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
+import { getCurtainAwareWallMaterials } from './curtain-wall-materials';
 import { extractWallSelectionRay, WALL_COLLISION_MESH_NAME, wallPointerEventsSuppressed, } from './pointer-transparency';
 import { createWallRayHitClassifier } from './selection-hit-owner';
 import { createWallTreatmentSelector, useWallTreatmentLevelData } from './treatment-level-data';
@@ -38,6 +39,7 @@ const WallRenderer = ({ node }) => {
     const ref = useRef(null);
     const placeholderGeometry = useMemo(() => createPlaceholderGeometry(3), []);
     const collisionPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(), []);
+    const shadowPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(), []);
     useRegistry(node.id, 'wall', ref);
     useLayoutEffect(() => {
         useScene.getState().markDirty(node.id);
@@ -46,8 +48,9 @@ const WallRenderer = ({ node }) => {
         return () => {
             placeholderGeometry.dispose();
             collisionPlaceholderGeometry.dispose();
+            shadowPlaceholderGeometry.dispose();
         };
-    }, [collisionPlaceholderGeometry, placeholderGeometry]);
+    }, [collisionPlaceholderGeometry, placeholderGeometry, shadowPlaceholderGeometry]);
     const rawHandlers = useNodeEvents(node, 'wall');
     // Hidden walls participate in hover/selection NEAREST-FIRST: when the
     // wall-mode pass hides this wall (`WallCutout` stamps `userData.wallHidden`
@@ -110,7 +113,7 @@ const WallRenderer = ({ node }) => {
     // register after mount, and a dangling ref cached as the slot default must
     // re-resolve when they land.
     const libraryMaterialsVersion = useLibraryMaterialsVersion();
-    const baseMaterials = getVisibleWallMaterials(node, shading, textures, colorPreset, sceneTheme, sceneMaterials);
+    const baseMaterials = getCurtainAwareWallMaterials(treatmentNode, shading, textures, colorPreset, sceneTheme, sceneMaterials).visible;
     // biome-ignore lint/correctness/useExhaustiveDependencies: libraryMaterialsVersion invalidates the ref resolution inside createWallExtraSlotMaterials
     const extraMaterials = useMemo(() => createWallExtraSlotMaterials(node, shading, sceneMaterials), [node, sceneMaterials, shading, libraryMaterialsVersion]);
     useEffect(() => () => {
@@ -119,6 +122,6 @@ const WallRenderer = ({ node }) => {
         for (const entry of owned)
             entry.dispose();
     }, [baseMaterials, extraMaterials]);
-    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: WALL_COLLISION_MESH_NAME, visible: false, ...handlers }), hasWallTreatments(treatmentNode) && (_jsx(WallTreatmentSubscription, { childrenNodes: childNodes, materials: extraMaterials, node: treatmentNode })), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
+    return (_jsxs("mesh", { castShadow: node.wallType !== 'curtain', geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { name: "curtain-wall-shadow", userData: { pascalExport: 'strip' }, geometry: shadowPlaceholderGeometry, layers: SHADOW_ONLY_LAYER, castShadow: true, visible: node.wallType === 'curtain', raycast: () => { }, children: _jsx("meshBasicMaterial", {}) }), _jsx("mesh", { geometry: collisionPlaceholderGeometry, name: WALL_COLLISION_MESH_NAME, visible: false, ...handlers }), node.wallType !== 'curtain' && hasWallTreatments(treatmentNode) && (_jsx(WallTreatmentSubscription, { childrenNodes: childNodes, materials: extraMaterials, node: treatmentNode })), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
 };
 export default WallRenderer;

package/dist/wall/slots.d.ts

@@ -1,4 +1,4 @@
-import { type SlotDeclaration } from '@pascal-app/core';
+import { type SlotDeclaration, type WallNode } from '@pascal-app/core';
 /**
  * A wall exposes two paintable faces — interior + exterior. Painting writes
  * `node.slots[interior|exterior]` via `wallPaint` like every other kind; this
@@ -6,5 +6,5 @@ import { type SlotDeclaration } from '@pascal-app/core';
  * keeps walls on the same `{ slotId, label, default }` contract. The defaults
  * come from core so the viewer's material resolver renders the identical value.
  */
-export declare function wallSlots(): SlotDeclaration[];
+export declare function wallSlots(node?: WallNode): SlotDeclaration[];
 //# sourceMappingURL=slots.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/wall/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA8B,MAAM,kBAAkB,CAAA;AAEnF;;;;;;GAMG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CA2E7C"}
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/wall/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,eAAe,EAAE,CAmF5D"}

package/dist/wall/slots.js

@@ -1,4 +1,4 @@
-import { WALL_SURFACE_SLOT_DEFAULTS } from '@pascal-app/core';
+import { getCurtainWallConfig, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 /**
  * A wall exposes two paintable faces — interior + exterior. Painting writes
  * `node.slots[interior|exterior]` via `wallPaint` like every other kind; this
@@ -6,7 +6,15 @@ import { WALL_SURFACE_SLOT_DEFAULTS } from '@pascal-app/core';
  * keeps walls on the same `{ slotId, label, default }` contract. The defaults
  * come from core so the viewer's material resolver renders the identical value.
  */
-export function wallSlots() {
+export function wallSlots(node) {
+    if (node?.wallType === 'curtain') {
+        const config = getCurtainWallConfig(node);
+        return [
+            { slotId: 'curtain-frame', label: 'Frame', default: config.frameColor },
+            { slotId: 'curtain-glass', label: 'Glass', default: config.glassColor },
+            { slotId: 'curtain-solid', label: 'Solid panels', default: config.solidColor },
+        ];
+    }
     return [
         { slotId: 'interior', label: 'Interior', default: WALL_SURFACE_SLOT_DEFAULTS.interior },
         { slotId: 'exterior', label: 'Exterior', default: WALL_SURFACE_SLOT_DEFAULTS.exterior },

package/dist/wall/split-floorplan-layer.d.ts

@@ -0,0 +1,4 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+/** The plan side of the wall's `split` reshape (`reshapeLayers.split`): the same draft as 3D. */
+export default function WallSplitFloorplanLayer(_props: FloorplanToolContext): import("react").JSX.Element | null;
+//# sourceMappingURL=split-floorplan-layer.d.ts.map

package/dist/wall/split-floorplan-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-floorplan-layer.d.ts","sourceRoot":"","sources":["../../src/wall/split-floorplan-layer.tsx"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,oBAAoB,EAG1B,MAAM,oBAAoB,CAAA;AAO3B,iGAAiG;AACjG,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,sCAgG3E"}

package/dist/wall/split-floorplan-layer.js

@@ -0,0 +1,71 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, useScene, } from '@pascal-app/core';
+import { clientToPlan, FloorplanDraftWallMeasurement, formatLinearMeasurement, useFloorplanRender, } from '@pascal-app/editor';
+import { getSceneTheme, useViewer } from '@pascal-app/viewer';
+import { useEffect } from 'react';
+import { bindWallSplitPointer } from './split-pointer';
+import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview';
+import { useWallSplit } from './split-store';
+/** The plan side of the wall's `split` reshape (`reshapeLayers.split`): the same draft as 3D. */
+export default function WallSplitFloorplanLayer(_props) {
+    const draft = useWallSplit((s) => s.draft);
+    const wallId = draft?.wallId;
+    const wall = useScene((s) => (draft ? s.nodes[draft.wallId] : undefined));
+    const levelId = useViewer((s) => s.selection.levelId);
+    const unit = useViewer((s) => s.unit);
+    const metricNotation = useViewer((s) => s.metricNotation);
+    const isDark = useViewer((s) => getSceneTheme(s.sceneTheme).appearance === 'dark');
+    const context = useFloorplanRender();
+    const upp = context?.unitsPerPixel ?? 0.01;
+    useEffect(() => {
+        if (!wallId || useScene.getState().nodes[wallId]?.parentId !== levelId)
+            return;
+        const scene = document.querySelector('g[data-floorplan-scene]');
+        const surface = scene?.ownerSVGElement;
+        if (!surface)
+            return;
+        return bindWallSplitPointer(surface, (event) => {
+            if (!(event.target instanceof Node) || !surface.contains(event.target))
+                return null;
+            const point = clientToPlan(event.clientX, event.clientY);
+            const current = useScene.getState().nodes[wallId];
+            if (!point || current?.type !== 'wall')
+                return null;
+            const distance = wallSplitDistance(current, point);
+            // Only the wall's own stroke is a target, including its endpoint exclusion zones.
+            const frame = frameAt(current, distance);
+            if (Math.hypot(frame.point.x - point[0], frame.point.y - point[1]) > hitHalfWidth(current, upp))
+                return null;
+            return distance;
+        });
+    }, [wallId, levelId, upp]);
+    if (!draft || wall?.type !== 'wall' || wall.parentId !== levelId)
+        return null;
+    const { preview, snap } = draft;
+    const half = hitHalfWidth(wall, upp);
+    const color = wallSplitMarkerColor(preview.valid);
+    const cut = preview.frames[0]?.point;
+    return (_jsxs("g", { pointerEvents: "none", "data-testid": "pascal-split-marker-2d", children: [snap?.kind === 'alignment' && cut && (_jsx("line", { stroke: "#818cf8", strokeDasharray: `${4 * upp} ${3 * upp}`, strokeOpacity: 0.8, strokeWidth: upp, x1: snap.anchor[0], x2: cut.x, y1: snap.anchor[1], y2: cut.y })), preview.frames.map(({ point, normal }, index) => {
+                const line = {
+                    x1: point.x - normal.x * half,
+                    y1: point.y - normal.y * half,
+                    x2: point.x + normal.x * half,
+                    y2: point.y + normal.y * half,
+                };
+                return (_jsxs("g", { children: [_jsx("line", { ...line, stroke: "#f7f3ed", strokeWidth: 7 * upp, strokeLinecap: "round" }), _jsx("line", { ...line, stroke: color, strokeWidth: 3 * upp, strokeLinecap: "round" })] }, index));
+            }), !preview.valid && cut ? (_jsx("text", { fill: color, fontSize: 12 * upp, paintOrder: "stroke", stroke: isDark ? '#0f172a' : '#ffffff', strokeWidth: 3 * upp, textAnchor: "middle", x: cut.x, y: cut.y - half - 6 * upp, children: preview.message })) : (wallSplitSegmentLabels(wall, preview).map((segment, index) => (_jsx(FloorplanDraftWallMeasurement, { labelBackground: isDark ? '#0f172a' : '#ffffff', labelText: isDark ? '#e2e8f0' : '#171717', measurement: {
+                    lengthLabel: `${formatLinearMeasurement(segment.length, unit, metricNotation)}${segment.count > 1 ? ` × ${segment.count}` : ''}`,
+                    midpoint: segment.midpoint,
+                    direction: segment.direction,
+                    angleLabels: [],
+                }, measurementStroke: context?.palette.measurementStroke ?? color, sceneRotationDeg: context?.sceneRotationDeg ?? 0, unitsPerPixel: upp }, index))))] }));
+}
+/** The wall's stroke plus a finger's width, so the cut can be grabbed at any zoom. */
+function hitHalfWidth(wall, upp) {
+    return getWallThickness(wall) / 2 + 8 * upp;
+}
+function frameAt(wall, distance) {
+    const length = getWallCurveLength(wall);
+    return getWallCurveFrameAt(wall, length > 0 ? distance / length : 0);
+}

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

@@ -0,0 +1,3 @@
+/** Both viewports feed a wall distance; neither writes scene nodes while hovering. */
+export declare function bindWallSplitPointer(surface: Element, distanceAt: (event: PointerEvent) => number | null): () => void;
+//# sourceMappingURL=split-pointer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"split-pointer.d.ts","sourceRoot":"","sources":["../../src/wall/split-pointer.ts"],"names":[],"mappings":"AAUA,sFAAsF;AACtF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,MAAM,GAAG,IAAI,cA2EnD"}

package/dist/wall/split-pointer.js

@@ -0,0 +1,95 @@
+import { commitWallSplit, hoverWallSplit, setWallSplitCuts } from './split-session';
+import { useWallSplit } from './split-store';
+// Pixels of continuous wheel travel per cut: a short trackpad swipe.
+const WHEEL_STEP_PX = 60;
+// A wheel event after this pause is a new notch or gesture and steps at once,
+// so each notch of a notched wheel is one cut whatever pixels the OS reports
+// for it; a continuous stream (trackpad, fast spin) steps by travel.
+const WHEEL_GESTURE_GAP_MS = 80;
+/** Both viewports feed a wall distance; neither writes scene nodes while hovering. */
+export function bindWallSplitPointer(surface, distanceAt) {
+    let pressed = null;
+    let wheelTravel = 0;
+    let lastWheelAt = Number.NEGATIVE_INFINITY;
+    const move = (event) => {
+        if (event.buttons && pressed !== event.pointerId)
+            return;
+        const distance = distanceAt(event);
+        if (distance !== null)
+            hoverWallSplit(distance, event.altKey);
+    };
+    const down = (event) => {
+        if (event.button !== 0)
+            return;
+        const distance = distanceAt(event);
+        if (distance === null)
+            return;
+        pressed = event.pointerId;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        hoverWallSplit(distance, event.altKey);
+    };
+    const up = (event) => {
+        if (pressed !== event.pointerId)
+            return;
+        pressed = null;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        const distance = distanceAt(event);
+        if (distance === null)
+            return;
+        hoverWallSplit(distance, event.altKey);
+        // Retain ownership through the click dispatched after pointerup, so normal
+        // selection cannot consume that same click after the cut closes its session.
+        const swallow = (click) => {
+            click.preventDefault();
+            click.stopImmediatePropagation();
+        };
+        surface.addEventListener('click', swallow, { capture: true, once: true });
+        setTimeout(() => surface.removeEventListener('click', swallow, true), 0);
+        commitWallSplit();
+    };
+    const cancel = () => {
+        pressed = null;
+    };
+    // Scrolling over the viewport changes the cut count, as in a loop cut;
+    // pinch (Ctrl + wheel) still zooms.
+    const wheel = (event) => {
+        if (event.ctrlKey || !(event.target instanceof Node) || !surface.contains(event.target))
+            return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        if (!event.deltaY)
+            return;
+        const fresh = event.timeStamp - lastWheelAt > WHEEL_GESTURE_GAP_MS;
+        lastWheelAt = event.timeStamp;
+        let steps;
+        // Line-mode deltas only come from a notched wheel: one line event, one notch.
+        if (fresh || event.deltaMode !== 0) {
+            wheelTravel = 0;
+            steps = Math.sign(event.deltaY);
+        }
+        else {
+            wheelTravel += event.deltaY;
+            steps = Math.trunc(wheelTravel / WHEEL_STEP_PX);
+            wheelTravel -= steps * WHEEL_STEP_PX;
+        }
+        if (!steps)
+            return;
+        const draft = useWallSplit.getState().draft;
+        if (draft)
+            setWallSplitCuts(draft.cuts - steps);
+    };
+    window.addEventListener('pointermove', move, true);
+    window.addEventListener('pointerdown', down, true);
+    window.addEventListener('pointerup', up, true);
+    window.addEventListener('pointercancel', cancel, true);
+    window.addEventListener('wheel', wheel, { capture: true, passive: false });
+    return () => {
+        window.removeEventListener('pointermove', move, true);
+        window.removeEventListener('pointerdown', down, true);
+        window.removeEventListener('pointerup', up, true);
+        window.removeEventListener('pointercancel', cancel, true);
+        window.removeEventListener('wheel', wheel, true);
+    };
+}

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

@@ -0,0 +1,55 @@
+import { type AnyNode, type AnyNodeId, type WallNode, type WallPlanPoint } from '@pascal-app/core';
+export declare const WALL_SPLIT_MAX_CUTS = 32;
+/** Cut markers in both views: warm when the cuts can commit, red when they can't. */
+export declare function wallSplitMarkerColor(valid: boolean): "#c86f45" | "#a63d2e";
+/** The pointer projected onto the wall, as a distance from its start; curved walls included. */
+export declare function wallSplitDistance(wall: WallNode, point: readonly [number, number]): number;
+/** Like a loop cut: one cut follows the pointer, more cuts divide the wall evenly. */
+export declare function wallSplitDistances(length: number, cuts: number, distance: number): number[];
+export type WallSplitSnap = {
+    kind: 'grid';
+} | {
+    kind: 'midpoint';
+} | {
+    kind: 'alignment';
+    anchor: WallPlanPoint;
+} | null;
+export type WallSplitSnapOptions = {
+    /** Grid step while the 'grid' snapping mode is active. */
+    gridStep: number | null;
+    /** Other wall ends to align with while the 'lines' mode is active. */
+    anchors: readonly WallPlanPoint[] | null;
+    /** How far (m) the pointer may be from an alignment target to catch it. */
+    tolerance: number;
+};
+/**
+ * Snaps a single cut along its wall with the active snapping mode: grid steps
+ * counted from the wall start, or — in 'lines' — the midpoint and where the
+ * level's other wall ends project onto the wall.
+ */
+export declare function snapWallSplitDistance(wall: WallNode, raw: number, options: WallSplitSnapOptions): {
+    distance: number;
+    snap: WallSplitSnap;
+};
+/** Ends of the level's other walls, for 'lines' alignment. */
+export declare function wallSplitAnchors(nodes: Record<AnyNodeId, AnyNode>, wall: WallNode): WallPlanPoint[];
+export declare function wallSplitPreview(nodes: Record<AnyNodeId, AnyNode>, wall: WallNode, distances: readonly number[]): {
+    distances: number[];
+    length: number;
+    frames: {
+        point: import("@pascal-app/core").Point2D;
+        tangent: import("@pascal-app/core").Point2D;
+        normal: import("@pascal-app/core").Point2D;
+    }[];
+    valid: boolean;
+    message: string;
+};
+export type WallSplitPreview = ReturnType<typeof wallSplitPreview>;
+/** What to label: both sides of a single cut, or one length repeated across even cuts. */
+export declare function wallSplitSegmentLabels(wall: WallNode, preview: WallSplitPreview): {
+    length: number;
+    count: number;
+    midpoint: WallPlanPoint;
+    direction: WallPlanPoint;
+}[];
+//# sourceMappingURL=split-preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"split-preview.d.ts","sourceRoot":"","sources":["../../src/wall/split-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAKd,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,yBAElD;AAID,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAuB1F;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAG3F;AAED,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,aAAa,CAAA;CAAE,GAC5C,IAAI,CAAA;AAER,MAAM,MAAM,oBAAoB,GAAG;IACjC,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,sEAAsE;IACtE,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,IAAI,CAAA;IACxC,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,oBAAoB,GAC5B;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,aAAa,CAAA;CAAE,CAyB3C;AAED,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,QAAQ,GACb,aAAa,EAAE,CAQjB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,SAAS,MAAM,EAAE;;;;;;;;;;EAqB7B;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAElE,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB;;;cAY1C,aAAa;eACR,aAAa;IAGvD"}

package/dist/wall/split-preview.js

@@ -0,0 +1,106 @@
+import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, planWallDivisions, } from '@pascal-app/core';
+export const WALL_SPLIT_MAX_CUTS = 32;
+/** Cut markers in both views: warm when the cuts can commit, red when they can't. */
+export function wallSplitMarkerColor(valid) {
+    return valid ? '#c86f45' : '#a63d2e';
+}
+// The planner refuses cuts closer than this to either end.
+const END_CLEARANCE = 0.05;
+/** The pointer projected onto the wall, as a distance from its start; curved walls included. */
+export function wallSplitDistance(wall, point) {
+    const length = getWallCurveLength(wall);
+    const arc = getWallArcData(wall);
+    if (arc) {
+        const angle = Math.atan2(point[1] - arc.center.y, point[0] - arc.center.x);
+        const turn = Math.PI * 2;
+        const delta = (((arc.direction * (angle - arc.startAngle)) % turn) + turn) % turn;
+        if (delta <= Math.abs(arc.delta))
+            return (delta / Math.abs(arc.delta)) * length;
+        return Math.hypot(point[0] - wall.start[0], point[1] - wall.start[1]) <=
+            Math.hypot(point[0] - wall.end[0], point[1] - wall.end[1])
+            ? 0
+            : length;
+    }
+    if (length === 0)
+        return 0;
+    return Math.max(0, Math.min(length, ((point[0] - wall.start[0]) * (wall.end[0] - wall.start[0]) +
+        (point[1] - wall.start[1]) * (wall.end[1] - wall.start[1])) /
+        length));
+}
+/** Like a loop cut: one cut follows the pointer, more cuts divide the wall evenly. */
+export function wallSplitDistances(length, cuts, distance) {
+    if (cuts <= 1)
+        return [distance];
+    return Array.from({ length: cuts }, (_, index) => (length * (index + 1)) / (cuts + 1));
+}
+/**
+ * Snaps a single cut along its wall with the active snapping mode: grid steps
+ * counted from the wall start, or — in 'lines' — the midpoint and where the
+ * level's other wall ends project onto the wall.
+ */
+export function snapWallSplitDistance(wall, raw, options) {
+    const length = getWallCurveLength(wall);
+    const inside = (distance) => distance >= END_CLEARANCE && distance <= length - END_CLEARANCE;
+    if (options.gridStep) {
+        const snapped = Math.round(raw / options.gridStep) * options.gridStep;
+        return inside(snapped)
+            ? { distance: snapped, snap: { kind: 'grid' } }
+            : { distance: raw, snap: null };
+    }
+    if (!options.anchors)
+        return { distance: raw, snap: null };
+    let best = {
+        distance: raw,
+        snap: null,
+        gap: options.tolerance,
+    };
+    const consider = (distance, snap) => {
+        const gap = Math.abs(distance - raw);
+        if (gap < best.gap && inside(distance))
+            best = { distance, snap, gap };
+    };
+    consider(length / 2, { kind: 'midpoint' });
+    for (const anchor of options.anchors) {
+        consider(wallSplitDistance(wall, anchor), { kind: 'alignment', anchor });
+    }
+    return { distance: best.distance, snap: best.snap };
+}
+/** Ends of the level's other walls, for 'lines' alignment. */
+export function wallSplitAnchors(nodes, wall) {
+    const own = (point) => [wall.start, wall.end].some((end) => end[0] === point[0] && end[1] === point[1]);
+    return Object.values(nodes).flatMap((node) => node.type === 'wall' && node.id !== wall.id && node.parentId === wall.parentId
+        ? [node.start, node.end].filter((point) => !own(point))
+        : []);
+}
+export function wallSplitPreview(nodes, wall, distances) {
+    const length = getWallCurveLength(wall);
+    const frames = distances.map((distance) => getWallCurveFrameAt(wall, length > 0 ? distance / length : 0));
+    let message = '';
+    if ([wall, ...Object.values(nodes).filter((n) => n.parentId === wall.id)].some((n) => n.metadata.arrayModifier || n.metadata.linkedArray)) {
+        message = 'Make the linked array real before splitting this wall.';
+    }
+    else {
+        try {
+            planWallDivisions(nodes, wall.id, distances);
+        }
+        catch (error) {
+            message = error instanceof Error ? error.message : 'This wall cannot be split here.';
+        }
+    }
+    return { distances: [...distances], length, frames, valid: !message, message };
+}
+/** What to label: both sides of a single cut, or one length repeated across even cuts. */
+export function wallSplitSegmentLabels(wall, preview) {
+    const bounds = [0, ...preview.distances, preview.length];
+    const segments = bounds.slice(1).map((end, index) => [bounds[index], end]);
+    const count = preview.distances.length === 1 ? 1 : segments.length;
+    return (count === 1 ? segments : segments.slice(0, 1)).map(([from, to]) => {
+        const { point, tangent } = getWallCurveFrameAt(wall, preview.length > 0 ? (from + to) / 2 / preview.length : 0);
+        return {
+            length: to - from,
+            count,
+            midpoint: [point.x, point.y],
+            direction: [tangent.x, tangent.y],
+        };
+    });
+}

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

@@ -0,0 +1,16 @@
+import { type WallNode } from '@pascal-app/core';
+/**
+ * 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 declare function openWallSplit(wall: WallNode): void;
+export declare function closeWallSplit(): void;
+/** Pointer projected onto the wall; Alt (`free`) skips snapping. */
+export declare function hoverWallSplit(raw: number, free?: boolean): void;
+export declare function setWallSplitCuts(cuts: number): void;
+/** Re-plan against the current scene (after an external edit). */
+export declare function refreshWallSplit(): void;
+export declare function commitWallSplit(): void;
+//# sourceMappingURL=split-session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"split-session.d.ts","sourceRoot":"","sources":["../../src/wall/split-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAuCzB;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,QA6C3C;AAED,wBAAgB,cAAc,SAQ7B;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,UAAQ,QAevD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,QAQ5C;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,SAM/B;AAED,wBAAgB,eAAe,SAY9B"}