@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/cabinet/kitchen-module-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kitchen-module-actions.d.ts","sourceRoot":"","sources":["../../src/cabinet/kitchen-module-actions.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAKjB,MAAM,kBAAkB,CAAA;AAOzB,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,WAAW,CAAA;AAYnE,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,GAAG,EACH,SAAS,GACV,EAAE;IACD,IAAI,EAAE,iBAAiB,CAAA;IACvB,GAAG,EAAE,WAAW,CAAA;IAChB,SAAS,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,IAAI,CAAA;CACzC,+BAyTA"}
+{"version":3,"file":"kitchen-module-actions.d.ts","sourceRoot":"","sources":["../../src/cabinet/kitchen-module-actions.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,KAAK,WAAW,EAMjB,MAAM,kBAAkB,CAAA;AAOzB,OAAO,EAAE,KAAK,eAAe,EAAqB,MAAM,WAAW,CAAA;AAYnE,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,GAAG,EACH,SAAS,GACV,EAAE;IACD,IAAI,EAAE,iBAAiB,CAAA;IACvB,GAAG,EAAE,WAAW,CAAA;IAChB,SAAS,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,IAAI,CAAA;CACzC,+BAyTA"}

package/dist/cabinet/kitchen-module-actions.js

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CabinetModuleNode, createSceneApi, runAsSingleSceneHistoryStep, usePascalI18n, useScene, } from '@pascal-app/core';
-import { ActionButton, formatLinearMeasurement } from '@pascal-app/editor';
+import { CabinetModuleNode, createSceneApi, formatLinearMeasurement, runAsSingleSceneHistoryStep, usePascalI18n, useScene, } from '@pascal-app/core';
+import { ActionButton } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useState } from 'react';
 import { applyCabinetModuleInsertion, cabinetModuleForRunInsertion } from './insertion.js';

package/dist/cabinet/placement-dimensions.d.ts

