@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/wall/tool.js

@@ -1,6 +1,6 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } 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 { addWallPolygonDraftCorner, CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, commitWallPolygonDraft, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getWallDrawVariant, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallDrawVariant, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallPolygonDraftWalls, } from '@pascal-app/editor';
+import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, formatAngleRadians, formatLinearMeasurement, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
+import { addWallPolygonDraftCorner, CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, commitWallPolygonDraft, createInvisibleWallOnCurrentLevel, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, endWallPullRun, formatWallDraftHeading, getAngleArcToSegmentReference, getAngleToSegmentReference, getGridEventScreenProjection, getSegmentAngleReferenceAtPoint, getSegmentGridStep, getWallDrawVariant, getWallLineKind, invisibleWallDraftSnapLines, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isTypingTarget, isWallRunFree, LocalizedHtml, markToolCancelConsumed, PLACEMENT_TYPING_LENGTH_ANGLE, PlacementCoordinateInput, placementTypingLengthOptions, publishHorizontalConstructionPlane, publishPlacementSurface, publishWallRunFeedback, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, resolveTypedWallEnd, routePlacementTypingKey, snapWallDraftPointDetailed, snapWallRunDraftPoint, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, usePlacementTyping, useSegmentDraftChain, useWallDraftThickness, useWallDrawVariant, useWallPullRun, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallDraftIsRun, wallPolygonDraftWalls, wallRunDirection, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
@@ -10,14 +10,23 @@ import RectangleWallTool from './rectangle-tool.js';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
  *
- * 1:1 port of the legacy `WallTool`. Two-click flow: click 1 sets the
- * start, click 2 creates the wall. Between clicks a vertical preview
- * rectangle + length/angle measurement HUD follow the pointer. Snapping is
- * governed by the global snapping mode (`'off'` is the bypass); Esc cancels.
+ * Walls: click 1 sets the start, click 2 creates the wall, and the tool waits
+ * for the next start. Polygon: each click adds a corner and the next side
+ * chains from it until Esc, a double-click, closing the loop or teeing into
+ * another wall. Between clicks a vertical preview rectangle + length/angle
+ * measurement HUD follow the pointer. Snapping is governed by the global
+ * snapping mode (`'off'` is the bypass): a Walls segment locks to 15° rays from
+ * its start; a Polygon side holds square to the one before and the house's
+ * axes, with projection guides and a labelled snap marker
+ * (`snapWallRunDraftPoint`).
  *
  * Not a `DragAction` — same reasoning as fence/slab/ceiling placement:
  * stateful sequence of grid:click events, not a single drag-up.
  *
+ * A wall end's pull grip (`startWallPull`) arms a run already started at that
+ * end: the tool seeds its chain from `useWallPullRun`, its first wall square to
+ * the pulled one, and ends the pull when the chain stops.
+ *
  * Mounted via `def.tool` from `wall/definition.ts`.
  */
 const DRAFT_WALL_THICKNESS = 0.1;
@@ -290,6 +299,25 @@ function getBelowLevelWalls() {
         .sort((a, b) => b.level - a.level)[0];
     return getLevelWalls(belowLevel?.id ?? null, nodes);
 }
+/**
+ * The walls the line tool snaps a drafted point against. `walls` is the active
+ * level, which the measurement HUD reports against. `snapWalls` adds an open
+ * Polygon room's sides and, as a reference for the corner and edge snaps, the
+ * floor below. `bodyWalls` leaves the floor below out: a body capture T-joins
+ * the wall it lands in, and a wall on another floor can't be joined, so an end
+ * near a lower wall's face stays where the plan (which only knows the active
+ * level) puts it. An invisible-wall draft also catches the invisible walls
+ * already drawn (`invisibleWallDraftSnapLines`).
+ */
+export function getWallDraftSnapWalls() {
+    const walls = getCurrentLevelWalls();
+    const draftWalls = [...wallPolygonDraftWalls(), ...invisibleWallDraftSnapLines()];
+    return {
+        walls,
+        snapWalls: [...walls, ...getBelowLevelWalls(), ...draftWalls],
+        bodyWalls: [...walls, ...draftWalls],
+    };
+}
 const LineWallTool = () => {
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
@@ -311,7 +339,7 @@ const LineWallTool = () => {
     const cameraRef = useRef(camera);
     cameraRef.current = camera;
     const previewHeight = typeof wallDefaults?.height === 'number' ? wallDefaults.height : activeLevelHeight;
-    const previewThickness = typeof wallDefaults?.thickness === 'number' ? wallDefaults.thickness : DRAFT_WALL_THICKNESS;
+    const previewThickness = useWallDraftThickness(DRAFT_WALL_THICKNESS);
     const previewHeightRef = useRef(previewHeight);
     previewHeightRef.current = previewHeight;
     const previewThicknessRef = useRef(previewThickness);
@@ -329,6 +357,7 @@ const LineWallTool = () => {
     const flatConstructionBase = useRef(false);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
+    const typingActive = usePlacementTyping((s) => s.isActive);
     // Base Y of an open Polygon room's ghost sides (its construction plane).
     const [polygonGhostY, setPolygonGhostY] = useState(0);
     const [axisGuide, setAxisGuide] = useState(null);
@@ -440,6 +469,8 @@ const LineWallTool = () => {
             flatConstructionBase.current = false;
             chainFirstVertex.current = null;
             chainWallIds.current = [];
+            draftPointer = null;
+            usePlacementTyping.getState().clear();
             const draftPreview = useFloorplanDraftPreview.getState();
             draftPreview.setWallDraftStart(null);
             draftPreview.setWallDraftEnd(null);
@@ -452,11 +483,99 @@ const LineWallTool = () => {
             useWallSnapIndicator.getState().clear();
             useSegmentDraftChain.getState().clear('wall');
             clearPlacementSurface();
+            seededPullSeq = null;
+            runReference = null;
+            // A pulled run ends with its chain: back to Select.
+            endWallPullRun();
         };
         // In 2D-only view the plan owns wall drafting; this tool stays mounted
         // behind the hidden canvas and still hears the plan's grid events, so it
         // must not also draft (it would add every corner twice).
         const planOwnsInput = () => visibleScene(useEditor.getState()) === '2d';
+        // The pull run this chain was seeded from.
+        let seededPullSeq = null;
+        // Direction of the run's last wall (the pulled one first); null before one.
+        let runReference = null;
+        // The floor plan forwards its own snapped moves; it shows their feedback.
+        const fromCanvas = (event) => event.nativeEvent?.target instanceof HTMLCanvasElement;
+        // A started run holds square to its last wall and the house's axes.
+        const snapRun = (point, event) => {
+            const runStart = chainFirstVertex.current ?? startingPoint.current;
+            return snapWallRunDraftPoint({
+                point,
+                start: [startingPoint.current.x, startingPoint.current.z],
+                runStart: [runStart.x, runStart.z],
+                reference: runReference,
+                walls: getWallDraftSnapWalls().bodyWalls,
+                free: isWallRunFree(event.nativeEvent),
+            });
+        };
+        // A wall end's pull grip opens the run at that end: start the chain there,
+        // on the pulled wall's own base, as if its end had been clicked.
+        const seedPull = (run) => {
+            if (!run || run.seq === seededPullSeq || planOwnsInput())
+                return;
+            const { walls } = getWallDraftSnapWalls();
+            const plane = snappedWallConstructionPlane([run.sourceWallId], walls) ?? resolveLevelConstructionPlane();
+            if (!plane)
+                return;
+            seededPullSeq = run.seq;
+            runReference = run.reference;
+            constructionPlane.current = plane;
+            flatConstructionBase.current = false;
+            chainWallIds.current = [];
+            startingPoint.current.set(run.start[0], plane.localY, run.start[1]);
+            chainFirstVertex.current = startingPoint.current.clone();
+            endingPoint.current.copy(startingPoint.current);
+            buildingState.current = 1;
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setWallDraftStart(run.start);
+            draftPreview.setWallDraftEnd(run.start);
+            cursorRef.current?.position.copy(startingPoint.current);
+            if (wallPreviewRef.current)
+                wallPreviewRef.current.visible = false;
+            setDraftMeasurement(null);
+            setAxisGuide({ origin: run.start, endOrigin: null, y: plane.localY, angleLabel: null });
+        };
+        // The pointer's own (snapped) draft end. A typed session re-projects it on
+        // every move and every keystroke, so the preview never waits for the mouse.
+        let draftPointer = null;
+        let draftY = 0;
+        const typedDraftEnd = (pointer) => {
+            const typing = usePlacementTyping.getState();
+            if (!typing.isActive)
+                return null;
+            return resolveTypedWallEnd([startingPoint.current.x, startingPoint.current.z], pointer, typing.fields, placementTypingLengthOptions(unit, metricNotation), getSegmentGridStep());
+        };
+        // Before the first move after a click the pointer still sits on the start.
+        const currentPointer = () => draftPointer
+            ? [draftPointer, draftY]
+            : [[startingPoint.current.x, startingPoint.current.z], startingPoint.current.y];
+        const showDraftEnd = (walls) => {
+            if (!wallPreviewRef.current)
+                return;
+            const [pointer, pointerY] = currentPointer();
+            const snappedLocal = typedDraftEnd(pointer) ?? pointer;
+            endingPoint.current.set(snappedLocal[0], pointerY, snappedLocal[1]);
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setWallDraftStart([startingPoint.current.x, startingPoint.current.z]);
+            draftPreview.setWallDraftEnd(snappedLocal);
+            cursorRef.current?.position.copy(endingPoint.current);
+            setAxisGuide({
+                origin: [startingPoint.current.x, startingPoint.current.z],
+                endOrigin: snappedLocal,
+                y: startingPoint.current.y,
+                angleLabel: getNearestAxisAngleLabel([startingPoint.current.x, startingPoint.current.z], snappedLocal, startingPoint.current.y),
+            });
+            const currentWallEnd = [snappedLocal[0], snappedLocal[1]];
+            if (previousWallEnd &&
+                (currentWallEnd[0] !== previousWallEnd[0] || currentWallEnd[1] !== previousWallEnd[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousWallEnd = currentWallEnd;
+            updateWallPreview(wallPreviewRef.current, startingPoint.current, endingPoint.current, previewHeightRef.current, previewThicknessRef.current);
+            setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, walls, unit, metricNotation, startingPoint.current.y, previewHeightRef.current));
+        };
         const onGridMove = (event) => {
             if (!(cursorRef.current && wallPreviewRef.current) || planOwnsInput())
                 return;
@@ -472,54 +591,62 @@ const LineWallTool = () => {
             else if (pointed) {
                 publishPlacementSurface(surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]), SURFACE_UP);
             }
-            const walls = getCurrentLevelWalls();
-            // Add walls on the floor below as extra snap references so the new wall
-            // can align with the level beneath it. Kept separate from `walls` so the
-            // measurement HUD only reports against the active level.
-            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
+            // Walls on the floor below are extra snap references so the new wall can
+            // align with the level beneath it; the measurement HUD reports against
+            // the active level's `walls` only.
+            const { walls, snapWalls, bodyWalls } = getWallDraftSnapWalls();
             const localPoint = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
                 : [event.localPosition[0], event.localPosition[2]];
             // Snapping is governed entirely by the snapping mode (grid / lines /
             // angles / off). `'off'` is the bypass — there is no Shift hold-to-bypass.
-            const angleLocked = buildingState.current === 1 && isAngleSnapActive();
-            const snapResult = snapWallDraftPointDetailed({
-                point: localPoint,
-                walls: snapWalls,
-                start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
-                angleSnap: angleLocked,
-                magnetic: isMagneticSnapActive(),
-            });
-            gridPosition = alignPoint(snapResult.point, { applySnap: !angleLocked });
-            // Stand the magnetic beacon at the endpoint when it locked onto an
-            // existing wall corner / wall point; clear it for plain grid/angle moves.
-            useWallSnapIndicator
-                .getState()
-                .set(snapResult.snap
-                ? { x: gridPosition[0], z: gridPosition[1], kind: snapResult.snap }
-                : null);
-            if (buildingState.current === 1) {
-                const snappedLocal = gridPosition;
-                const draftY = constructionPlane.current?.localY ?? event.localPosition[1];
-                endingPoint.current.set(snappedLocal[0], draftY, snappedLocal[1]);
-                const draftPreview = useFloorplanDraftPreview.getState();
-                draftPreview.setWallDraftStart([startingPoint.current.x, startingPoint.current.z]);
-                draftPreview.setWallDraftEnd(snappedLocal);
-                cursorRef.current.position.copy(endingPoint.current);
-                setAxisGuide({
-                    origin: [startingPoint.current.x, startingPoint.current.z],
-                    endOrigin: snappedLocal,
-                    y: startingPoint.current.y,
-                    angleLabel: getNearestAxisAngleLabel([startingPoint.current.x, startingPoint.current.z], snappedLocal, startingPoint.current.y),
+            // While a session is open, a split-view move forwarded by the plan was
+            // already snapped there; snapping it again here could pull the ray onto
+            // a nearby corner, so the 3D draft would drift from the plan's.
+            const typedFromFloorplan = buildingState.current === 1 &&
+                usePlacementTyping.getState().isActive &&
+                getGridEventScreenProjection(event) !== undefined;
+            // Everything here is building-local: the lattice, the 15° rays and the
+            // alignment axes all turn with a building the site planner turned.
+            if (typedFromFloorplan) {
+                gridPosition = localPoint;
+                useWallSnapIndicator.getState().set(null);
+            }
+            else if (buildingState.current === 1 && wallDraftIsRun()) {
+                // A started run holds square and shows its guides and snap marker.
+                const runSnap = snapRun(localPoint, event);
+                gridPosition = runSnap.point;
+                if (fromCanvas(event))
+                    publishWallRunFeedback(runSnap);
+            }
+            else {
+                // A Walls segment locks to 15° rays from its start.
+                const angleLocked = buildingState.current === 1 && isAngleSnapActive();
+                const snapResult = snapWallDraftPointDetailed({
+                    point: localPoint,
+                    walls: snapWalls,
+                    start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
+                    angleSnap: angleLocked,
+                    magnetic: isMagneticSnapActive(),
+                    captureWallBodies: true,
+                    bodyWalls,
                 });
-                const currentWallEnd = [snappedLocal[0], snappedLocal[1]];
-                if (previousWallEnd &&
-                    (currentWallEnd[0] !== previousWallEnd[0] || currentWallEnd[1] !== previousWallEnd[1])) {
-                    triggerSFX('sfx:grid-snap');
-                }
-                previousWallEnd = currentWallEnd;
-                updateWallPreview(wallPreviewRef.current, startingPoint.current, endingPoint.current, previewHeightRef.current, previewThicknessRef.current);
-                setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, walls, unit, metricNotation, startingPoint.current.y, previewHeightRef.current));
+                // A point locked onto a wall stays on it: alignment only shows its guides.
+                gridPosition = alignPoint(snapResult.point, {
+                    applySnap: !angleLocked && snapResult.snap === null,
+                });
+                // Stand the magnetic beacon at the endpoint when it locked onto an
+                // existing wall corner / wall point; clear it for plain grid/angle moves.
+                useWallSnapIndicator
+                    .getState()
+                    .set(snapResult.snap
+                    ? { x: gridPosition[0], z: gridPosition[1], kind: snapResult.snap }
+                    : null);
+            }
+            if (buildingState.current === 1) {
+                draftPointer = gridPosition;
+                draftY = constructionPlane.current?.localY ?? event.localPosition[1];
+                showDraftEnd(walls);
             }
             else {
                 const hoverPlane = resampleTerrainConstructionPlane(resolveEventConstructionPlane(event, pointed), gridPosition);
@@ -537,8 +664,7 @@ const LineWallTool = () => {
                 stopDrafting();
                 return;
             }
-            const walls = getCurrentLevelWalls();
-            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
+            const { walls, snapWalls, bodyWalls } = getWallDraftSnapWalls();
             const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null;
             const localClick = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
@@ -548,8 +674,12 @@ const LineWallTool = () => {
                     point: localClick,
                     walls: snapWalls,
                     magnetic: isMagneticSnapActive(),
+                    captureWallBodies: true,
+                    bodyWalls,
+                });
+                const snappedStart = alignPoint(snapResult.point, {
+                    applySnap: snapResult.snap === null,
                 });
-                const snappedStart = alignPoint(snapResult.point);
                 const resolvedPlane = (pointed?.sourceNodeId
                     ? resolveEventConstructionPlane(event, pointed)
                     : pointMatches(snappedStart, snapResult.point)
@@ -562,6 +692,7 @@ const LineWallTool = () => {
                 gridPosition = snappedStart;
                 startingPoint.current.set(snappedStart[0], plane.localY, snappedStart[1]);
                 chainFirstVertex.current = startingPoint.current.clone();
+                runReference = null;
                 endingPoint.current.copy(startingPoint.current);
                 buildingState.current = 1;
                 const draftPreview = useFloorplanDraftPreview.getState();
@@ -592,14 +723,25 @@ const LineWallTool = () => {
                 setDraftMeasurement(null);
             }
             else if (buildingState.current === 1) {
+                // An open session commits the endpoint its preview shows, re-derived
+                // from the pointer so keys typed since the last move count, and is
+                // never re-snapped.
+                const typedCommit = typedDraftEnd(draftPointer ?? localClick);
                 const angleLocked = isAngleSnapActive();
-                const snappedEnd = alignPoint(snapWallDraftPointDetailed({
-                    point: localClick,
-                    walls: snapWalls,
-                    start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
-                    angleSnap: angleLocked,
-                    magnetic: isMagneticSnapActive(),
-                }).point, { applySnap: !angleLocked });
+                const snappedEnd = typedCommit ??
+                    (wallDraftIsRun()
+                        ? snapRun(localClick, event).point
+                        : alignPoint(snapWallDraftPointDetailed({
+                            point: localClick,
+                            walls: snapWalls,
+                            start: angleLocked
+                                ? [startingPoint.current.x, startingPoint.current.z]
+                                : undefined,
+                            angleSnap: angleLocked,
+                            magnetic: isMagneticSnapActive(),
+                            captureWallBodies: true,
+                            bodyWalls,
+                        }).point, { applySnap: !angleLocked }));
                 const dx = snappedEnd[0] - startingPoint.current.x;
                 const dz = snappedEnd[1] - startingPoint.current.z;
                 if (dx * dx + dz * dz < 0.01 * 0.01)
@@ -613,6 +755,7 @@ const LineWallTool = () => {
                     // A Polygon room writes nothing until it completes: the corner joins
                     // the draft, and closing / sealing / teeing commits every wall at once.
                     const outcome = addWallPolygonDraftCorner(snappedEnd);
+                    usePlacementTyping.getState().clear();
                     useAlignmentGuides.getState().clear();
                     useWallSnapIndicator.getState().clear();
                     if (outcome !== 'open') {
@@ -620,29 +763,40 @@ const LineWallTool = () => {
                         stopDrafting();
                         return;
                     }
+                    runReference = wallRunDirection([startingPoint.current.x, startingPoint.current.z], snappedEnd);
                     nextStart = snappedEnd;
                 }
                 else {
                     const draftPlane = constructionPlane.current;
                     const commitPointed = draftPlane?.supportSlabId === GROUND_SUPPORT_ID ? null : pointedSurfaceFor(event);
                     // Both start and end are building-local ✓
-                    const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
-                        supportCap: commitPointed ? commitPointed.elevation : (draftPlane?.elevation ?? null),
-                        preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
-                        constructionElevation: draftPlane?.elevation ?? null,
-                        constructionHeight: previewHeightRef.current,
-                        constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
-                        flatConstructionBase: flatConstructionBase.current,
-                    });
+                    // The Walls variant's Invisible draws room separators, not walls.
+                    const createdWall = getWallLineKind() === 'invisible'
+                        ? createInvisibleWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd)
+                        : createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
+                            supportCap: commitPointed
+                                ? commitPointed.elevation
+                                : (draftPlane?.elevation ?? null),
+                            preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
+                            constructionElevation: draftPlane?.elevation ?? null,
+                            constructionHeight: previewHeightRef.current,
+                            constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
+                            flatConstructionBase: flatConstructionBase.current,
+                        });
                     if (!createdWall)
                         return;
                     chainWallIds.current.push(createdWall.id);
+                    // What was typed belongs to this segment; the next starts afresh.
+                    usePlacementTyping.getState().clear();
+                    // The run's next wall holds square to this one.
+                    runReference = wallRunDirection(createdWall.start, createdWall.end);
                     // The new segment is now a real node — make it an alignment target
                     // for the next segment, and drop the just-shown guide.
                     refreshAlignmentCandidates();
                     useAlignmentGuides.getState().clear();
                     useWallSnapIndicator.getState().clear();
-                    if (useEditor.getState().getContinuation('wall') === 'single') {
+                    // Walls draws one wall per two clicks.
+                    if (!wallDraftIsRun()) {
                         stopDrafting();
                         return;
                     }
@@ -659,7 +813,7 @@ const LineWallTool = () => {
                     const levelWalls = getCurrentLevelWalls();
                     if (closedToChainStart ||
                         chainEndJoinsExistingWall(createdWall.end, levelWalls, chainWallIds.current) ||
-                        wallClosesRoom(levelWalls, createdWall)) {
+                        (createdWall.type === 'wall' && wallClosesRoom(levelWalls, createdWall))) {
                         stopDrafting();
                         return;
                     }
@@ -695,19 +849,71 @@ const LineWallTool = () => {
         };
         const onCancel = () => {
             if (buildingState.current === 1) {
+                // A first cancel (Escape, ⌘Z, …) ends an open typed session; the next
+                // cancels the draft.
+                if (usePlacementTyping.getState().isActive) {
+                    markToolCancelConsumed();
+                    usePlacementTyping.getState().clear();
+                    return;
+                }
                 markToolCancelConsumed();
                 stopDrafting();
             }
         };
+        // Typed entry while a segment is drafted: a digit opens a session on the
+        // length, Tab one on the angle. In 2D-only view the plan commits walls, so
+        // its own key handler takes these.
+        const onKeyDown = (event) => {
+            if (buildingState.current !== 1 || planOwnsInput() || isTypingTarget(event.target))
+                return;
+            const outcome = routePlacementTypingKey(event, {
+                begin: (activeField) => {
+                    usePlacementTyping
+                        .getState()
+                        .begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE, activeField });
+                    return true;
+                },
+                tabBegins: true,
+            });
+            if (!outcome)
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            if (outcome !== 'commit')
+                return;
+            const [pointer, pointerY] = currentPointer();
+            const typedEnd = typedDraftEnd(pointer);
+            if (!typedEnd)
+                return;
+            onGridClick({
+                nativeEvent: { detail: 1 },
+                position: [typedEnd[0], pointerY, typedEnd[1]],
+                localPosition: [typedEnd[0], pointerY, typedEnd[1]],
+            });
+        };
+        const stopTypedPreview = usePlacementTyping.subscribe((state, previous) => {
+            if (buildingState.current !== 1)
+                return;
+            if (state.fields === previous.fields && state.isActive === previous.isActive)
+                return;
+            showDraftEnd(getWallDraftSnapWalls().walls);
+        });
         emitter.on('grid:move', onGridMove);
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown, true);
+        const stopPullSeeding = useWallPullRun.subscribe((state) => seedPull(state.run));
+        seedPull(useWallPullRun.getState().run);
         return () => {
             // Leaving the tool mid-polygon abandons it (nothing was written).
             discardWallPolygonDraft();
+            stopPullSeeding();
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown, true);
+            stopTypedPreview();
+            usePlacementTyping.getState().clear();
             clearPlacementSurface();
             useAlignmentGuides.getState().clear();
             useWallSnapIndicator.getState().clear();
@@ -717,7 +923,16 @@ const LineWallTool = () => {
             draftPreview.setWallDraftEnd(null);
         };
     }, [unit, metricNotation]);
-    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsx(PolygonDraftGhosts, { height: previewHeight, thickness: previewThickness, y: polygonGhostY }), _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)))] }))] }));
+    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsx(PolygonDraftGhosts, { height: previewHeight, thickness: previewThickness, y: polygonGhostY }), _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 })] }), typingActive && (draftMeasurement || axisGuide) ? (_jsx(LocalizedHtml, { center: true, position: draftMeasurement?.lengthPosition ?? [
+                    axisGuide.origin[0],
+                    axisGuide.y + previewHeight + DRAFT_LABEL_Y_OFFSET,
+                    axisGuide.origin[1],
+                ], style: { pointerEvents: 'auto', userSelect: 'none' }, zIndexRange: [200, 0], children: _jsx(PlacementCoordinateInput, { placeholders: [
+                        draftMeasurement?.lengthLabel ?? '',
+                        axisGuide?.endOrigin
+                            ? formatWallDraftHeading(axisGuide.origin, axisGuide.endOrigin)
+                            : '',
+                    ] }) })) : null, draftMeasurement && (_jsxs(_Fragment, { children: [typingActive ? null : (_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)))] }))] }));
 };
 /**
  * The placed sides of an open Polygon room, drawn like the live segment's

package/dist/wall/treatments.d.ts

@@ -7,6 +7,9 @@ type OpeningLike = {
     width?: number;
     height?: number;
     position?: [number, number, number];
+    casingFaceA?: boolean;
+    casingFaceB?: boolean;
+    casingWidth?: number;
 };
 type TrimKind = WallTrimKind;
 type WallSide = WallFace;

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

@@ -1 +1 @@
-{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,YAAY,CAAA;AAC5B,KAAK,QAAQ,GAAG,QAAQ,CAAA;AACxB,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GAAG,cAAc,CAAA;AAoMzC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAwND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FA2GlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCA+DC,CAAA"}
+{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,aAAa,EAClB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,KAAK,QAAQ,GAAG,YAAY,CAAA;AAC5B,KAAK,QAAQ,GAAG,QAAQ,CAAA;AACxB,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GAAG,cAAc,CAAA;AAoMzC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AA+PD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FA0HlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCA+DC,CAAA"}