@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/wall/measurement.js

@@ -1,8 +1,19 @@
 import { getWallArcData, getWallCurveFrameAt, getWallFaceOffsets, getWallLocalFaceZ, sampleWallCenterline, useScene, } from '@pascal-app/core';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 const point = (x, y, z) => [x, y, z];
+function getWallChordT(wall, worldX, worldZ) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const lenSq = dx * dx + dz * dz;
+    if (lenSq < 1e-8)
+        return 0.5;
+    const px = worldX - wall.start[0];
+    const pz = worldZ - wall.start[1];
+    return Math.max(0, Math.min(1, (px * dx + pz * dz) / lenSq));
+}
 export function wallMeasurementFeatures(wall) {
-    const height = resolveWallOpeningCeiling(wall, useScene.getState().nodes);
+    const nodes = useScene.getState().nodes;
+    const midHeight = resolveWallOpeningCeiling(wall, nodes, 0.5);
     const arc = getWallArcData(wall);
     const centerline = sampleWallCenterline(wall).map(({ x, y }) => point(x, 0, y));
     const midpoint = getWallCurveFrameAt(wall, 0.5).point;
@@ -77,7 +88,7 @@ export function wallMeasurementFeatures(wall) {
             geometry: {
                 kind: 'segment',
                 start: point(midpoint.x, 0, midpoint.y),
-                end: point(midpoint.x, height, midpoint.y),
+                end: point(midpoint.x, midHeight, midpoint.y),
             },
         },
         {
@@ -87,7 +98,11 @@ export function wallMeasurementFeatures(wall) {
             priority: 75,
             geometry: {
                 kind: 'path',
-                points: centerline.map(([x, , z]) => point(x, height, z)),
+                points: centerline.map(([x, , z]) => {
+                    const chordT = getWallChordT(wall, x, z);
+                    const h = resolveWallOpeningCeiling(wall, nodes, chordT);
+                    return point(x, h, z);
+                }),
             },
         },
     ];
@@ -145,7 +160,8 @@ export function matchWallMeasurementFeature(wall, hit, maxDistance) {
         const faceDistance = Math.hypot(hit[0] - faceX, hit[2] - faceZ);
         const threshold = Math.max(maxDistance, halfThickness + 0.03);
         if (faceDistance <= threshold && (!best || faceDistance < best.distance)) {
-            const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes), hit[1]));
+            const chordT = getWallChordT(wall, faceX, faceZ);
+            const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes, chordT), hit[1]));
             best = {
                 featureId: side > 0 ? 'wall:face:left' : 'wall:face:right',
                 point: point(faceX, height, faceZ),
@@ -175,7 +191,8 @@ export function resolveWallMeasurementFeature(wall, reference) {
     if (typeof heightValue !== 'number' || feature.geometry.kind !== 'path') {
         return normal ? { ...feature, normal } : feature;
     }
-    const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes), heightValue));
+    const chordT = getWallChordT(wall, frame.point.x, frame.point.y);
+    const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes, chordT), heightValue));
     return {
         ...feature,
         ...(normal ? { normal } : {}),

package/dist/wall/move-endpoint-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAcL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA4BzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AA6HD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CA8hBzE,CAAA;eAkBc,oBAAoB"}
+{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAeL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AA6HD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CA8hBzE,CAAA;eAkBc,oBAAoB"}

package/dist/wall/move-endpoint-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { acquireSceneHistoryPause, collectAlignmentAnchors, emitter, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, resolveAlignment, resolveMovedWallSupportSlabPatch, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, isTypingTarget, MeasurementPill, markToolCancelConsumed, resolveEndpointWallSplit, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useInteractionScope, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
+import { acquireSceneHistoryPause, collectAlignmentAnchors, emitter, formatAngleRadians, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, resolveAlignment, resolveMovedWallSupportSlabPatch, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { CursorSphere, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, isTypingTarget, MeasurementPill, markToolCancelConsumed, resolveEndpointWallSplit, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useInteractionScope, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useCallback, useEffect, useRef, useState } from 'react';
@@ -497,7 +497,7 @@ export const MoveWallEndpointTool = ({ target }) => {
         end: previewEnd,
         curveOffset: target.wall.curveOffset,
     });
-    const wallHeight = resolveWallOpeningCeiling(effectiveWall, nodes);
+    const wallHeight = resolveWallOpeningCeiling(effectiveWall, nodes, 0.5);
     const dimMidX = (previewStart[0] + previewEnd[0]) / 2;
     const dimMidZ = (previewStart[1] + previewEnd[1]) / 2;
     return (_jsx(LevelOffsetGroup, { children: _jsxs("group", { position: [0, wallBaseElevation, 0], children: [_jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, wallHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: wallHeight, length: liveLength, primary: "length", thickness: getWallThickness(effectiveWall), unit: unit }) }), canDetachCorner && (_jsx(Html, { position: [cursorLocalPos[0], 0, cursorLocalPos[2]], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed

package/dist/wall/move-shared.js

@@ -161,7 +161,7 @@ export function buildBridgeWallPreviews(args) {
             start: [...plan.originalPoint],
             end: [...nextPoint],
             color: getWallGhostColor(plan.wall),
-            height: resolveWallOpeningCeiling(plan.wall, useScene.getState().nodes),
+            height: resolveWallOpeningCeiling(plan.wall, useScene.getState().nodes, 0.5),
         };
         previews.push({ ghost, wall });
         wallsForDuplicateCheck.push(wall);

package/dist/wall/panel-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/wall/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EA0Bd,KAAK,0BAA0B,EAC/B,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAA;AAkB3B,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAqB9E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;kBAsB9E,kBAAkB;EAYnC;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,EAC1C,OAAO,GAAE,MAAM,IAId,GACA,QAAQ,EAAE,CAuMZ;AAED,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,0BAA0B,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQ7F,CAAA;AAEH,sEAAsE;AACtE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,0BAA0B,EAAE,MAAM,CAO9E,CAAA;AAiCD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,iBAAiB,EAAE,CAoF7F"}
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/wall/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EA2Bd,KAAK,0BAA0B,EAC/B,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAA;AAkB3B,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAqB9E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;kBAsB9E,kBAAkB;EAYnC;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,EAC1C,OAAO,GAAE,MAAM,IAId,GACA,QAAQ,EAAE,CAiNZ;AAED,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,0BAA0B,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQ7F,CAAA;AAEH,sEAAsE;AACtE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,0BAA0B,EAAE,MAAM,CAO9E,CAAA;AAiCD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,iBAAiB,EAAE,CAoF7F"}

package/dist/wall/panel-model.js

@@ -1,5 +1,5 @@
-import { BRICK_AIR_SPACE, BRICK_VENEER, DEFAULT_WALL_THICKNESS, FIBER_CEMENT, faceOnLine, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, justificationForFaceOnLine, normalizeWallCurveOffset, planWallJustification, projectWallTypes, roomSideFaces, runAsSingleSceneHistoryStep, SIDING_LAP, STONE_VENEER_UNVERIFIED, STUCCO_3_COAT, terrainSupportLift, useScene, WALL_ASSEMBLY_PRESETS, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, wallAssemblyFromLegacy, wallAssemblyPatch, wallAssemblyToLegacy, wallTrimPatch, } from '@pascal-app/core';
-import { curveReshapeScope, formatLinearMeasurement, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { BRICK_AIR_SPACE, BRICK_VENEER, DEFAULT_WALL_THICKNESS, FIBER_CEMENT, faceOnLine, formatLinearMeasurement, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, justificationForFaceOnLine, normalizeWallCurveOffset, planWallJustification, projectWallTypes, roomSideFaces, runAsSingleSceneHistoryStep, SIDING_LAP, STONE_VENEER_UNVERIFIED, STUCCO_3_COAT, terrainSupportLift, useScene, WALL_ASSEMBLY_PRESETS, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, wallAssemblyFromLegacy, wallAssemblyPatch, wallAssemblyToLegacy, wallTrimPatch, } from '@pascal-app/core';
+import { curveReshapeScope, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
@@ -79,7 +79,7 @@ export function wallSettings(node, nodes, update, reshape = () => {
     useViewer.getState().setSelection({ selectedIds: [] });
 }) {
     const rows = [];
-    const height = resolveWallOpeningCeiling(node, nodes);
+    const height = resolveWallOpeningCeiling(node, nodes, 0);
     const repairBase = () => ({
         supportOffset: undefined,
         ...(node.supportSlabId === GROUND_SUPPORT_ID &&
@@ -142,6 +142,7 @@ export function wallSettings(node, nodes, update, reshape = () => {
             choice('Dimensions', 'wall-height-auto', 'Current height', `${Number(height.toFixed(3))} m`);
         else
             number('Dimensions', 'height', 'Height', node.height, 0.1, 1000, 0.05, (height) => update({ height }));
+        number('Dimensions', 'end-height-offset', 'End height offset', node.endHeightOffset ?? 0, -(height - 0.01), Infinity, 0.05, (endHeightOffset) => update({ endHeightOffset }));
         choice('Dimensions', 'wall-bottom', 'Bottom', node.fillToTerrain ? 'Fill to terrain' : 'Auto', () => update(node.fillToTerrain
             ? { fillToTerrain: undefined, ...repairBase() }
             : { fillToTerrain: true }));

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAoJA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8bhC;AA4TD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;;;EAU5D"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAoJA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAsdhC;AA4TD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;;;EAU5D"}

package/dist/wall/panel.js

@@ -1,8 +1,8 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { assemblyThickness, FRAMING_SPACINGS, GROUND_SUPPORT_ID, GYPSUM_HALF, GYPSUM_SHEATHING, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallAssemblyPreset, getWallCurveLength, normalizeWallCurveOffset, resolveWallAssembly, runAsSingleSceneHistoryStep, terrainSupportLift, useLiveNodeOverrides, usePascalI18n, useScene, WALL_ASSEMBLY_PRESETS, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WSP_SHEATHING, wallAssemblyFromLegacy, wallAssemblyPatch, wallAssemblyToLegacy, wallAssemblyUnverifiedNote, wallTrimPatch, } from '@pascal-app/core';
+import { assemblyThickness, FRAMING_SPACINGS, formatLinearMeasurement, GROUND_SUPPORT_ID, GYPSUM_HALF, GYPSUM_SHEATHING, getClampedWallCurveOffset, getLinearUnitLabel, getMaxWallCurveOffset, getWallAssemblyPreset, getWallCurveLength, linearControlValueToMeters, metersToLinearUnit, normalizeWallCurveOffset, resolveWallAssembly, runAsSingleSceneHistoryStep, terrainSupportLift, useLiveNodeOverrides, usePascalI18n, useScene, WALL_ASSEMBLY_PRESETS, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WSP_SHEATHING, wallAssemblyFromLegacy, wallAssemblyPatch, wallAssemblyToLegacy, wallAssemblyUnverifiedNote, wallTrimPatch, } from '@pascal-app/core';
 import { setWallFaceScript } from '@pascal-app/core/agent-operations';
-import { ActionButton, ActionGroup, curveReshapeScope, finishScriptCode, formatLinearMeasurement, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, useProjectWallTypes, WallPaintRegionList, WallTypeMenu, } from '@pascal-app/editor';
+import { ActionButton, ActionGroup, curveReshapeScope, finishScriptCode, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, useProjectWallTypes, WallPaintRegionList, WallTypeMenu, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Spline } from 'lucide-react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
@@ -110,7 +110,7 @@ export default function WallPanel() {
         const wall = selectedId ? s.nodes[selectedId] : undefined;
         if (wall?.type !== 'wall')
             return undefined;
-        return resolveWallOpeningCeiling(wall, s.nodes);
+        return resolveWallOpeningCeiling(wall, s.nodes, 0);
     });
     const sceneNodes = useScene((s) => s.nodes);
     const reference = useMemo(() => (node ? wallReferenceModel([node], sceneNodes) : null), [node, sceneNodes]);
@@ -142,7 +142,7 @@ export default function WallPanel() {
         if (mode === 'custom' && !isCustom) {
             // Seed from the current effective height so the geometry doesn't
             // jump at the moment of detaching from the storey plane.
-            const seeded = resolveWallOpeningCeiling(n, useScene.getState().nodes);
+            const seeded = resolveWallOpeningCeiling(n, useScene.getState().nodes, 0);
             handleUpdate({ height: Math.max(0.1, seeded) });
         }
         else if (mode === 'storey' && isCustom) {
@@ -182,17 +182,19 @@ export default function WallPanel() {
     const followsTerrain = node.fillToTerrain === true;
     const isPlaneBound = node.height == null;
     const height = node.height ?? resolvedHeightMeters ?? 2.5;
+    const endHeightOffset = node.endHeightOffset ?? 0;
     const thickness = node.thickness ?? 0.1;
     const curveOffset = getClampedWallCurveOffset(node);
     const maxCurveOffset = getMaxWallCurveOffset(node);
     const unitLabel = getLinearUnitLabel(unit);
     const displayLength = metersToLinearUnit(length, unit);
     const displayHeight = metersToLinearUnit(height, unit);
+    const displayEndHeightOffset = metersToLinearUnit(endHeightOffset, unit);
     const displayThickness = metersToLinearUnit(thickness, unit);
     const displayCurveOffset = metersToLinearUnit(curveOffset, unit);
     const displayMaxCurveOffset = metersToLinearUnit(maxCurveOffset, unit);
     const curveOffsetLimit = Math.max(0.01, maxCurveOffset);
-    const wallHeightMeters = height;
+    const wallHeightMeters = resolvedHeightMeters ?? height;
     const skirting = { ...WALL_SKIRTING_DEFAULT, ...(node.skirting ?? {}) };
     const crown = { ...WALL_CROWN_DEFAULT, ...(node.crown ?? {}) };
     const chairRail = { ...WALL_CHAIR_RAIL_DEFAULT, ...(node.chairRail ?? {}) };
@@ -230,7 +232,14 @@ export default function WallPanel() {
                                         maxMeters: 1000,
                                         minMeters: 0.1,
                                     }),
-                                }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 })), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: i18n._({ id: 'node.wall.panel.bottom', message: 'Bottom' }) }), _jsx(SegmentedControl, { onChange: handleInfillChange, options: [
+                                }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 })), _jsx(SliderControl, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: i18n._({
+                                    id: 'node.wall.panel.endHeightOffset',
+                                    message: 'End height offset',
+                                }), min: metersToLinearUnit(-(wallHeightMeters - 0.01), unit), onChange: (v) => handlePreview({
+                                    endHeightOffset: linearControlValueToMeters(v, unit, {
+                                        minMeters: -(wallHeightMeters - 0.01),
+                                    }),
+                                }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayEndHeightOffset * 100) / 100 }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: i18n._({ id: 'node.wall.panel.bottom', message: 'Bottom' }) }), _jsx(SegmentedControl, { onChange: handleInfillChange, options: [
                                     { label: i18n._({ id: 'node.wall.panel.auto', message: 'Auto' }), value: 'auto' },
                                     {
                                         label: i18n._({

package/dist/wall/quick-measurement.js

@@ -2,7 +2,7 @@ import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, useScene, }
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 export function wallQuickMeasurement(node) {
     const length = getWallCurveLength(node);
-    const height = resolveWallOpeningCeiling(node, useScene.getState().nodes);
+    const height = resolveWallOpeningCeiling(node, useScene.getState().nodes, 0.5);
     const frame = getWallCurveFrameAt(node, 0.5);
     return {
         title: node.name ?? 'Wall',

package/dist/wall/rectangle-command.d.ts

@@ -238,6 +238,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     } | undefined;
     justification?: "a" | "b" | undefined;
     height?: number | undefined;
+    endHeightOffset?: number | undefined;
     curveOffset?: number | undefined;
     supportSlabId?: string | undefined;
     supportOffset?: number | undefined;

package/dist/wall/rectangle-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangle-command.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-command.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,CAAC,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlC"}
+{"version":3,"file":"rectangle-command.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-command.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,CAAC,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlC"}

package/dist/wall/rectangle-tool.js

@@ -1,7 +1,7 @@
 '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, useFloorplanDraftPreview, useInteractionScope, useLinearDisplay, useRegistryToolContext, useWallSnapIndicator, } from '@pascal-app/editor';
+import { emitter, formatLinearMeasurement, useScene, wallRectangleCorners, } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, isMagneticSnapActive, markToolCancelConsumed, NO_RAYCAST, publishHorizontalConstructionPlane, resolveEventConstructionPlane, snapWallDraftPointDetailed, triggerSFX, useEditor, useFloorplanDraftPreview, 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';

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

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

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

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, useScene, } from '@pascal-app/core';
-import { clientToPlan, FloorplanDraftMeasurement, formatLinearMeasurement, useFloorplanRender, } from '@pascal-app/editor';
+import { formatLinearMeasurement, getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, useScene, } from '@pascal-app/core';
+import { clientToPlan, FloorplanDraftMeasurement, useFloorplanRender, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useEffect } from 'react';
 import { bindWallSplitPointer } from './split-pointer.js';

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

@@ -1 +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"}
+{"version":3,"file":"split-tool.d.ts","sourceRoot":"","sources":["../../src/wall/split-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,kBAAkB,CAAA;AAezB;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,sCA8J9D"}

package/dist/wall/split-tool.js

@@ -1,7 +1,7 @@
 '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 { formatLinearMeasurement, getWallThickness, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, 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';

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAiBL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AA0czB;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,IAAI;IACvC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACtB,CAQA;AAyqBD,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAe5B,CAAA;eAEc,QAAQ"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAmBL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAmdzB;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,IAAI;IACvC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACtB,CAQA;AAkyBD,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAe5B,CAAA;eAEc,QAAQ"}

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, createInvisibleWallOnCurrentLevel, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, endWallPullRun, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getWallDrawVariant, getWallLineKind, invisibleWallDraftSnapLines, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isWallRunFree, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, publishWallRunFeedback, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, snapWallRunDraftPoint, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallDraftThickness, useWallDrawVariant, useWallPullRun, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallDraftIsRun, wallPolygonDraftWalls, wallRunDirection, } 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';
@@ -357,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);
@@ -468,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);
@@ -534,6 +537,45 @@ const LineWallTool = () => {
             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;
@@ -558,9 +600,19 @@ const LineWallTool = () => {
                 : [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.
+            // 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 (buildingState.current === 1 && wallDraftIsRun()) {
+            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;
@@ -592,27 +644,9 @@ const LineWallTool = () => {
                     : 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),
-                });
-                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));
+                draftPointer = gridPosition;
+                draftY = constructionPlane.current?.localY ?? event.localPosition[1];
+                showDraftEnd(walls);
             }
             else {
                 const hoverPlane = resampleTerrainConstructionPlane(resolveEventConstructionPlane(event, pointed), gridPosition);
@@ -689,18 +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 = 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 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)
@@ -714,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') {
@@ -744,6 +786,8 @@ const LineWallTool = () => {
                     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
@@ -805,13 +849,59 @@ 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 () => {
@@ -821,6 +911,9 @@ const LineWallTool = () => {
             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();
@@ -830,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.map

@@ -1 +1 @@
-{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAUL,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;AA2OD,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,2FAgHlC;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"}