@@ -1,4 +1,5 @@
-import type { AnyNode, AnyNodeId } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+import { findClosestCabinetWallInPlan } from './wall-snap.js';
 export type CabinetPlacementDimension = {
     id: string;
     start: [number, number, number];
@@ -9,6 +10,37 @@ export type CabinetPlacementDimension = {
     renderIn3d?: boolean;
     renderInFloorplan?: boolean;
 };
+type CabinetPlacementWallHit = NonNullable<ReturnType<typeof findClosestCabinetWallInPlan>>;
+export type CabinetPlacementCoordinates = {
+    distance: number;
+    offset: number;
+};
+/**
+ * Cabinet distance is measured from the wall start to the cabinet's near edge;
+ * offset is signed away from the selected wall face.
+ */
+export declare function getCabinetPlacementCoordinates({ depth, hit, levelId, nodes, position, width, }: {
+    depth: number;
+    hit: CabinetPlacementWallHit;
+    levelId: AnyNodeId;
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>;
+    position: readonly [number, number, number];
+    width: number;
+}): CabinetPlacementCoordinates;
+export declare function resolveCabinetTypedPlacementPosition({ depth, distance, hit, levelId, nodes, offset, position, width, }: {
+    depth: number;
+    distance: number;
+    hit: CabinetPlacementWallHit;
+    levelId: AnyNodeId;
+    nodes: Readonly<Record<AnyNodeId, AnyNode>>;
+    offset: number;
+    position: readonly [number, number, number];
+    width: number;
+}): {
+    position: [number, number, number];
+    wallLocalX: number;
+    yaw: number;
+} | null;
 export declare function buildCabinetPlacementSizeDimensions({ depth, height, position, rotation, width, }: {
     depth: number;
     height: number;
@@ -16,11 +48,12 @@ export declare function buildCabinetPlacementSizeDimensions({ depth, height, pos
     rotation: number;
     width: number;
 }): CabinetPlacementDimension[];
-export declare function resolveCabinetPlacementDimensions({ depth, levelId, nodes, position, rotation, wallId, width, }: {
+export declare function resolveCabinetPlacementDimensions({ depth, levelId, nodes, position, providedWallHit, rotation, wallId, width, }: {
     depth: number;
     levelId: AnyNodeId;
     nodes: Readonly<Record<AnyNodeId, AnyNode>>;
     position: readonly [number, number, number];
+    providedWallHit?: CabinetPlacementWallHit;
     rotation: number;
     wallId?: AnyNodeId;
     width: number;
@@ -39,4 +72,5 @@ export declare function resolveCabinetPlacementDimensionPosition({ depth, dimens
     position: [number, number, number];
     wallLocalX: number;
 } | null;
+export {};
 //# sourceMappingURL=placement-dimensions.d.ts.map

package/dist/cabinet/placement-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placement-dimensions.d.ts","sourceRoot":"","sources":["../../src/cabinet/placement-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAY1D,MAAM,MAAM,yBAAyB,GAAG;IACtC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED,wBAAgB,mCAAmC,CAAC,EAClD,KAAK,EACL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,KAAK,GACN,EAAE;IACD,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,yBAAyB,EAAE,CAmC9B;AAmED,wBAAgB,iCAAiC,CAAC,EAChD,KAAK,EACL,OAAO,EACP,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,KAAK,GACN,EAAE;IACD,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;IAC3C,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,yBAAyB,EAAE,CAkF9B;AAED,wBAAgB,wCAAwC,CAAC,EACvD,KAAK,EACL,WAAW,EACX,OAAO,EACP,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,KAAK,EACL,KAAK,GACN,EAAE;IACD,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;IAC3C,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,GAAG;IAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAyEpE"}
+{"version":3,"file":"placement-dimensions.d.ts","sourceRoot":"","sources":["../../src/cabinet/placement-dimensions.ts"],"names":[],"mappings":"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"}

package/dist/cabinet/placement-dimensions.js

@@ -1,8 +1,74 @@
+import { getWallCurveFrameAt, isCurvedWall } from '@pascal-app/core';
 import { runLocalToPlan } from './run-layout.js';
 import { collectCabinetWallSnapNeighbors, findClosestCabinetWallInPlan, resolveCabinetWallFaceOffset, } from './wall-snap.js';
 const DIMENSION_Y = 0.035;
 const DIMENSION_OFFSET = 0.22;
 const DIMENSION_EPSILON = 1e-4;
+function cabinetWallFrameAtLocalX(hit, localX) {
+    if (isCurvedWall(hit.wall)) {
+        return getWallCurveFrameAt(hit.wall, localX / hit.wallLength);
+    }
+    return {
+        point: {
+            x: hit.wall.start[0] + hit.dirX * localX,
+            y: hit.wall.start[1] + hit.dirY * localX,
+        },
+        tangent: { x: hit.dirX, y: hit.dirY },
+        normal: { x: -hit.dirY, y: hit.dirX },
+    };
+}
+/**
+ * Cabinet distance is measured from the wall start to the cabinet's near edge;
+ * offset is signed away from the selected wall face.
+ */
+export function getCabinetPlacementCoordinates({ depth, hit, levelId, nodes, position, width, }) {
+    const frame = cabinetWallFrameAtLocalX(hit, hit.localX);
+    const faceOffset = resolveCabinetWallFaceOffset({
+        hit,
+        nodes: nodes,
+        parentLevelId: levelId,
+    });
+    const normalScale = hit.side === 'front' ? 1 : -1;
+    const wallToPosition = [position[0] - frame.point.x, position[2] - frame.point.y];
+    const actualOffset = (wallToPosition[0] * frame.normal.x + wallToPosition[1] * frame.normal.y) * normalScale;
+    const flushOffset = faceOffset * normalScale + depth / 2;
+    return {
+        distance: Math.max(0, Math.min(hit.wallLength - width, hit.localX - width / 2)),
+        offset: actualOffset - flushOffset,
+    };
+}
+export function resolveCabinetTypedPlacementPosition({ depth, distance, hit, levelId, nodes, offset, position, width, }) {
+    if (!Number.isFinite(distance) || !Number.isFinite(offset))
+        return null;
+    // A cabinet wider than the wall still places (wall snap allows the pose),
+    // and wall snap centers it on the wall (empty span → midpoint). Typed
+    // distance collapses to that centered pose instead of mapping 0 to
+    // width / 2, which would slide the cabinet off the wall center.
+    const maxDistance = Math.max(0, hit.wallLength - width);
+    if (distance < -DIMENSION_EPSILON || distance > maxDistance + DIMENSION_EPSILON)
+        return null;
+    const clampedDistance = Math.min(Math.max(distance, 0), maxDistance);
+    const localX = hit.wallLength <= width ? hit.wallLength / 2 : clampedDistance + width / 2;
+    const frame = cabinetWallFrameAtLocalX(hit, localX);
+    // Sample the miter at the destination station — the frozen hit's localX is
+    // the pre-typing snap, so its face offset is wrong on mitered corners.
+    const faceOffset = resolveCabinetWallFaceOffset({
+        hit: { ...hit, localX },
+        nodes: nodes,
+        parentLevelId: levelId,
+    });
+    const normalScale = hit.side === 'front' ? 1 : -1;
+    const centerOffset = faceOffset + normalScale * (depth / 2 + offset);
+    return {
+        position: [
+            frame.point.x + frame.normal.x * centerOffset,
+            position[1],
+            frame.point.y + frame.normal.y * centerOffset,
+        ],
+        wallLocalX: localX,
+        yaw: Math.atan2(frame.normal.x * normalScale, frame.normal.y * normalScale),
+    };
+}
 export function buildCabinetPlacementSizeDimensions({ depth, height, position, rotation, width, }) {
     const run = {
         position: [position[0], position[1], position[2]],
@@ -70,8 +136,8 @@ function findPlacementWallHit({ levelId, nodes, position, rotation, wallId, }) {
     });
     return selectedWall?.type === 'wall' && hit?.wall.id !== selectedWall.id ? null : hit;
 }
-export function resolveCabinetPlacementDimensions({ depth, levelId, nodes, position, rotation, wallId, width, }) {
-    const wallHit = findPlacementWallHit({ levelId, nodes, position, rotation, wallId });
+export function resolveCabinetPlacementDimensions({ depth, levelId, nodes, position, providedWallHit, rotation, wallId, width, }) {
+    const wallHit = providedWallHit ?? findPlacementWallHit({ levelId, nodes, position, rotation, wallId });
     if (!wallHit)
         return [];
     const minLocalX = wallHit.localX - width / 2;

package/dist/cabinet/system.js

@@ -4,7 +4,7 @@ import { useFrame } from '@react-three/fiber';
 import { useRef } from 'react';
 import { poseCabinetMovingParts } from './animation.js';
 import { updateCooktopFlameTube } from './cooktop-flame.js';
-import { bumpCabinetRunsNear, cabinetRunFootprint, cabinetRunNeighborSignature, } from './definition.js';
+import { bumpCabinetRunsNear, cabinetRunFootprint, cabinetRunNeighborSignature, } from './definition.render.js';
 import { collectCabinetFlameObjects } from './flame-index.js';
 function materialWithOpacity(material) {
     if (!material)

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/cabinet/tool.tsx"],"names":[],"mappings":"AAkiEA,MAAM,CAAC,OAAO,UAAU,WAAW,gCAGlC"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/cabinet/tool.tsx"],"names":[],"mappings":"AAi1EA,MAAM,CAAC,OAAO,UAAU,WAAW,gCAGlC"}

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, useLocale, useScene, } from '@pascal-app/core';
-import { clearPlacementSurface, EDITOR_LAYER, getFloorStackPreviewPosition, getSideFromNormal, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, markToolCancelConsumed, movementSfxStepKey, PlacementBox, PlacementDimensionGuides, publishPlacementSurface, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
+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';
@@ -16,7 +16,7 @@ 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';
@@ -200,6 +200,8 @@ const CabinetPlacementTool = () => {
     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);
@@ -220,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));
@@ -399,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,
@@ -468,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;
@@ -503,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.
@@ -792,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,
@@ -887,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);
@@ -898,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();
@@ -1160,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;
@@ -1192,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');
@@ -1215,7 +1254,7 @@ const CabinetPlacementTool = () => {
                 clearPlacementSurface();
                 useFacingPose.getState().clear();
                 stopPlacementCommitPropagation(event);
-                return;
+                return true;
             }
             if (useEditor.getState().getContinuation('cabinet') === 'continuous') {
                 draftSegmentsRef.current = [];
@@ -1232,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);
@@ -1254,10 +1298,190 @@ 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;
@@ -1392,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;
@@ -1467,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();
@@ -1486,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();
@@ -1567,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],