@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/cabinet/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CabinetModuleNode, CabinetNode, collectAlignmentAnchors, createSceneApi, emitter, getFloorPlacedFootprints, getWallLocalFaceZ, isCurvedWall, movingAlignmentAnchors, nodeRegistry, resolveAlignment, resolveSupportSlabPatch, runAsSingleSceneHistoryStep, spatialGridManager, useScene, } from '@pascal-app/core';
-import { clearPlacementSurface, EDITOR_LAYER, getFloorStackPreviewPosition, getSideFromNormal, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, markToolCancelConsumed, movementSfxStepKey, PlacementBox, PlacementDimensionGuides, parseMeasurement, publishPlacementSurface, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
+import { CabinetModuleNode, CabinetNode, collectAlignmentAnchors, createSceneApi, emitter, getFloorPlacedFootprints, getWallLocalFaceZ, isCurvedWall, movingAlignmentAnchors, nodeRegistry, resolveAlignment, resolveSupportSlabPatch, runAsSingleSceneHistoryStep, spatialGridManager, useLocale, useScene, } from '@pascal-app/core';
+import { clearPlacementSurface, EDITOR_LAYER, formatLinearMeasurement, getFloorStackPreviewPosition, getSideFromNormal, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, LocalizedHtml, markToolCancelConsumed, movementSfxStepKey, PLACEMENT_TYPING_DISTANCE_OFFSET, PlacementBox, PlacementCoordinateInput, PlacementDimensionGuides, parseMeasurement, placementTypingLengthOptions, publishPlacementSurface, routePlacementTypingKey, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, usePlacementTyping, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useFrame } from '@react-three/fiber';
@@ -12,10 +12,11 @@ import { LevelOffsetGroup } from '../shared/level-offset-group.js';
 import { findWallOpeningConflicts } from '../shared/wall-opening-clearance.js';
 import { cabinetStretchExitSide, chooseCabinetContinuousAnchor, createCabinetContinuousContinuation, isCabinetContinuousFollowUpClick, isForcePlacementEvent, planCabinetContinuousStretch, resolveCabinetContinuousValidity, } from './continuous-placement.js';
 import { bumpCabinetRunsNear, cabinetDefinition, cabinetModuleDefinition, cabinetRunFootprint, } from './definition.js';
+import { parseCabinetDimensionInput } from './dimension-input.js';
 import { buildCabinetGeometry } from './geometry.js';
 import { applyCabinetModuleInsertion, cabinetModuleForRunInsertion } from './insertion.js';
 import { resolveCabinetNeighborPlacement } from './neighbor-placement.js';
-import { buildCabinetPlacementSizeDimensions, resolveCabinetPlacementDimensionPosition, resolveCabinetPlacementDimensions, } from './placement-dimensions.js';
+import { buildCabinetPlacementSizeDimensions, getCabinetPlacementCoordinates, resolveCabinetPlacementDimensionPosition, resolveCabinetPlacementDimensions, resolveCabinetTypedPlacementPosition, } from './placement-dimensions.js';
 import { resolveCabinetGridPosition, resolveCabinetGridPositionInFrame, resolveCabinetLevelPlanFrame, } from './placement-snap.js';
 import useCabinetPlacementStatus from './placement-status.js';
 import useCabinetPlacementType from './placement-type.js';
@@ -196,8 +197,11 @@ const CabinetPlacementTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
     const unit = useViewer((s) => s.unit);
     const metricNotation = useViewer((s) => s.metricNotation);
+    const locale = useLocale();
     const activeDimensionId = usePlacementPreview((s) => s.activeDimensionId);
     const dimensionInput = usePlacementPreview((s) => s.dimensionInput);
+    const typingActive = usePlacementTyping((s) => s.isActive);
+    const typingProjectedPosition = usePlacementTyping((s) => s.projectedPosition);
     const [placement, setPlacement] = useState(null);
     const [draftSegments, setDraftSegments] = useState([]);
     const [yaw, setYaw] = useState(0);
@@ -218,6 +222,13 @@ const CabinetPlacementTool = () => {
     const previousTickFrameRef = useRef(-1);
     const draftAnchorRef = useRef(null);
     const lastRawPositionRef = useRef(null);
+    const typedWallHitRef = useRef(null);
+    const typedCoordinateDefaultsRef = useRef(null);
+    // Set while a code path intentionally ends the session *and* owns the
+    // placement afterwards (canvas-click commit, island toggle) so the
+    // restore-on-cancel logic stays out of the way.
+    const suppressTypedRestoreRef = useRef(false);
+    const lastPlacementEventRef = useRef(null);
     const activeGhostRef = useRef(null);
     const surfacePointRef = useRef(new Vector3());
     const surfaceNormalRef = useRef(new Vector3(0, 1, 0));
@@ -397,6 +408,9 @@ const CabinetPlacementTool = () => {
                 levelId: activeLevelId,
                 nodes: useScene.getState().nodes,
                 position: previewPosition,
+                providedWallHit: typedWallHitRef.current && next.wallLocalX != null
+                    ? { ...typedWallHitRef.current, localX: next.wallLocalX }
+                    : undefined,
                 rotation: next.yaw,
                 wallId: next.wallId,
                 width: stretch?.length ?? livePreviewNode.width,
@@ -466,6 +480,10 @@ const CabinetPlacementTool = () => {
         previousWasWallSnapRef.current = false;
         previousTickFrameRef.current = -1;
         draftAnchorRef.current = null;
+        typedWallHitRef.current = null;
+        typedCoordinateDefaultsRef.current = null;
+        lastPlacementEventRef.current = null;
+        usePlacementTyping.getState().clear();
         let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNodeRef.current.id, activeLevelId);
         let lastWallEventTime = -1;
         let wallOwnedPointerAt = Number.NEGATIVE_INFINITY;
@@ -501,6 +519,15 @@ const CabinetPlacementTool = () => {
             if (hasContinuousDraft)
                 clearDraft();
             islandModeRef.current = nextIslandMode;
+            // Island mode has no wall snapping, so a live typed session would be
+            // orphaned (frozen pointer + vanished HUD). End it — the toggle owns
+            // the placement afterwards, so suppress the pose restore.
+            if (nextIslandMode && usePlacementTyping.getState().isActive) {
+                suppressTypedRestoreRef.current = true;
+                usePlacementTyping.getState().clear();
+                typedWallHitRef.current = null;
+                typedCoordinateDefaultsRef.current = null;
+            }
             if (hasContinuousDraft)
                 return;
             // Drop a stale wall-snapped preview so the next move re-resolves free.
@@ -790,9 +817,12 @@ const CabinetPlacementTool = () => {
         };
         // While stretching, the run is pinned at the anchored first module and
         // grows toward the cursor — the far end tracks the pointer smoothly.
-        const resolveStretchedPlacement = (anchor, event) => {
+        const resolveStretchedPlacement = (anchor, event, rawOverride) => {
             useAlignmentGuides.getState().clear();
-            const raw = resolveRawPosition(event);
+            // `rawOverride` lets callers seed the stretch geometry directly (typed
+            // entry commits at the typed pose — the reused pointer event's cursor
+            // position is stale and must not grow the run).
+            const raw = rawOverride ?? resolveRawPosition(event);
             let stretch = planCabinetContinuousStretch({
                 anchor,
                 previewWidth: previewNodeRef.current.width,
@@ -885,6 +915,9 @@ const CabinetPlacementTool = () => {
             const ts = event.nativeEvent?.timeStamp ?? -1;
             if (ts === lastWallEventTime || wallOwnsPointer())
                 return;
+            if (usePlacementTyping.getState().isActive)
+                return;
+            lastPlacementEventRef.current = event;
             const anchor = resolveDraftAnchor();
             if (anchor) {
                 publishPlacement(resolveActiveStretchPlacement(anchor, event), ts);
@@ -896,6 +929,11 @@ const CabinetPlacementTool = () => {
             lastWallEventTime = event.nativeEvent?.timeStamp ?? -1;
             if (event.node.parentId !== activeLevelId)
                 return;
+            if (usePlacementTyping.getState().isActive) {
+                event.stopPropagation();
+                return;
+            }
+            lastPlacementEventRef.current = event;
             const anchor = resolveDraftAnchor();
             if (anchor) {
                 markWallOwnedPointer();
@@ -1158,24 +1196,27 @@ const CabinetPlacementTool = () => {
             clearDraft();
             stopPlacementCommitPropagation(event);
         };
-        const onClick = (event) => {
+        // Returns true when a cabinet (or insertion) was actually committed —
+        // `fromTypedCommit` marks the synthetic Enter-commit call, which manages
+        // the typing session itself in its caller.
+        const onClickInner = (event, fromTypedCommit = false, rawOverride) => {
             const anchor = resolveDraftAnchor();
             if (anchor) {
                 const detail = event.nativeEvent?.detail ?? 1;
                 if (isCabinetContinuousFollowUpClick(detail)) {
                     clearDraft();
                     stopPlacementCommitPropagation(event);
-                    return;
+                    return false;
                 }
                 const segment = resolveCurrentDraftSegment(anchor, event);
                 if (!segment) {
                     stopPlacementCommitPropagation(event);
-                    return;
+                    return false;
                 }
                 const committed = commitDraftSegment(segment);
                 if (!committed) {
                     stopPlacementCommitPropagation(event);
-                    return;
+                    return false;
                 }
                 chainRootRunRef.current ??= committed.run;
                 chainRunRef.current = committed.run;
@@ -1190,20 +1231,20 @@ const CabinetPlacementTool = () => {
                 publishPlacement(resolveActiveStretchPlacement(draftAnchorRef.current, event));
                 triggerSFX('sfx:item-place');
                 stopPlacementCommitPropagation(event);
-                return;
+                return true;
             }
             const next = isForcePlacementEvent(event)
                 ? resolvePlacement(event)
                 : (placementRef.current ?? resolvePlacement(event));
             if (!next.valid) {
                 stopPlacementCommitPropagation(event);
-                return;
+                return false;
             }
             if (next.insertionPreview) {
                 const insertedId = commitInsertion(next);
                 if (!insertedId) {
                     stopPlacementCommitPropagation(event);
-                    return;
+                    return false;
                 }
                 useViewer.getState().setSelection({ selectedIds: [insertedId] });
                 useEditor.getState().setMode('select');
@@ -1213,7 +1254,7 @@ const CabinetPlacementTool = () => {
                 clearPlacementSurface();
                 useFacingPose.getState().clear();
                 stopPlacementCommitPropagation(event);
-                return;
+                return true;
             }
             if (useEditor.getState().getContinuation('cabinet') === 'continuous') {
                 draftSegmentsRef.current = [];
@@ -1230,10 +1271,15 @@ const CabinetPlacementTool = () => {
                     wallLocalX: next.wallLocalX,
                     wallSurfaceNormal: next.wallSurfaceNormal,
                 };
-                publishPlacement(resolveStretchedPlacement(draftAnchorRef.current, event));
+                // Typed entry commits at the typed pose: seed the stretch preview
+                // there (zero-length) instead of growing toward the stale cursor
+                // position carried by the reused pointer event.
+                publishPlacement(rawOverride
+                    ? resolveStretchedPlacement(draftAnchorRef.current, event, rawOverride)
+                    : resolveStretchedPlacement(draftAnchorRef.current, event));
                 triggerSFX('sfx:item-pick');
                 stopPlacementCommitPropagation(event);
-                return;
+                return true;
             }
             const { cabinet, buildModule } = buildRunNodes(next.position, next.yaw);
             const module = buildModule(0, previewNodeRef.current.width, 0);
@@ -1252,19 +1298,200 @@ const CabinetPlacementTool = () => {
             triggerSFX('sfx:item-place');
             useAlignmentGuides.getState().clear();
             usePlacementPreview.getState().clear();
+            usePlacementTyping.getState().clear();
+            typedWallHitRef.current = null;
+            typedCoordinateDefaultsRef.current = null;
             clearPlacementSurface();
             useFacingPose.getState().clear();
             stopPlacementCommitPropagation(event);
+            return true;
+        };
+        // Canvas clicks land here. A click during typed entry commits the typed
+        // preview (what the user sees); the session is only ended when the
+        // commit actually succeeds — an invalid typed pose keeps the session
+        // alive so the values can still be edited.
+        const onClick = (event, fromTypedCommit = false, rawOverride) => {
+            const typingActive = !fromTypedCommit && usePlacementTyping.getState().isActive;
+            const committed = onClickInner(event, fromTypedCommit, rawOverride);
+            if (typingActive && committed) {
+                suppressTypedRestoreRef.current = true;
+                usePlacementTyping.getState().clear();
+                typedWallHitRef.current = null;
+                typedCoordinateDefaultsRef.current = null;
+            }
+            return committed;
+        };
+        const applyTypedPlacement = () => {
+            const typing = usePlacementTyping.getState();
+            const current = placementRef.current;
+            const hit = typedWallHitRef.current;
+            const defaults = typedCoordinateDefaultsRef.current;
+            if (!typing.isActive || !current || !hit || !defaults || current.stretch)
+                return false;
+            const lengthOptions = placementTypingLengthOptions(unit, metricNotation);
+            const parseTypedValue = (raw, fallback) => raw.trim()
+                ? parseMeasurement(raw, { kind: 'length', unitId: 'm' }, lengthOptions)
+                : fallback;
+            const distance = parseTypedValue(typing.fields[0], defaults[0]);
+            const offset = parseTypedValue(typing.fields[1], defaults[1]);
+            if (distance == null || offset == null)
+                return false;
+            const resolved = resolveCabinetTypedPlacementPosition({
+                depth: previewNodeRef.current.depth,
+                distance,
+                hit,
+                levelId: activeLevelId,
+                nodes: useScene.getState().nodes,
+                offset,
+                position: current.position,
+                width: previewNodeRef.current.width,
+            });
+            if (!resolved)
+                return false;
+            // Typed entry targets an exact wall position. Drop any run-insertion
+            // preview captured by the pointer path — otherwise Enter re-enters the
+            // `onClick` insertion branch and commits the original run slot instead
+            // of the typed coordinates.
+            const { conflictIds: _conflictIds, insertionFailure: _insertionFailure, insertionPreview: _insertionPreview, valid: _valid, ...placementBase } = current;
+            const next = withPlacementValidity({
+                ...placementBase,
+                position: resolved.position,
+                wallLocalX: resolved.wallLocalX,
+                yaw: resolved.yaw,
+                wallSurfaceNormal: [Math.sin(resolved.yaw), 0, Math.cos(resolved.yaw)],
+                snappedToWall: true,
+            }, false);
+            placementRef.current = next;
+            setPlacement(next);
+            usePlacementTyping.getState().setProjectedPosition(next.position);
+            publishFloorplanPreview(next);
+            return true;
+        };
+        const beginTypedPlacement = (activeField) => {
+            const current = placementRef.current;
+            if (!current || current.stretch || !current.snappedToWall || !current.wallId)
+                return false;
+            const nodes = useScene.getState().nodes;
+            const excludedWallIds = Object.values(nodes)
+                .filter((node) => node.type === 'wall' && node.id !== current.wallId)
+                .map((node) => node.id);
+            const hit = findClosestCabinetWallInPlan({
+                excludeIds: excludedWallIds,
+                // The placement already knows its wall; a typed perpendicular offset
+                // can push the cabinet center beyond the normal snap distance, so
+                // don't cap the projection — just make sure the closest wall is the
+                // one we're attached to.
+                maxDistance: Infinity,
+                nodes,
+                parentLevelId: activeLevelId,
+                planPoint: [current.position[0], current.position[2]],
+            });
+            if (!hit || hit.wall.id !== current.wallId)
+                return false;
+            const coordinates = getCabinetPlacementCoordinates({
+                depth: previewNodeRef.current.depth,
+                hit,
+                levelId: activeLevelId,
+                nodes,
+                position: current.position,
+                width: previewNodeRef.current.width,
+            });
+            typedWallHitRef.current = hit;
+            typedCoordinateDefaultsRef.current = [coordinates.distance, coordinates.offset];
+            suppressTypedRestoreRef.current = false;
+            usePlacementTyping.getState().begin({
+                labels: PLACEMENT_TYPING_DISTANCE_OFFSET,
+                fieldDefaults: [
+                    formatLinearMeasurement(coordinates.distance, unit, metricNotation),
+                    formatLinearMeasurement(coordinates.offset, unit, metricNotation),
+                ],
+                activeField,
+            });
+            return true;
         };
+        let handledSubmitRevision = usePlacementTyping.getState().submitRevision;
+        let previousTypingFields = usePlacementTyping.getState().fields;
+        let previousTypingField = usePlacementTyping.getState().activeField;
+        let previousTypingActive = usePlacementTyping.getState().isActive;
+        const unsubscribePlacementTyping = usePlacementTyping.subscribe((state) => {
+            const fieldsChanged = state.fields[0] !== previousTypingFields[0] || state.fields[1] !== previousTypingFields[1];
+            const activeFieldChanged = state.activeField !== previousTypingField;
+            const becameActive = state.isActive && !previousTypingActive;
+            const becameInactive = !state.isActive && previousTypingActive;
+            previousTypingFields = state.fields;
+            previousTypingField = state.activeField;
+            previousTypingActive = state.isActive;
+            if (state.isActive && (fieldsChanged || activeFieldChanged || becameActive)) {
+                applyTypedPlacement();
+            }
+            // Any exit path (Escape in the HUD input, tool cancel, commit) must
+            // drop the frozen wall hit — otherwise pointer moves keep feeding it
+            // into `publishFloorplanPreview`. An uncommitted exit re-resolves
+            // placement from the last pointer event so `placementRef` does not
+            // stay stuck at the cancelled typed pose.
+            if (becameInactive) {
+                typedWallHitRef.current = null;
+                typedCoordinateDefaultsRef.current = null;
+                if (!suppressTypedRestoreRef.current && lastPlacementEventRef.current) {
+                    const event = lastPlacementEventRef.current;
+                    const anchor = resolveDraftAnchor();
+                    const next = anchor
+                        ? resolveActiveStretchPlacement(anchor, event)
+                        : resolvePlacement(event);
+                    publishPlacement(next);
+                }
+                suppressTypedRestoreRef.current = false;
+            }
+            if (state.submitRevision === handledSubmitRevision)
+                return;
+            handledSubmitRevision = state.submitRevision;
+            if (!applyTypedPlacement())
+                return;
+            // Typed commits must honor the typed pose. Reusing the last pointer
+            // event in continuous mode would replay a stale `altKey` into
+            // `isForcePlacementEvent` and re-resolve placement from the old
+            // cursor hit instead of the typed distance/offset. `node` is also
+            // stripped: `stopPlacementCommitPropagation` installs a 300ms
+            // window click swallow for real wall hits, which would eat the
+            // user's next real click after this keyboard commit.
+            const baseCommitEvent = useEditor.getState().getContinuation('cabinet') === 'continuous'
+                ? (lastPlacementEventRef.current ??
+                    { nativeEvent: {} })
+                : { nativeEvent: {} };
+            const { node: _node, ...baseEventWithoutNode } = baseCommitEvent;
+            const commitEvent = {
+                ...baseEventWithoutNode,
+                nativeEvent: { ...(baseCommitEvent.nativeEvent ?? {}), altKey: false },
+            };
+            // Seed any continuous-mode stretch at the typed position (zero-length
+            // span), not the stale cursor carried by the reused pointer event.
+            // Restore is suppressed: a successful commit owns the placement, and
+            // `onClick`'s internal `clear()` would otherwise re-trigger the
+            // restore logic below and revert the fresh stretch anchor.
+            const typedPosition = placementRef.current?.position;
+            suppressTypedRestoreRef.current = true;
+            const committed = onClick(commitEvent, true, typedPosition);
+            // Keep the typed values when the pose was rejected (e.g. collision)
+            // so Enter does not silently wipe the session — the user can adjust
+            // distance/offset and retry.
+            if (!committed) {
+                suppressTypedRestoreRef.current = false;
+                return;
+            }
+            typedWallHitRef.current = null;
+            typedCoordinateDefaultsRef.current = null;
+            usePlacementTyping.getState().clear();
+        });
         const applyTypedDimension = () => {
             const editor = usePlacementPreview.getState();
             const current = placementRef.current;
             if (!(editor.activeDimensionId && editor.dimensionInput && current)) {
                 return false;
             }
-            const value = parseMeasurement(editor.dimensionInput, { kind: 'length', unitId: 'm' }, {
-                bareUnit: unit === 'imperial' ? 'in' : metricNotation === 'millimeters' ? 'mm' : 'm',
-                system: unit === 'imperial' ? 'imperial' : 'metric',
+            const value = parseCabinetDimensionInput(editor.dimensionInput, {
+                locale,
+                metricNotation,
+                unit,
             });
             if (value === null)
                 return false;
@@ -1389,6 +1616,20 @@ const CabinetPlacementTool = () => {
             if (isTypingTarget(event.target))
                 return;
             const dimensionEditor = usePlacementPreview.getState();
+            const typingOutcome = routePlacementTypingKey(event, {
+                begin: (field) => !dimensionEditor.activeDimensionId && beginTypedPlacement(field),
+            });
+            if (typingOutcome) {
+                if (typingOutcome === 'commit')
+                    usePlacementTyping.getState().requestCommit();
+                if (typingOutcome === 'clear') {
+                    typedWallHitRef.current = null;
+                    typedCoordinateDefaultsRef.current = null;
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
             if (event.key === 'Tab' && dimensionEditor.dimensions.length > 0) {
                 const currentIndex = dimensionEditor.dimensions.findIndex((dimension) => dimension.id === dimensionEditor.activeDimensionId);
                 const direction = event.shiftKey ? -1 : 1;
@@ -1464,6 +1705,13 @@ const CabinetPlacementTool = () => {
             triggerSFX('sfx:item-rotate');
         };
         const onCancel = () => {
+            if (usePlacementTyping.getState().isActive) {
+                markToolCancelConsumed();
+                usePlacementTyping.getState().clear();
+                typedWallHitRef.current = null;
+                typedCoordinateDefaultsRef.current = null;
+                return;
+            }
             if (!draftAnchorRef.current)
                 return;
             markToolCancelConsumed();
@@ -1483,11 +1731,15 @@ const CabinetPlacementTool = () => {
             emitter.off('wall:move', onWallMove);
             emitter.off('tool:cancel', onCancel);
             unsubscribeCabinetPlacementType();
+            unsubscribePlacementTyping();
             unsubscribePlacementClicks();
             unsubscribePlacementDoubleClicks();
             window.removeEventListener('keydown', onKeyDown, true);
             draftAnchorRef.current = null;
             usePlacementPreview.getState().clear();
+            usePlacementTyping.getState().clear();
+            typedWallHitRef.current = null;
+            typedCoordinateDefaultsRef.current = null;
             clearPlacementSurface();
             useFacingPose.getState().clear();
             useAlignmentGuides.getState().clear();
@@ -1564,7 +1816,11 @@ const CabinetPlacementTool = () => {
                         previewNode.width,
                         previewNode.carcassHeight,
                         placement.neighborJoin?.depth ?? previewNode.depth,
-                    ], onDimensionSelect: stretch ? undefined : (id) => usePlacementPreview.getState().selectDimension(id), position: placementBoxPosition, rotationY: placementRotationY, valid: placement.valid }), _jsx(PlacementDimensionGuides, {}), draftSegments.map((segment, segmentIndex) => (_jsx("group", { position: segment.anchor.position, rotation: [0, segment.anchor.yaw, 0], children: segment.stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(draftModuleOffsets[segmentIndex] + index) }) }, `${segmentIndex}-${index}`))) }, `draft-${segmentIndex}`))), _jsx("group", { position: visualPosition, ref: activeGhostRef, rotation: [0, placementRotationY, 0], children: placement.insertionPreview ? (_jsx("group", { scale: [1, 1, (placement.neighborJoin?.depth ?? previewNode.depth) / previewNode.depth], children: _jsx("primitive", { object: insertionGhost }) })) : stretch ? (stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(activeStretchGhostOffset + index) }) }, index)))) : (_jsx("primitive", { object: ghost })) }), placement.insertionPreview && !placement.neighborJoin ? (_jsx("group", { position: placement.insertionPreview.runPosition, rotation: [0, placement.insertionPreview.runYaw, 0], children: placement.insertionPreview.modules.map((module, index) => (_jsx("group", { position: module.position, scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: insertionGhostForIndex(index + 1) }) }, module.id))) })) : null, placementLabel ? (_jsx(Html, { center: true, position: [
+                    ], onDimensionSelect: stretch ? undefined : (id) => usePlacementPreview.getState().selectDimension(id), position: placementBoxPosition, rotationY: placementRotationY, valid: placement.valid }), _jsx(PlacementDimensionGuides, {}), draftSegments.map((segment, segmentIndex) => (_jsx("group", { position: segment.anchor.position, rotation: [0, segment.anchor.yaw, 0], children: segment.stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(draftModuleOffsets[segmentIndex] + index) }) }, `${segmentIndex}-${index}`))) }, `draft-${segmentIndex}`))), _jsx("group", { position: visualPosition, ref: activeGhostRef, rotation: [0, placementRotationY, 0], children: placement.insertionPreview ? (_jsx("group", { scale: [1, 1, (placement.neighborJoin?.depth ?? previewNode.depth) / previewNode.depth], children: _jsx("primitive", { object: insertionGhost }) })) : stretch ? (stretch.modules.map((module, index) => (_jsx("group", { position: [module.x, 0, 0], scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: ghostForIndex(activeStretchGhostOffset + index) }) }, index)))) : (_jsx("primitive", { object: ghost })) }), placement.insertionPreview && !placement.neighborJoin ? (_jsx("group", { position: placement.insertionPreview.runPosition, rotation: [0, placement.insertionPreview.runYaw, 0], children: placement.insertionPreview.modules.map((module, index) => (_jsx("group", { position: module.position, scale: [module.width / previewNode.width, 1, 1], children: _jsx("primitive", { object: insertionGhostForIndex(index + 1) }) }, module.id))) })) : null, typingActive && !stretch && placement.snappedToWall ? (_jsx(LocalizedHtml, { center: true, position: [
+                    typingProjectedPosition?.[0] ?? placement.position[0],
+                    visualPosition[1] + previewNode.carcassHeight + 0.45,
+                    typingProjectedPosition?.[2] ?? placement.position[2],
+                ], style: { pointerEvents: 'auto', userSelect: 'none' }, zIndexRange: [200, 0], children: _jsx(PlacementCoordinateInput, {}) })) : null, placementLabel ? (_jsx(Html, { center: true, position: [
                     labelPosition[0],
                     previewNode.plinthHeight + previewNode.carcassHeight + 0.35,
                     labelPosition[2],

package/dist/cabinet/wall-snap.d.ts

@@ -19,9 +19,13 @@ export type CabinetRunWallSnapPose = {
     position: [number, number, number];
     rotation: number;
 };
-export declare function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw, nodes, parentLevelId, planPoint, yaw, }: {
+export declare function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw, maxDistance, nodes, parentLevelId, planPoint, yaw, }: {
     excludeIds: readonly AnyNodeId[];
     fallbackToAnyYaw?: boolean;
+    /** Override the snap-distance cap — pass `Infinity` when the wall is
+     *  already known and only the projection onto it is needed (e.g. typed
+     *  entry re-entering a session at a large perpendicular offset). */
+    maxDistance?: number;
     nodes: Record<AnyNodeId, AnyNode>;
     parentLevelId: AnyNodeId;
     planPoint: readonly [number, number];

package/dist/cabinet/wall-snap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-snap.d.ts","sourceRoot":"","sources":["../../src/cabinet/wall-snap.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wall-snap.d.ts","sourceRoot":"","sources":["../../src/cabinet/wall-snap.ts"],"names":[],"mappings":"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"}

package/dist/cabinet/wall-snap.js

@@ -99,7 +99,7 @@ function closestStraightWallPoint(wall, planPoint) {
         distance: Math.hypot(planPoint[0] - closestX, planPoint[1] - closestZ),
     };
 }
-export function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw = false, nodes, parentLevelId, planPoint, yaw, }) {
+export function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw = false, maxDistance = WALL_SNAP_DISTANCE_M, nodes, parentLevelId, planPoint, yaw, }) {
     const excluded = new Set(excludeIds);
     let bestAny;
     let bestCompatible;
@@ -112,7 +112,7 @@ export function findClosestCabinetWallInPlan({ excludeIds, fallbackToAnyYaw = fa
         const closest = isCurvedWall(wall)
             ? closestCurvedWallPoint(wall, planPoint)
             : closestStraightWallPoint(wall, planPoint);
-        if (!closest || closest.distance > WALL_SNAP_DISTANCE_M)
+        if (!closest || closest.distance > maxDistance)
             continue;
         const side = closest.perpDistance >= 0 ? 'front' : 'back';
         const candidate = {

package/dist/ceiling/build-up-section.d.ts

@@ -0,0 +1,7 @@
+import { type CeilingNode } from '@pascal-app/core';
+export declare function CeilingBuildUpSection({ node, onUpdate, unit, }: {
+    node: CeilingNode;
+    onUpdate: (patch: Partial<CeilingNode>) => void;
+    unit: 'metric' | 'imperial';
+}): import("react").JSX.Element;
+//# sourceMappingURL=build-up-section.d.ts.map

package/dist/ceiling/build-up-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-up-section.d.ts","sourceRoot":"","sources":["../../src/ceiling/build-up-section.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AA8CzB,wBAAgB,qBAAqB,CAAC,EACpC,IAAI,EACJ,QAAQ,EACR,IAAI,GACL,EAAE;IACD,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,CAAA;IAC/C,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;CAC5B,+BAqFA"}

package/dist/ceiling/build-up-section.js

@@ -0,0 +1,57 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ceilingBuildUpThickness, LUMBER_DEPTH, usePascalI18n, } from '@pascal-app/core';
+import { PanelSection, SelectControl } from '@pascal-app/editor';
+import { BuildUpReadout, editedBuildUp, FinishFields, FramingSizeFields, InsulationFields, NONE, PanelFields, } from '../shared/build-up-controls.js';
+import { formatLayerDepth } from '../shared/layer-thickness.js';
+import { ceilingBuildUpPresetOptions, ceilingBuildUpPresetPatch, ceilingBuildUpPresetValue, } from './panel-model.js';
+const INCH = 0.0254;
+const FRAMING_OPTIONS = [
+    { label: /* i18n */ { id: 'node.ceiling.buildUpSection.none', message: 'None' }, value: NONE },
+    {
+        label: /* i18n */ {
+            id: 'node.ceiling.buildUpSection.ceilingJoists',
+            message: 'Ceiling joists',
+        },
+        value: 'joists',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.ceiling.buildUpSection.trussBottomChords',
+            message: 'Truss bottom chords',
+        },
+        value: 'truss-chords',
+    },
+];
+const NEW_FRAMING = {
+    joists: { system: 'joists', size: '2x6', spacing: 16 * INCH },
+    'truss-chords': { system: 'truss-chords', size: '2x4', spacing: 24 * INCH },
+};
+export function CeilingBuildUpSection({ node, onUpdate, unit, }) {
+    const i18n = usePascalI18n();
+    const buildUp = node.buildUp;
+    const edit = (change) => {
+        if (buildUp)
+            onUpdate({ buildUp: editedBuildUp(buildUp, change) });
+    };
+    const framing = buildUp?.framing;
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.ceiling.buildUpSection.layers', message: 'Layers' }), children: [_jsx(SelectControl, { label: i18n._({ id: 'node.ceiling.buildUpSection.preset', message: 'Preset' }), onChange: (id) => {
+                    const patch = ceilingBuildUpPresetPatch(id);
+                    if (patch)
+                        onUpdate(patch);
+                }, options: ceilingBuildUpPresetOptions(ceilingBuildUpPresetValue(buildUp)), value: ceilingBuildUpPresetValue(buildUp) }), buildUp && (_jsxs(_Fragment, { children: [_jsx(FinishFields, { label: i18n._({ id: 'node.ceiling.buildUpSection.finish', message: 'Finish' }), layer: buildUp.finish, onChange: (finish) => edit({ finish }), unit: unit }), _jsx(SelectControl, { label: i18n._({ id: 'node.ceiling.buildUpSection.framing', message: 'Framing' }), onChange: (system) => edit({
+                            framing: system === NONE
+                                ? undefined
+                                : framing
+                                    ? { ...framing, system }
+                                    : NEW_FRAMING[system],
+                        }), options: FRAMING_OPTIONS.map((option) => ({ ...option, label: i18n._(option.label) })), value: framing?.system ?? NONE }), framing && (_jsx(FramingSizeFields, { framing: framing, onChange: (change) => edit({ framing: { ...framing, ...change } }), sizeLabel: framing.system === 'joists'
+                            ? i18n._({ id: 'node.ceiling.buildUpSection.joists', message: 'Joists' })
+                            : i18n._({
+                                id: 'node.ceiling.buildUpSection.bottomChord',
+                                message: 'Bottom chord',
+                            }), unit: unit })), _jsx(PanelFields, { added: 0.75 * INCH, label: i18n._({ id: 'node.ceiling.buildUpSection.decking', message: 'Decking' }), layer: buildUp.decking, onChange: (decking) => edit({ decking }), optional: true, unit: unit }), _jsx(InsulationFields, { framingDepth: LUMBER_DEPTH[framing?.size ?? '2x4'], layer: buildUp.insulation, onChange: (insulation) => edit({ insulation }), unit: unit }), _jsx(BuildUpReadout, { label: i18n._({ id: 'node.ceiling.buildUpSection.thickness', message: 'Thickness' }), value: formatLayerDepth(ceilingBuildUpThickness(buildUp), unit) }), _jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: i18n._({
+                            id: 'node.ceiling.buildUpSection.theHeightIsTheFinishedUnderside',
+                            message: 'The height is the finished underside; the layers rise from it.',
+                        }) })] }))] }));
+}