@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/item/__fixtures__/main-floorplan.js

@@ -1,297 +0,0 @@
-import { getBlockFaceFrame, getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
-import { formatLinearMeasurement, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
-import { restingNodePlanFrame } from '../../shared/resting-surface-plan';
-// Plan-space rotation convention used by the legacy `rotatePlanVector`
-// in `editor/src/lib/floorplan/geometry.ts`. This is a CLOCKWISE rotation
-// — the registry-side equivalent of the canonical floor-plan transform
-// math. Don't switch to a standard counter-clockwise rotation; the wall
-// items math (wallRotation = -atan2(dy, dx)) is calibrated against this
-// convention, and the legacy item floor-plan stack reads from these
-// offsets across many sites.
-function rotateVec(x, y, angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    return [x * c + y * s, -x * s + y * c];
-}
-export function resolveItemTransform(item, ctx, cache = new Map()) {
-    const cached = cache.get(item.id);
-    if (cached !== undefined)
-        return cached;
-    const localRotation = item.rotation[1] ?? 0;
-    let result = null;
-    const parentNode = item.parentId
-        ? ctx.resolve(item.parentId)
-        : undefined;
-    if (parentNode?.type === 'wall') {
-        // Wall-aligned: rotate item.position by wall's angle, anchor at wall.start.
-        const wall = parentNode;
-        const wallRotation = -Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
-        const wallLocalZ = item.asset.attachTo === 'wall-side'
-            ? ((wall.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
-            : item.position[2];
-        const [offsetX, offsetY] = rotateVec(item.position[0], wallLocalZ, wallRotation);
-        result = {
-            x: wall.start[0] + offsetX,
-            y: wall.start[1] + offsetY,
-            rotation: wallRotation + localRotation,
-        };
-    }
-    else if (parentNode?.type === 'item') {
-        // Nested item: recursively resolve parent's transform.
-        const parentT = resolveItemTransform(parentNode, ctx, cache);
-        if (parentT) {
-            const [offsetX, offsetY] = rotateVec(item.position[0], item.position[2], parentT.rotation);
-            result = {
-                x: parentT.x + offsetX,
-                y: parentT.y + offsetY,
-                rotation: parentT.rotation + localRotation,
-            };
-        }
-    }
-    else if (parentNode?.type === 'cabinet' ||
-        parentNode?.type === 'cabinet-module' ||
-        parentNode?.type === 'procedural-item') {
-        const f = restingNodePlanFrame(item, ctx.resolve);
-        result = {
-            x: f.position[0],
-            y: f.position[2],
-            rotation: Math.atan2(f.axes[2][0], f.axes[2][2]),
-        };
-    }
-    else if (parentNode?.type === 'shelf') {
-        // Shelf-hosted item: `item.position` is in shelf-local coords. The
-        // shelf has its own `position` + `rotation[1]` in its parent (level)
-        // frame, so the item's plan-space position composes the shelf's
-        // pose with the item's local offset. Without this branch the
-        // `else` below would treat shelf-local coords as level-local and
-        // the item would render at the wrong spot whenever the shelf is
-        // anywhere other than (0, 0, 0).
-        //
-        // We also check `useLiveTransforms` for the shelf — if the shelf is
-        // mid-move (3D or 2D), its scene-state `position` is still at the
-        // pre-move spot but the live transform carries the cursor-tracked
-        // position. Reading the live value here keeps the hosted item
-        // following the shelf in 2D throughout the drag, mirroring how the
-        // shelf's own entry follows via the layer's effectiveNode override.
-        const shelf = parentNode;
-        const live = useLiveTransforms.getState().get(shelf.id);
-        if (shelf.parentId &&
-            ['item', 'shelf', 'cabinet', 'cabinet-module', 'procedural-item'].includes(ctx.resolve(shelf.parentId)?.type ?? '')) {
-            const parentT = resolveItemTransform({
-                ...shelf,
-                position: live?.position ?? shelf.position,
-                rotation: [0, live?.rotation ?? shelf.rotation[1], 0],
-            }, ctx, cache);
-            if (!parentT)
-                return null;
-            const [x, y] = rotateVec(item.position[0], item.position[2], parentT.rotation);
-            return { x: parentT.x + x, y: parentT.y + y, rotation: parentT.rotation + localRotation };
-        }
-        const shelfX = live?.position[0] ?? shelf.position[0];
-        const shelfZ = live?.position[2] ?? shelf.position[2];
-        const shelfRotationY = live?.rotation ?? shelf.rotation[1] ?? 0;
-        const [offsetX, offsetY] = rotateVec(item.position[0], item.position[2], shelfRotationY);
-        result = {
-            x: shelfX + offsetX,
-            y: shelfZ + offsetY,
-            rotation: shelfRotationY + localRotation,
-        };
-    }
-    else if (parentNode?.type === 'roof-segment') {
-        // Roof-hosted wall item: FACE-LOCAL position mapped through the face
-        // frame, then composed through the segment's and parent roof's poses
-        // into level-local plan coords.
-        const segment = parentNode;
-        const roof = segment.parentId
-            ? ctx.resolve(segment.parentId)
-            : undefined;
-        if (roof?.type === 'roof' && item.roofFace) {
-            const frame = getRoofWallFaceFrame(segment, item.roofFace);
-            const segLocal = roofFacePointToSegment(segment, item.roofFace, item.position);
-            const [sx, sz] = rotateVec(segLocal[0], segLocal[2], segment.rotation ?? 0);
-            const [rx, rz] = rotateVec(sx + segment.position[0], sz + segment.position[2], roof.rotation ?? 0);
-            result = {
-                x: rx + roof.position[0],
-                y: rz + roof.position[2],
-                rotation: (roof.rotation ?? 0) + (segment.rotation ?? 0) + frame.yaw + localRotation,
-            };
-        }
-    }
-    else if (parentNode?.type === 'block' && item.blockFaceId) {
-        const frame = getBlockFaceFrame(parentNode.topology, item.blockFaceId);
-        if (frame) {
-            const localX = frame.origin[0] +
-                frame.xAxis[0] * item.position[0] +
-                frame.yAxis[0] * item.position[1] +
-                frame.normal[0] * item.position[2];
-            const localZ = frame.origin[2] +
-                frame.xAxis[2] * item.position[0] +
-                frame.yAxis[2] * item.position[1] +
-                frame.normal[2] * item.position[2];
-            const hostRotation = parentNode.rotation ?? 0;
-            const [offsetX, offsetZ] = rotateVec(localX, localZ, hostRotation);
-            const faceRotation = -Math.atan2(frame.xAxis[2], frame.xAxis[0]);
-            result = {
-                x: parentNode.position[0] + offsetX,
-                y: parentNode.position[2] + offsetZ,
-                rotation: hostRotation + faceRotation + localRotation,
-            };
-        }
-    }
-    else {
-        // Level / slab / ceiling parent — item.position is level-local.
-        result = {
-            x: item.position[0],
-            y: item.position[2],
-            rotation: localRotation,
-        };
-    }
-    cache.set(item.id, result);
-    return result;
-}
-export function buildItemContextualDimensions(node, ctx) {
-    const transform = resolveItemTransform(node, ctx);
-    if (!transform)
-        return null;
-    const [width, , depth] = getScaledDimensions(node);
-    if (width <= 1e-6 || depth <= 1e-6)
-        return null;
-    const centerLocalZ = node.asset.attachTo === 'wall-side' ? depth / 2 : 0;
-    const [centerOffsetX, centerOffsetY] = rotateVec(0, centerLocalZ, transform.rotation);
-    const cx = transform.x + centerOffsetX;
-    const cy = transform.y + centerOffsetY;
-    const halfWidth = width / 2;
-    const halfDepth = depth / 2;
-    const point = (x, y) => {
-        const [rx, ry] = rotateVec(x, y, transform.rotation);
-        return [cx + rx, cy + ry];
-    };
-    const widthNormal = rotateVec(0, -1, transform.rotation);
-    const depthNormal = rotateVec(1, 0, transform.rotation);
-    const unit = ctx.viewState?.unit ?? 'metric';
-    const metricNotation = readFloorplanMetricNotationOverride(ctx) ?? 'meters';
-    const stroke = ctx.viewState?.palette?.selectedStroke ?? '#2563eb';
-    return {
-        kind: 'group',
-        children: [
-            {
-                kind: 'dimension',
-                start: point(-halfWidth, -halfDepth),
-                end: point(halfWidth, -halfDepth),
-                offsetNormal: widthNormal,
-                offsetDistance: 0.28,
-                extensionOvershoot: 0.08,
-                text: formatLinearMeasurement(width, unit, metricNotation),
-                stroke,
-            },
-            {
-                kind: 'dimension',
-                start: point(halfWidth, -halfDepth),
-                end: point(halfWidth, halfDepth),
-                offsetNormal: depthNormal,
-                offsetDistance: 0.28,
-                extensionOvershoot: 0.08,
-                text: formatLinearMeasurement(depth, unit, metricNotation),
-                stroke,
-            },
-        ],
-    };
-}
-export function buildItemFloorplan(node, ctx) {
-    const transform = resolveItemTransform(node, ctx);
-    if (!transform)
-        return null;
-    const [width, , depth] = getScaledDimensions(node);
-    if (width <= 0 || depth <= 0)
-        return null;
-    // Wall-side items are anchored at the mounted wall face; their body extends
-    // depth-ward AWAY from the wall (into the room), so push the footprint centre
-    // a half-depth out along the item's local +Z. After the front/back π flip in
-    // `transform.rotation`, +depth/2 always points off the wall for either side;
-    // a negative offset would lay the footprint across the wall onto the far side.
-    const centerLocalZ = node.asset.attachTo === 'wall-side' ? depth / 2 : 0;
-    const [centerOffsetX, centerOffsetY] = rotateVec(0, centerLocalZ, transform.rotation);
-    const cx = transform.x + centerOffsetX;
-    const cy = transform.y + centerOffsetY;
-    // Rectangle corners in local space, rotated and translated.
-    const halfW = width / 2;
-    const halfD = depth / 2;
-    const corners = [
-        [-halfW, -halfD],
-        [halfW, -halfD],
-        [halfW, halfD],
-        [-halfW, halfD],
-    ];
-    const points = corners.map(([x, y]) => {
-        const [rx, ry] = rotateVec(x, y, transform.rotation);
-        return [cx + rx, cy + ry];
-    });
-    const isSelected = ctx.viewState?.selected ?? false;
-    // Marquee preview — the about-to-be-selected tint every other kind shows.
-    const isHighlighted = ctx.viewState?.highlighted ?? false;
-    const showSelection = isSelected || isHighlighted;
-    const isMoving = ctx.viewState?.moving ?? false;
-    const selectedStroke = ctx.viewState?.palette?.selectedStroke ?? '#3b82f6';
-    const floorPlanUrl = node.asset.floorPlanUrl;
-    const children = [
-        {
-            kind: 'polygon',
-            points,
-            // When an asset thumbnail is present, the polygon is a transparent
-            // hit-target — the image carries the visual weight. Without a
-            // thumbnail the polygon needs a light fill to read at all.
-            //
-            // `transparent` (not `none`) so the interior remains hit-testable —
-            // the registry layer's wrapping `<g>` only fires onPointerDown when
-            // the child renders a paintable surface. `fill="none"` would make
-            // clicks pass through to whatever's beneath, breaking selection.
-            fill: floorPlanUrl ? 'transparent' : '#fef3c7',
-            // Selected items read as selected: palette stroke + heavier weight
-            // (the move dot used to be the only cue, and it hides in
-            // multi-selections).
-            stroke: showSelection ? selectedStroke : '#92400e',
-            strokeWidth: showSelection ? 0.035 : 0.012,
-            opacity: 0.85,
-        },
-    ];
-    // Asset thumbnail — top-down PNG capture from the asset modal. Drawn
-    // inside the footprint with the item's rotation applied. Matches the
-    // legacy `FloorplanItemImage` overlay.
-    if (floorPlanUrl) {
-        children.push({
-            kind: 'image',
-            url: floorPlanUrl,
-            center: [cx, cy],
-            width,
-            height: depth,
-            // `rotateVec` (the footprint polygon) applies R(-angle), but the renderer
-            // draws the image with SVG `rotate(+deg)` = R(+angle). Negate so the
-            // sprite rotates the same way as its footprint box (and 3D); otherwise the
-            // two counter-rotate and diverge by 2x the item's rotation.
-            rotation: -transform.rotation,
-        });
-    }
-    // Selection ring ABOVE the thumbnail — the base polygon's selected stroke
-    // sits underneath the image, so re-draw it on top. `fill: none` keeps the
-    // ring click-through; the base polygon owns hit-testing.
-    if (showSelection && floorPlanUrl) {
-        children.push({
-            kind: 'polygon',
-            points,
-            fill: 'none',
-            stroke: selectedStroke,
-            strokeWidth: 0.035,
-            opacity: isSelected ? 0.95 : 0.7,
-        });
-    }
-    // Move handle — orange dot at the item center. Only when selected and not
-    // already moving: during a move the dot sits under the cursor, so a release
-    // over it would re-arm the move (and re-enter edit) instead of committing.
-    if (isSelected && !isMoving) {
-        children.push({
-            kind: 'move-handle',
-            point: [cx, cy],
-        });
-    }
-    return { kind: 'group', children };
-}

package/dist/lean-to-extension/slots.d.ts

@@ -1,5 +0,0 @@
-import type { SlotDeclaration } from '@pascal-app/core';
-export type LeanToSlotId = 'flashing' | 'ledger' | 'beam' | 'framing' | 'posts' | 'footings';
-export declare const LEAN_TO_SLOT_DEFAULTS: Partial<Record<LeanToSlotId, string>>;
-export declare function leanToSlots(): SlotDeclaration[];
-//# sourceMappingURL=slots.d.ts.map

package/dist/lean-to-extension/slots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,CAAA;AAE5F,eAAO,MAAM,qBAAqB,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAIvE,CAAA;AAED,wBAAgB,WAAW,IAAI,eAAe,EAAE,CAS/C"}

package/dist/lean-to-extension/slots.js

@@ -1,15 +0,0 @@
-export const LEAN_TO_SLOT_DEFAULTS = {
-    flashing: 'library:metal-steel',
-    posts: 'library:concrete-plaster',
-    footings: 'library:concrete-plaster',
-};
-export function leanToSlots() {
-    return [
-        { slotId: 'flashing', label: 'Flashing', default: LEAN_TO_SLOT_DEFAULTS.flashing },
-        { slotId: 'ledger', label: 'Ledger / high beam', default: LEAN_TO_SLOT_DEFAULTS.ledger },
-        { slotId: 'beam', label: 'Low beam', default: LEAN_TO_SLOT_DEFAULTS.beam },
-        { slotId: 'framing', label: 'Framing', default: LEAN_TO_SLOT_DEFAULTS.framing },
-        { slotId: 'posts', label: 'Posts', default: LEAN_TO_SLOT_DEFAULTS.posts },
-        { slotId: 'footings', label: 'Footings', default: LEAN_TO_SLOT_DEFAULTS.footings },
-    ];
-}

package/dist/shelf/slots.d.ts

@@ -1,9 +0,0 @@
-import type { SlotDeclaration } from '@pascal-app/core';
-import type { ShelfNode } from './schema';
-export type ShelfSlotId = 'shelves' | 'frame' | 'back';
-export declare const SHELF_SLOT_DEFAULT_COLOR = "#ffffff";
-/** Map a builder mesh name to its slot id (null = not a paintable shelf part). */
-export declare function shelfSlotIdForMeshName(name: string): ShelfSlotId | null;
-/** Which slots a given shelf actually exposes (depends on style/flags). */
-export declare function shelfSlots(node: ShelfNode): SlotDeclaration[];
-//# sourceMappingURL=slots.d.ts.map

package/dist/shelf/slots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/shelf/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;AAGtD,eAAO,MAAM,wBAAwB,YAAY,CAAA;AAEjD,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAavE;AAED,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,EAAE,CAS7D"}

package/dist/shelf/slots.js

@@ -1,30 +0,0 @@
-// Visual parity with the retired DEFAULT_SHELF_MATERIAL (off-white).
-export const SHELF_SLOT_DEFAULT_COLOR = '#ffffff';
-/** Map a builder mesh name to its slot id (null = not a paintable shelf part). */
-export function shelfSlotIdForMeshName(name) {
-    if (name.startsWith('shelf-board'))
-        return 'shelves';
-    if (name === 'shelf-back')
-        return 'back';
-    if (name.startsWith('shelf-side') ||
-        name.startsWith('shelf-post') ||
-        name.startsWith('shelf-divider') ||
-        name.startsWith('shelf-bracket') ||
-        name.startsWith('shelf-brace')) {
-        return 'frame';
-    }
-    return null;
-}
-/** Which slots a given shelf actually exposes (depends on style/flags). */
-export function shelfSlots(node) {
-    const slots = [
-        { slotId: 'shelves', label: 'Shelves', default: SHELF_SLOT_DEFAULT_COLOR },
-    ];
-    const hasFrame = !(node.style === 'wall-shelf' && node.bracketStyle === 'hidden');
-    if (hasFrame)
-        slots.push({ slotId: 'frame', label: 'Frame', default: SHELF_SLOT_DEFAULT_COLOR });
-    const hasBack = node.style === 'cubby' || (node.style === 'bookshelf' && node.withBack);
-    if (hasBack)
-        slots.push({ slotId: 'back', label: 'Back', default: SHELF_SLOT_DEFAULT_COLOR });
-    return slots;
-}

package/dist/slab/slots.d.ts

@@ -1,10 +0,0 @@
-import type { SlotDeclaration } from '@pascal-app/core';
-export type SlabSlotId = 'surface' | 'side';
-export declare const SLAB_TOP_SLOT_DEFAULT = "library:wood-woodplank48";
-export declare const SLAB_SIDE_SLOT_DEFAULT = "#cccccc";
-/**
- * A slab exposes two paintable faces: the top floor surface and its sides
- * (vertical walls + underside).
- */
-export declare function slabSlots(): SlotDeclaration[];
-//# sourceMappingURL=slots.d.ts.map

package/dist/slab/slots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/slab/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,MAAM,CAAA;AAU3C,eAAO,MAAM,qBAAqB,6BAA6B,CAAA;AAC/D,eAAO,MAAM,sBAAsB,YAAY,CAAA;AAE/C;;;GAGG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CAK7C"}

package/dist/slab/slots.js

@@ -1,20 +0,0 @@
-// Declared default appearances for an unpainted slab in colored mode — a
-// catalog `library:<id>` finish or a `#rrggbb` colour. Textures-off collapses
-// both to the themed floor role (the escape hatch).
-//
-// `surface` (top face) keeps the wood floor default and the slot id used before
-// the top/side split, so existing painted slabs keep their floor finish. `side`
-// (walls + underside) defaults to a light grey so a slab's edges read as a
-// distinct trim rather than wood end-grain.
-export const SLAB_TOP_SLOT_DEFAULT = 'library:wood-woodplank48';
-export const SLAB_SIDE_SLOT_DEFAULT = '#cccccc';
-/**
- * A slab exposes two paintable faces: the top floor surface and its sides
- * (vertical walls + underside).
- */
-export function slabSlots() {
-    return [
-        { slotId: 'surface', label: 'Top', default: SLAB_TOP_SLOT_DEFAULT },
-        { slotId: 'side', label: 'Sides', default: SLAB_SIDE_SLOT_DEFAULT },
-    ];
-}

package/dist/stair/floor-stack.d.ts

@@ -1,10 +0,0 @@
-import type { AnyNode, AnyNodeId, FloorPlacedFootprint, StairNode, StairSegmentNode } from '@pascal-app/core';
-type SegmentTransform = {
-    position: [number, number, number];
-    rotation: number;
-};
-export declare function getStairFloorPlacedFootprints(stair: StairNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): FloorPlacedFootprint[];
-export declare function getStairSegmentFloorPlacedFootprints(stair: StairNode, segments: readonly StairSegmentNode[]): FloorPlacedFootprint[];
-export declare function computeStairSegmentFloorStackTransforms(segments: readonly StairSegmentNode[]): SegmentTransform[];
-export {};
-//# sourceMappingURL=floor-stack.d.ts.map

package/dist/stair/floor-stack.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor-stack.d.ts","sourceRoot":"","sources":["../../src/stair/floor-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,oBAAoB,EAAE,CAUxB;AA+CD,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,oBAAoB,EAAE,CA4BxB;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,gBAAgB,EAAE,CAgDpB"}

package/dist/stair/floor-stack.js

@@ -1,115 +0,0 @@
-export function getStairFloorPlacedFootprints(stair, nodes) {
-    if ((stair.stairType ?? 'straight') !== 'straight') {
-        return getArcStairFloorPlacedFootprints(stair);
-    }
-    const segments = (stair.children ?? [])
-        .map((childId) => nodes[childId])
-        .filter((node) => node?.type === 'stair-segment');
-    return getStairSegmentFloorPlacedFootprints(stair, segments);
-}
-const MAX_ARC_FOOTPRINT_SWEEP = Math.PI / 12;
-function getArcStairFloorPlacedFootprints(stair) {
-    const isSpiral = stair.stairType === 'spiral';
-    const innerRadius = Math.max(isSpiral ? 0.05 : 0.2, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9));
-    const outerRadius = innerRadius + Math.max(stair.width ?? 1, 0.4);
-    const sweepAngle = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
-    const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
-    const sliceCount = Math.max(stepCount, Math.ceil(Math.abs(sweepAngle) / MAX_ARC_FOOTPRINT_SWEEP));
-    const footprints = [];
-    for (let index = 0; index < sliceCount; index += 1) {
-        const startAngle = -sweepAngle / 2 + (sweepAngle * index) / sliceCount;
-        const endAngle = -sweepAngle / 2 + (sweepAngle * (index + 1)) / sliceCount;
-        const midAngle = (startAngle + endAngle) / 2;
-        const halfSweep = Math.abs(endAngle - startAngle) / 2;
-        const projectedInnerRadius = innerRadius * Math.cos(halfSweep);
-        const radialSize = outerRadius - projectedInnerRadius;
-        const tangentialSize = 2 * outerRadius * Math.sin(halfSweep);
-        const centerRadius = (outerRadius + projectedInnerRadius) / 2;
-        const [offsetX, offsetZ] = rotateXZ(Math.cos(midAngle) * centerRadius, Math.sin(midAngle) * centerRadius, stair.rotation);
-        footprints.push({
-            position: [stair.position[0] + offsetX, stair.position[1], stair.position[2] + offsetZ],
-            dimensions: [Math.max(radialSize, 0.01), 0.01, Math.max(tangentialSize, 0.01)],
-            rotation: [0, midAngle - stair.rotation, 0],
-        });
-    }
-    if (isSpiral && (stair.showCenterColumn ?? true)) {
-        const columnRadius = Math.max(0.05, Math.min(innerRadius * 0.72, innerRadius - 0.03));
-        footprints.push({
-            position: stair.position,
-            dimensions: [columnRadius * 2, 0.01, columnRadius * 2],
-            rotation: [0, 0, 0],
-        });
-    }
-    return footprints;
-}
-export function getStairSegmentFloorPlacedFootprints(stair, segments) {
-    const transforms = computeStairSegmentFloorStackTransforms(segments);
-    return segments.map((segment, index) => {
-        const transform = transforms[index];
-        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
-        const centerInGroupX = transform.position[0] + centerOffsetX;
-        const centerInGroupZ = transform.position[2] + centerOffsetZ;
-        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stair.rotation);
-        return {
-            position: [
-                stair.position[0] + centerOffsetWorldX,
-                stair.position[1] + transform.position[1],
-                stair.position[2] + centerOffsetWorldZ,
-            ],
-            dimensions: [
-                segment.width,
-                Math.max(segment.height, segment.thickness, 0.01),
-                segment.length,
-            ],
-            rotation: [0, stair.rotation + transform.rotation, 0],
-        };
-    });
-}
-export function computeStairSegmentFloorStackTransforms(segments) {
-    const transforms = [];
-    let currentX = 0;
-    let currentY = 0;
-    let currentZ = 0;
-    let currentRot = 0;
-    for (let index = 0; index < segments.length; index += 1) {
-        const segment = segments[index];
-        if (index > 0) {
-            const previous = segments[index - 1];
-            let attachX = 0;
-            let attachZ = 0;
-            let rotationDelta = 0;
-            switch (segment.attachmentSide) {
-                case 'front':
-                    attachX = 0;
-                    attachZ = previous.length;
-                    rotationDelta = 0;
-                    break;
-                case 'left':
-                    attachX = previous.width / 2;
-                    attachZ = previous.length / 2;
-                    rotationDelta = Math.PI / 2;
-                    break;
-                case 'right':
-                    attachX = -previous.width / 2;
-                    attachZ = previous.length / 2;
-                    rotationDelta = -Math.PI / 2;
-                    break;
-            }
-            const [rotatedX, rotatedZ] = rotateXZ(attachX, attachZ, currentRot);
-            currentX += rotatedX;
-            currentY += previous.height;
-            currentZ += rotatedZ;
-            currentRot += rotationDelta;
-        }
-        transforms.push({
-            position: [currentX, currentY, currentZ],
-            rotation: currentRot,
-        });
-    }
-    return transforms;
-}
-function rotateXZ(x, z, angle) {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    return [x * cos + z * sin, -x * sin + z * cos];
-}

package/dist/stair/slots.d.ts

@@ -1,7 +0,0 @@
-import type { SlotDeclaration, StairNode } from '@pascal-app/core';
-export type StairSlotId = 'treads' | 'body' | 'railing';
-export declare const STAIR_TREADS_SLOT_DEFAULT = "library:wood-woodplank48";
-export declare const STAIR_BODY_SLOT_DEFAULT = "library:preset-lightgrey";
-export declare const STAIR_RAILING_SLOT_DEFAULT = "library:metal-steel";
-export declare function stairSlots(node: StairNode): SlotDeclaration[];
-//# sourceMappingURL=slots.d.ts.map

package/dist/stair/slots.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/stair/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAElE,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAA;AAEvD,eAAO,MAAM,yBAAyB,6BAA6B,CAAA;AACnE,eAAO,MAAM,uBAAuB,6BAA6B,CAAA;AACjE,eAAO,MAAM,0BAA0B,wBAAwB,CAAA;AAE/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,EAAE,CAW7D"}

package/dist/stair/slots.js

@@ -1,13 +0,0 @@
-export const STAIR_TREADS_SLOT_DEFAULT = 'library:wood-woodplank48';
-export const STAIR_BODY_SLOT_DEFAULT = 'library:preset-lightgrey';
-export const STAIR_RAILING_SLOT_DEFAULT = 'library:metal-steel';
-export function stairSlots(node) {
-    const slots = [
-        { slotId: 'treads', label: 'Treads', default: STAIR_TREADS_SLOT_DEFAULT },
-        { slotId: 'body', label: 'Body', default: STAIR_BODY_SLOT_DEFAULT },
-    ];
-    if (node.railingMode && node.railingMode !== 'none') {
-        slots.push({ slotId: 'railing', label: 'Railing', default: STAIR_RAILING_SLOT_DEFAULT });
-    }
-    return slots;
-}

package/dist/wall/drawing-mode.d.ts

@@ -1,12 +0,0 @@
-export declare const useWallDrawingMode: import("zustand").UseBoundStore<import("zustand").StoreApi<{
-    mode: "line" | "rectangle";
-    toggle: () => void;
-}>>;
-/**
- * R toggles line / rectangle drawing (the HUD's Shape chip cycles the same
- * store). Both wall tools mount this: the 3D tool only exists once the canvas
- * does, and split view mounts both, so one listener serves whichever is up.
- * The mode outlives the tool: re-arming walls resumes the last shape used.
- */
-export declare function useWallDrawingModeKeys(): void;
-//# sourceMappingURL=drawing-mode.d.ts.map

package/dist/wall/drawing-mode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drawing-mode.d.ts","sourceRoot":"","sources":["../../src/wall/drawing-mode.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,kBAAkB;UACvB,MAAM,GAAG,WAAW;YAClB,MAAM,IAAI;GAOjB,CAAA;AAWH;;;;;GAKG;AACH,wBAAgB,sBAAsB,SAOrC"}

package/dist/wall/drawing-mode.js

@@ -1,38 +0,0 @@
-import { emitter } from '@pascal-app/core';
-import { isEditableKeyboardTarget } from '@pascal-app/editor';
-import { useEffect } from 'react';
-import { create } from 'zustand';
-export const useWallDrawingMode = create((set, get) => ({
-    mode: 'line',
-    toggle: () => {
-        emitter.emit('tool:cancel');
-        set({ mode: get().mode === 'rectangle' ? 'line' : 'rectangle' });
-    },
-}));
-const onKeyDown = (e) => {
-    if (e.repeat || e.metaKey || e.ctrlKey || e.altKey)
-        return;
-    if (e.key !== 'r' && e.key !== 'R')
-        return;
-    if (isEditableKeyboardTarget(e.target))
-        return;
-    e.preventDefault();
-    useWallDrawingMode.getState().toggle();
-};
-let owners = 0;
-/**
- * R toggles line / rectangle drawing (the HUD's Shape chip cycles the same
- * store). Both wall tools mount this: the 3D tool only exists once the canvas
- * does, and split view mounts both, so one listener serves whichever is up.
- * The mode outlives the tool: re-arming walls resumes the last shape used.
- */
-export function useWallDrawingModeKeys() {
-    useEffect(() => {
-        if (owners++ === 0)
-            window.addEventListener('keydown', onKeyDown);
-        return () => {
-            if (--owners === 0)
-                window.removeEventListener('keydown', onKeyDown);
-        };
-    }, []);
-}

package/dist/wall/slots.d.ts

@@ -1,10 +0,0 @@
-import { type SlotDeclaration, type WallNode } from '@pascal-app/core';
-/**
- * A wall exposes two paintable faces — interior + exterior. Painting writes
- * `node.slots[interior|exterior]` via `wallPaint` like every other kind; this
- * declaration surfaces the slot list + declared defaults for the picker and
- * keeps walls on the same `{ slotId, label, default }` contract. The defaults
- * come from core so the viewer's material resolver renders the identical value.
- */
-export declare function wallSlots(node?: WallNode): SlotDeclaration[];
-//# sourceMappingURL=slots.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/wall/slots.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,eAAe,EAAE,CAmF5D"}