@pascal-app/nodes 0.1.1

package/dist/wall/floorplan-move.js

@@ -0,0 +1,259 @@
+import { getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
+/**
+ * 2D floor-plan move handler for wall.
+ *
+ * Mirrors the 3D `MoveWallTool` junction-plan behavior so dragging a
+ * wall in the floor plan produces the same scene topology as dragging
+ * it in 3D: linked corners cascade, same-direction collapsed walls
+ * delete, off-axis branches stay rectilinear with a new bridge wall
+ * inserted between the original and new corner.
+ *
+ * Tick (`apply`) — publishes per-frame `{ start, end }` overrides to
+ * `useLiveNodeOverrides` for the moved wall + every linked wall.
+ * `useScene` stays at the pre-drag values throughout the drag; the
+ * `WallSystem` and the 2D floor-plan layer fold the overrides in when
+ * reading endpoints, so the visual preview updates without churning
+ * zustand. Bridge creates and wall deletes are still deferred to
+ * commit so the live preview doesn't churn the scene graph either.
+ *
+ * Commit (`commit`) — recomputes the plan at the final cursor position
+ * and emits one atomic `applyNodeChanges` covering the moved walls,
+ * the bridge wall creates, and the collapsed wall deletes — so a
+ * single Ctrl-Z rolls the entire operation back. Clears the live
+ * overrides after the write lands so the system reads from the new
+ * committed scene state.
+ *
+ * Auto-slab live preview and ghost bridge SVG previews — visible in
+ * the 3D tool — are deliberately deferred. Slab polygons re-derive on
+ * commit through the normal scene reactions; bridges appear at commit
+ * time. Follow-up work to surface them mid-drag is tracked separately.
+ */
+export const wallFloorplanMoveTarget = ({ node }) => {
+    const wallId = node.id;
+    const originalStart = [node.start[0], node.start[1]];
+    const originalEnd = [node.end[0], node.end[1]];
+    const originalCenter = [
+        (originalStart[0] + originalEnd[0]) / 2,
+        (originalStart[1] + originalEnd[1]) / 2,
+    ];
+    // Perpendicular (wall normal) axis — same lock the 3D `MoveWallTool`
+    // uses, so a 2D drag slides the wall sideways across its own
+    // direction rather than free-floating in XZ. `null` only for
+    // degenerate zero-length walls; we fall through to free motion in
+    // that case (the wall is going to be deleted anyway).
+    const moveAxis = getPerpendicularWallMoveAxis(originalStart, originalEnd);
+    const isNew = !!node.metadata?.isNew;
+    const linkedOriginals = isNew
+        ? []
+        : getLinkedWallSnapshots({
+            wallId: node.id,
+            wallParentId: node.parentId ?? null,
+            originalStart,
+            originalEnd,
+        });
+    // Anchor lazily at the first cursor sample (the click point) and
+    // measure cursor movement from there. The wall doesn't shift on
+    // click — `rawDelta` is zero on the first apply, so the snapped
+    // centre projection equals `originalProj` (already grid-aligned for
+    // walls placed via the draft tool). As the cursor moves, the wall
+    // translates along its normal by the cursor's perpendicular delta,
+    // snapped to absolute grid lines.
+    //
+    // Using `originalCenter` as the anchor instead would pin the wall's
+    // centre to the cursor — but the floor-plan drag icon lives inside
+    // a floating menu whose hit-area is offset from the exact wall
+    // centre, so the first `planPoint` would never equal `originalCenter`
+    // and the wall would snap to a different grid cell the instant the
+    // drag began, even before the cursor moved.
+    let rawAnchor = null;
+    let lastDelta = [0, 0];
+    let lastNextStart = originalStart;
+    let lastNextEnd = originalEnd;
+    const session = {
+        affectedIds: [wallId, ...linkedOriginals.map((w) => w.id)],
+        apply({ planPoint }) {
+            if (!rawAnchor) {
+                rawAnchor = [planPoint[0], planPoint[1]];
+                return;
+            }
+            const rawDx = planPoint[0] - rawAnchor[0];
+            const rawDz = planPoint[1] - rawAnchor[1];
+            const step = getSegmentGridStep();
+            // Axis-lock the move to the wall's perpendicular (normal). Project
+            // the original centre + raw cursor delta onto the axis, snap the
+            // absolute projection to a grid multiple, then translate the wall
+            // by `axis * perpDelta`. Matches `MoveWallTool` so 2D and 3D drag
+            // produce identical wall topology.
+            let dx;
+            let dz;
+            if (moveAxis) {
+                const originalProj = originalCenter[0] * moveAxis[0] + originalCenter[1] * moveAxis[1];
+                const rawProj = originalProj + rawDx * moveAxis[0] + rawDz * moveAxis[1];
+                const snappedProj = snapScalarToGrid(rawProj, step);
+                const perpDelta = snappedProj - originalProj;
+                dx = moveAxis[0] * perpDelta;
+                dz = moveAxis[1] * perpDelta;
+            }
+            else {
+                dx = snapScalarToGrid(rawDx, step);
+                dz = snapScalarToGrid(rawDz, step);
+            }
+            if (dx === lastDelta[0] && dz === lastDelta[1])
+                return;
+            lastDelta = [dx, dz];
+            const nextStart = [originalStart[0] + dx, originalStart[1] + dz];
+            const nextEnd = [originalEnd[0] + dx, originalEnd[1] + dz];
+            lastNextStart = nextStart;
+            lastNextEnd = nextEnd;
+            const plan = planWallMoveJunctions(linkedOriginals, originalStart, originalEnd, nextStart, nextEnd);
+            const plannedUpdates = getPlannedLinkedWallUpdates(plan, originalStart, originalEnd, nextStart, nextEnd);
+            const plannedById = new Map(plannedUpdates.map((entry) => [entry.id, entry]));
+            // Walls in the plan that would collapse to ≈zero-length get held
+            // at their pre-drag positions during the live preview — actually
+            // deleting them is deferred to commit so a single drag tick
+            // doesn't churn the scene graph with create / delete pairs.
+            const collapsedIds = new Set([
+                ...plannedUpdates
+                    .filter((entry) => !isSegmentLongEnough(entry.start, entry.end))
+                    .map((entry) => entry.id),
+                ...plan.wallsToDelete.map((wall) => wall.id),
+            ]);
+            const linkedUpdates = linkedOriginals.map((wall) => {
+                if (collapsedIds.has(wall.id)) {
+                    return { id: wall.id, start: wall.start, end: wall.end };
+                }
+                const planned = plannedById.get(wall.id);
+                if (planned) {
+                    return { id: wall.id, start: planned.start, end: planned.end };
+                }
+                return { id: wall.id, start: wall.start, end: wall.end };
+            });
+            // Publish endpoint overrides instead of writing to `useScene`.
+            // `WallSystem` + the 2D layer + the sidebar panel all consult
+            // `useLiveNodeOverrides` first, so the visual + numeric preview
+            // updates each frame while zustand stays at the pre-drag values
+            // until the user commits. Batched into a single zustand
+            // notification — otherwise each per-wall `.set` would re-render
+            // every override subscriber once per linked wall per tick.
+            useLiveNodeOverrides
+                .getState()
+                .setMany([
+                [wallId, { start: nextStart, end: nextEnd }],
+                ...linkedUpdates.map((upd) => [upd.id, { start: upd.start, end: upd.end }]),
+            ]);
+            // Surface bridge-wall previews so the floor-plan SVG layer can
+            // render dashed outlines of what `commit()` will insert. Mirrors
+            // the 3D `MoveWallTool`'s `ghostWallPreviews` mesh layer. The
+            // `existingWalls` snapshot needs the post-drag layout so duplicate
+            // detection works; we synthesise it from scene state + the
+            // overrides we just published (zustand is still on baseline).
+            const previewSceneWalls = getWallsAfterUpdates(useScene.getState().nodes, [
+                { id: wallId, data: { start: nextStart, end: nextEnd } },
+                ...linkedUpdates.map((u) => ({ id: u.id, data: { start: u.start, end: u.end } })),
+            ]).filter((wall) => !collapsedIds.has(wall.id));
+            const bridgePreviews = buildBridgeWallPreviews({
+                bridgePlans: plan.bridgePlans,
+                nextStart,
+                nextEnd,
+                existingWalls: previewSceneWalls,
+            });
+            const ghostBridges = bridgePreviews.map(({ ghost, wall }) => ({
+                id: ghost.id,
+                start: ghost.start,
+                end: ghost.end,
+                color: ghost.color,
+                thickness: getFloorplanWallThickness(wall),
+            }));
+            useWallMoveGhosts.getState().setBridges(ghostBridges);
+            // `WallSystem` only runs its rebuild pass when `dirtyNodes` is
+            // non-empty. We're not writing to scene any more, but we still
+            // need the system to pick up the live override changes — so
+            // mark dirty here. The rebuild reads the effective endpoints
+            // (override-merged) so the mesh follows the cursor.
+            const sceneState = useScene.getState();
+            sceneState.markDirty(wallId);
+            for (const upd of linkedUpdates) {
+                sceneState.markDirty(upd.id);
+            }
+        },
+        canCommit() {
+            const live = useScene.getState().nodes[wallId];
+            if (live?.type !== 'wall')
+                return false;
+            const [dx, dz] = lastDelta;
+            return dx !== 0 || dz !== 0;
+        },
+        commit() {
+            const sceneState = useScene.getState();
+            const liveWall = sceneState.nodes[wallId];
+            if (liveWall?.type !== 'wall') {
+                // Bail without leaving stale overrides behind.
+                const overrides = useLiveNodeOverrides.getState();
+                overrides.clear(wallId);
+                for (const wall of linkedOriginals)
+                    overrides.clear(wall.id);
+                return;
+            }
+            const plan = planWallMoveJunctions(linkedOriginals, originalStart, originalEnd, lastNextStart, lastNextEnd);
+            const linkedWallUpdates = getPlannedLinkedWallUpdates(plan, originalStart, originalEnd, lastNextStart, lastNextEnd);
+            const collapsedLinkedWallIds = new Set([
+                ...linkedWallUpdates
+                    .filter((entry) => !isSegmentLongEnough(entry.start, entry.end))
+                    .map((entry) => entry.id),
+                ...plan.wallsToDelete.map((wall) => wall.id),
+            ]);
+            const movingWallUpdate = {
+                id: wallId,
+                data: isNew
+                    ? {
+                        start: lastNextStart,
+                        end: lastNextEnd,
+                        metadata: stripWallIsNewMetadata(node.metadata),
+                    }
+                    : { start: lastNextStart, end: lastNextEnd },
+            };
+            const commitUpdates = [
+                movingWallUpdate,
+                ...linkedWallUpdates
+                    .filter((entry) => !collapsedLinkedWallIds.has(entry.id))
+                    .map((entry) => ({
+                    id: entry.id,
+                    data: { start: entry.start, end: entry.end },
+                })),
+            ];
+            const existingWalls = getWallsAfterUpdates(sceneState.nodes, commitUpdates).filter((wall) => !collapsedLinkedWallIds.has(wall.id));
+            const bridgeCreates = buildBridgeWallCreates({
+                bridgePlans: plan.bridgePlans,
+                nextStart: lastNextStart,
+                nextEnd: lastNextEnd,
+                existingWalls,
+                wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
+            });
+            sceneState.applyNodeChanges({
+                update: commitUpdates,
+                create: bridgeCreates,
+                delete: Array.from(collapsedLinkedWallIds),
+            });
+            // Drop the live overrides now that the committed scene state
+            // matches them — leaving them around would keep the system
+            // double-merging the same values and would shadow any genuine
+            // post-commit edits to start/end. Cleared synchronously so the
+            // next frame reads the new scene state directly.
+            const overrides = useLiveNodeOverrides.getState();
+            overrides.clear(wallId);
+            for (const wall of linkedOriginals)
+                overrides.clear(wall.id);
+            // Swap ghosts → real walls: the bridges we just created render
+            // through the registry layer, so the dashed previews aren't
+            // needed any more. Clearing here (instead of waiting for the
+            // overlay's unmount cleanup) avoids a one-frame flash where
+            // both ghosts and real bridges paint at the new position.
+            useWallMoveGhosts.getState().clear();
+            useViewer.getState().setSelection({ selectedIds: [wallId] });
+        },
+    };
+    return session;
+};

package/dist/wall/floorplan-overrides.d.ts

@@ -0,0 +1,22 @@
+import type { AnyNode, AnyNodeId } from '@pascal-app/core';
+/**
+ * Project per-frame wall drag overrides (`{ start, end, curveOffset }`)
+ * from `useLiveNodeOverrides` into a fresh `nodes` snapshot. The 2D drag
+ * handlers publish overrides for the moved wall plus its linked
+ * neighbours; the floor-plan layer hands the merged snapshot to
+ * `buildContext` so each wall's `ctx.siblings` (which feeds the
+ * miter calculation) reflects the live cursor positions instead of
+ * the last committed scene state.
+ *
+ * Only wall entries are touched; every other node is shared by
+ * reference. The allocation cost is one shallow object per overridden
+ * wall — the override map is small, so this is cheap. When the
+ * override map is empty (no live drag) the input is returned
+ * unchanged.
+ */
+export declare function wallFloorplanSiblingOverrides(args: {
+    nodeId: AnyNodeId;
+    nodes: Record<AnyNodeId, AnyNode>;
+    liveOverrides: Map<string, Record<string, unknown>>;
+}): Record<AnyNodeId, AnyNode>;
+//# sourceMappingURL=floorplan-overrides.d.ts.map

package/dist/wall/floorplan-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-overrides.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE1D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAY7B"}

package/dist/wall/floorplan-overrides.js

@@ -0,0 +1,32 @@
+/**
+ * Project per-frame wall drag overrides (`{ start, end, curveOffset }`)
+ * from `useLiveNodeOverrides` into a fresh `nodes` snapshot. The 2D drag
+ * handlers publish overrides for the moved wall plus its linked
+ * neighbours; the floor-plan layer hands the merged snapshot to
+ * `buildContext` so each wall's `ctx.siblings` (which feeds the
+ * miter calculation) reflects the live cursor positions instead of
+ * the last committed scene state.
+ *
+ * Only wall entries are touched; every other node is shared by
+ * reference. The allocation cost is one shallow object per overridden
+ * wall — the override map is small, so this is cheap. When the
+ * override map is empty (no live drag) the input is returned
+ * unchanged.
+ */
+export function wallFloorplanSiblingOverrides(args) {
+    const { nodes, liveOverrides } = args;
+    if (liveOverrides.size === 0)
+        return nodes;
+    let out = null;
+    for (const [id, override] of liveOverrides) {
+        const existing = nodes[id];
+        if (existing?.type !== 'wall')
+            continue;
+        if (Object.keys(override).length === 0)
+            continue;
+        if (!out)
+            out = { ...nodes };
+        out[id] = { ...existing, ...override };
+    }
+    return out ?? nodes;
+}

package/dist/wall/floorplan.d.ts

@@ -0,0 +1,23 @@
+import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallMiterData, type WallNode } from '@pascal-app/core';
+export declare function computeWallFloorplanLevelData({ siblings, }: {
+    siblings: ReadonlyArray<WallNode>;
+    nodes: Record<string, AnyNode>;
+}): WallMiterData;
+/**
+ * Stage C floor-plan builder for wall — emits the full chrome stack the
+ * legacy `floorplan-panel.tsx` rendered inline:
+ *
+ *   1. The mitered footprint polygon (themed fill + stroke).
+ *   2. A diagonal hatch overlay when selected.
+ *   3. A transparent hit-line on the centerline so the user can grab the
+ *      wall body easily.
+ *   4. Two endpoint handles (start + end) when selected — the registry
+ *      layer hosts the 5-circle stack + hover transitions + 2D drag.
+ *   5. A small dimension label at the midpoint when selected.
+ *
+ * `ctx.levelData` provides the shared level miter graph when the floor-plan
+ * dispatcher precomputes it; `ctx.siblings` remains the fallback path for
+ * direct builder callers.
+ */
+export declare function buildWallFloorplan(node: WallNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,aAAa,CAEhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+LjG"}

package/dist/wall/floorplan.js

@@ -0,0 +1,249 @@
+import { calculateLevelMiters, getWallCurveLength, getWallMidpointHandlePoint, getWallPlanFootprint, isCurvedWall, } from '@pascal-app/core';
+// Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
+// Slightly exaggerates thin walls so the 2D plan stays legible without
+// drifting from BIM data. Inlined to keep nodes/wall self-contained.
+const FLOORPLAN_WALL_THICKNESS_SCALE = 1.18;
+const FLOORPLAN_MIN_VISIBLE_WALL_THICKNESS = 0.13;
+const FLOORPLAN_MAX_EXTRA_THICKNESS = 0.035;
+function floorplanWallThickness(wall) {
+    const baseThickness = wall.thickness ?? 0.1;
+    const scaledThickness = baseThickness * FLOORPLAN_WALL_THICKNESS_SCALE;
+    return Math.min(baseThickness + FLOORPLAN_MAX_EXTRA_THICKNESS, Math.max(baseThickness, scaledThickness, FLOORPLAN_MIN_VISIBLE_WALL_THICKNESS));
+}
+function exaggerateWallThickness(wall) {
+    return { ...wall, thickness: floorplanWallThickness(wall) };
+}
+function formatLengthMetric(meters) {
+    return `${Number.parseFloat(meters.toFixed(2))}m`;
+}
+export function computeWallFloorplanLevelData({ siblings, }) {
+    return calculateLevelMiters(siblings.map(exaggerateWallThickness));
+}
+/**
+ * Stage C floor-plan builder for wall — emits the full chrome stack the
+ * legacy `floorplan-panel.tsx` rendered inline:
+ *
+ *   1. The mitered footprint polygon (themed fill + stroke).
+ *   2. A diagonal hatch overlay when selected.
+ *   3. A transparent hit-line on the centerline so the user can grab the
+ *      wall body easily.
+ *   4. Two endpoint handles (start + end) when selected — the registry
+ *      layer hosts the 5-circle stack + hover transitions + 2D drag.
+ *   5. A small dimension label at the midpoint when selected.
+ *
+ * `ctx.levelData` provides the shared level miter graph when the floor-plan
+ * dispatcher precomputes it; `ctx.siblings` remains the fallback path for
+ * direct builder callers.
+ */
+export function buildWallFloorplan(node, ctx) {
+    const self = exaggerateWallThickness(node);
+    // Prefer the level-batch miter graph the floor-plan dispatcher precomputes
+    // once per pass (`computeWallFloorplanLevelData`). Only the fallback path —
+    // a direct builder caller with no shared data — pays the O(N) exaggerate +
+    // level-wide miter calc per wall; the dispatcher path is O(1) here, which is
+    // what keeps a wall drag from being O(N²) across the level.
+    const miters = ctx.levelData ??
+        calculateLevelMiters([
+            self,
+            ...ctx.siblings
+                .filter((s) => s.type === 'wall')
+                .map(exaggerateWallThickness),
+        ]);
+    const polygon = getWallPlanFootprint(self, miters);
+    if (!polygon || polygon.length < 3)
+        return null;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    const points = polygon.map((p) => [p.x, p.y]);
+    // Stroke colour shifts: selected → theme accent; hover (when not
+    // selected) → palette.wallHoverStroke (light blue from the legacy);
+    // otherwise the dark grey carries through. Mirrors the legacy
+    // `wallStroke` ternary in floorplan-panel.tsx around line 4356.
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : '#1f2937';
+    const fill = showSelectedChrome ? '#ffffff' : '#374151';
+    const children = [
+        {
+            kind: 'polygon',
+            points,
+            fill,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.03 : 0.02,
+            opacity: 0.92,
+            // Once the wall is selected, the body keeps catching the pointer
+            // so the cursor stays neutral (no drag/pointer affordance from
+            // the slab below leaking through), but only the side-arrows and
+            // endpoint handles should start a drag — the wrapper g's click
+            // handler is a no-op re-select for the already-selected wall.
+            cursor: isSelected ? 'default' : undefined,
+        },
+    ];
+    // Selection hatch overlay — only when the wall is *the* selected item
+    // (not when it's just marquee-highlighted), matching the legacy.
+    if (isSelected && palette) {
+        children.push({
+            kind: 'hatch',
+            points,
+            color: palette.selectedHatch,
+            opacity: 1,
+        });
+    }
+    // Hit-line on the centerline. Stroke width is in screen pixels so it
+    // stays clickable at any zoom. Skipped while selected — the user has
+    // the side-arrows / endpoint handles by then, and leaving the hit-line
+    // live would re-introduce a "click-and-drag the wall body" path.
+    if (!isSelected) {
+        children.push({
+            kind: 'hit-line',
+            x1: node.start[0],
+            y1: node.start[1],
+            x2: node.end[0],
+            y2: node.end[1],
+            strokeWidthPx: 18,
+            cursor: 'pointer',
+        });
+    }
+    // Endpoint handles only when the user has actively selected this wall.
+    if (isSelected) {
+        children.push({
+            kind: 'endpoint-handle',
+            point: [node.start[0], node.start[1]],
+            state: 'idle',
+            affordance: 'move-endpoint',
+            payload: { wallId: node.id, endpoint: 'start' },
+        });
+        children.push({
+            kind: 'endpoint-handle',
+            point: [node.end[0], node.end[1]],
+            state: 'idle',
+            affordance: 'move-endpoint',
+            payload: { wallId: node.id, endpoint: 'end' },
+        });
+        // Side move arrows — two directional arrows at the wall midpoint,
+        // pointing outward perpendicular to the wall. Mirrors the 3D
+        // `WallMoveSideHandles` arrows so users can grab the wall body
+        // from the floor plan. PointerDown on either arrow activates
+        // `wallFloorplanMoveTarget` via the registry-layer dispatcher.
+        {
+            const dx = node.end[0] - node.start[0];
+            const dz = node.end[1] - node.start[1];
+            const wallLength = Math.hypot(dx, dz);
+            if (wallLength > 1e-6) {
+                const midX = (node.start[0] + node.end[0]) / 2;
+                const midZ = (node.start[1] + node.end[1]) / 2;
+                const nx = -dz / wallLength;
+                const nz = dx / wallLength;
+                const offset = floorplanWallThickness(node) / 2 + 0.05;
+                children.push({
+                    kind: 'move-arrow',
+                    point: [midX + nx * offset, midZ + nz * offset],
+                    angle: Math.atan2(nz, nx),
+                });
+                children.push({
+                    kind: 'move-arrow',
+                    point: [midX - nx * offset, midZ - nz * offset],
+                    angle: Math.atan2(-nz, -nx),
+                });
+            }
+        }
+        // Curve sagitta handle — teal dot at the wall midpoint that
+        // controls `curveOffset`. Hidden when the wall hosts a door /
+        // window / wall-attached item: bending the wall would tear those
+        // children, so the legacy disables the handle in that case (see
+        // `wallCurveHandles.hasWallChildrenBlockingCurve`).
+        if (!hasCurveBlockingChildren(ctx.children)) {
+            const handle = getWallMidpointHandlePoint(node);
+            children.push({
+                kind: 'endpoint-handle',
+                point: [handle.x, handle.y],
+                state: 'idle',
+                variant: 'curve',
+                affordance: 'curve',
+                payload: { wallId: node.id },
+            });
+        }
+        // Length measurement. Curved walls use the simple rounded label
+        // (the chord-vs-arc thing is hard to express with a dimension line);
+        // straight walls get the full architect's overlay with extension
+        // marks + ticks, offset to the side facing away from the level
+        // centroid (matches the legacy `getWallMeasurementOverlay`).
+        const length = getWallCurveLength(node);
+        if (length >= 0.1) {
+            const dx = node.end[0] - node.start[0];
+            const dz = node.end[1] - node.start[1];
+            const midX = (node.start[0] + node.end[0]) / 2;
+            const midZ = (node.start[1] + node.end[1]) / 2;
+            if (isCurvedWall(node)) {
+                children.push({
+                    kind: 'dimension-label',
+                    cx: midX,
+                    cy: midZ,
+                    text: formatLengthMetric(length),
+                    angle: Math.atan2(dz, dx),
+                });
+            }
+            else {
+                // Outward unit normal = perpendicular to (dx, dz), choose the
+                // side facing away from other walls' centroid so the dimension
+                // line sits outside the building.
+                const nx = -dz / length;
+                const nz = dx / length;
+                const wallSiblings = ctx.siblings.filter((s) => s.type === 'wall');
+                const centroid = wallCentroid([node, ...wallSiblings]);
+                const cx = midX - centroid[0];
+                const cz = midZ - centroid[1];
+                const facingAway = cx * nx + cz * nz >= 0 ? 1 : -1;
+                children.push({
+                    kind: 'dimension',
+                    start: [node.start[0], node.start[1]],
+                    end: [node.end[0], node.end[1]],
+                    offsetNormal: [nx * facingAway, nz * facingAway],
+                    offsetDistance: 0.75,
+                    extensionOvershoot: 0.12,
+                    text: formatLengthMetric(length),
+                });
+            }
+        }
+    }
+    return { kind: 'group', children };
+}
+function wallCentroid(walls) {
+    // Mean of every wall endpoint — cheap approximation of "where the
+    // building lives" so we can offset the dimension line away from it.
+    let sumX = 0;
+    let sumZ = 0;
+    let count = 0;
+    for (const wall of walls) {
+        sumX += wall.start[0] + wall.end[0];
+        sumZ += wall.start[1] + wall.end[1];
+        count += 2;
+    }
+    if (count === 0)
+        return [0, 0];
+    return [sumX / count, sumZ / count];
+}
+/**
+ * Doors, windows, and wall-attached items would tear if the wall bent
+ * around them, so the curve sagitta handle hides when any of those
+ * children exist. Mirrors the legacy
+ * `wallCurveHandles.hasWallChildrenBlockingCurve` check.
+ */
+function hasCurveBlockingChildren(children) {
+    for (const child of children) {
+        if (child.type === 'door' || child.type === 'window')
+            return true;
+        if (child.type === 'item') {
+            const attachTo = child.asset?.attachTo;
+            if (attachTo === 'wall' || attachTo === 'wall-side')
+                return true;
+        }
+    }
+    return false;
+}

package/dist/wall/index.d.ts

@@ -0,0 +1,3 @@
+export { wallDefinition } from './definition';
+export { WallNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wall/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA"}

package/dist/wall/index.js

@@ -0,0 +1,2 @@
+export { wallDefinition } from './definition';
+export { WallNode } from './schema';

package/dist/wall/measurement.d.ts

@@ -0,0 +1,5 @@
+import { type MeasurementFeature, type MeasurementFeatureBinding, type MeasurementFeatureReference, type WallNode } from '@pascal-app/core';
+export declare function wallMeasurementFeatures(wall: WallNode): MeasurementFeature[];
+export declare function matchWallMeasurementFeature(wall: WallNode, hit: [number, number, number], maxDistance: number): MeasurementFeatureBinding | null;
+export declare function resolveWallMeasurementFeature(wall: WallNode, reference: MeasurementFeatureReference): MeasurementFeature | null;
+//# sourceMappingURL=measurement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAEhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAIzB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CAuF5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA2ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CA6B3B"}