@pascal-app/nodes 1.0.0 → 1.0.3

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"}

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"}