@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/column/post-placement.js

@@ -0,0 +1,157 @@
+import { beamBottomElevation, createFramingPost, DEFAULT_FRAMING_POST_SIZE, emitter, FRAMING_POST_SIZES, framingPostFields, framingPostSize, framingPostTopAt, getFloorPlacedElevation, postStationsAlong, } from '@pascal-app/core';
+import { getMovingNode, isGridSnapActive, snapBuildingLocalToWorldGrid, snapWallDraftPointDetailed, useEditor, } from '@pascal-app/editor';
+/** Posts no further apart than this under a beam the panel posts: 8 ft, as a porch's are. */
+export const FRAMING_POST_SPACING = 8 * 12 * 0.0254;
+/**
+ * The Post tool is the column tool armed with a framing post's fields (`toolDefaults.column`,
+ * `role: 'post'`): its size and base, or null while it places ornamental columns.
+ */
+export function framingPostToolChoices(defaults) {
+    if (defaults?.role !== 'post')
+        return null;
+    const width = typeof defaults.width === 'number' ? defaults.width : undefined;
+    const size = (width !== undefined && framingPostSize({ width, depth: width })) || DEFAULT_FRAMING_POST_SIZE;
+    const base = defaults.postBase;
+    return {
+        size,
+        base: base === 'post-base' || base === 'pier' ? base : 'none',
+    };
+}
+/** The column tool's defaults that make it the Post tool: a post of this size and base. */
+export function framingPostToolDefaults(size = DEFAULT_FRAMING_POST_SIZE, base = 'none') {
+    return { ...framingPostFields(size, base) };
+}
+/**
+ * Drops a preset still following the cursor (a column preset's clone on the move tool): while it
+ * moves, no build tool mounts.
+ */
+export function dropInflightColumnPlacement() {
+    if (!getMovingNode())
+        return;
+    emitter.emit('tool:cancel');
+    useEditor.getState().setMovingNode(null);
+}
+/**
+ * The size and base last picked, kept apart from the tool's defaults: a host clears those when it
+ * arms the column tool from a tile, and the Post tile should come back as the user left it.
+ */
+let lastChoices = { size: DEFAULT_FRAMING_POST_SIZE, base: 'none' };
+/**
+ * Arms the column tool as the Post tool (the Build panel's Post tile): a post of `size` on `base`,
+ * else as the tool has them, else as they were last picked.
+ */
+export function armFramingPostTool(size, base) {
+    dropInflightColumnPlacement();
+    const editor = useEditor.getState();
+    const current = framingPostToolChoices(editor.toolDefaults.column) ?? lastChoices;
+    lastChoices = { size: size ?? current.size, base: base ?? current.base };
+    editor.setToolDefaults('column', framingPostToolDefaults(lastChoices.size, lastChoices.base));
+    if (!(editor.mode === 'build' && editor.tool === 'column'))
+        editor.armToolMode({ mode: 'build', tool: 'column' });
+}
+/** A point the wall snap reads as a wall: a segment of no length catches at the point. */
+function pointReference(id, parentId, at) {
+    return {
+        object: 'node',
+        id: id,
+        type: 'wall',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        start: at,
+        end: at,
+        frontSide: 'unknown',
+        backSide: 'unknown',
+    };
+}
+/**
+ * What a post set on `levelId` snaps to: each beam's centreline (its ends, its middle and its run,
+ * so a post lands under a beam end or anywhere along it) and the other posts' and columns'
+ * centres.
+ */
+export function postSnapTargets(nodes, levelId, ignoreIds = []) {
+    const targets = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== levelId || node.visible === false || ignoreIds.includes(node.id))
+            continue;
+        if (node.type === 'beam') {
+            targets.push({ ...pointReference(node.id, node.parentId, node.start), end: node.end });
+        }
+        else if (node.type === 'column') {
+            targets.push(pointReference(node.id, node.parentId, [node.position[0], node.position[2]]));
+        }
+    }
+    return targets;
+}
+/**
+ * A post's plan point, snapped: a beam end, a point along a beam or another post catch it within
+ * the snap's reach, otherwise the grid while it snaps. `free` (Alt) places it as it is.
+ */
+export function snapPostPoint(args) {
+    if (args.free)
+        return { point: args.point, snap: null };
+    const step = useEditor.getState().gridSnapStep;
+    const grid = isGridSnapActive();
+    const result = snapWallDraftPointDetailed({
+        point: args.point,
+        walls: postSnapTargets(args.nodes, args.levelId, args.ignoreIds),
+        // Beams and posts always catch a post; the grid is the snapping mode's to give.
+        magnetic: true,
+        gridSnap: (point) => (grid ? snapBuildingLocalToWorldGrid(point, step) : point),
+    });
+    return { point: result.point, snap: result.snap };
+}
+/** The runtime foot: the elected support's top under the post, plus its own lift. */
+export const electedPostFoot = (nodes, levelId) => (post) => getFloorPlacedElevation({
+    node: post,
+    nodes: nodes,
+    position: post.position,
+    levelId,
+}) + post.position[1];
+/**
+ * A framing post at a plan point, standing from its foot up to the underside of the beam over it,
+ * else to the ceiling plane: what the Post tool places, and its ghost.
+ */
+export function framingPostAt(args) {
+    const draft = createFramingPost({
+        position: args.point,
+        size: args.choices.size,
+        base: args.choices.base,
+        levelId: args.levelId,
+    });
+    const base = args.foot(draft);
+    const { top, beamId } = framingPostTopAt(args.nodes, args.levelId, args.point, {
+        baseElevation: base,
+        side: FRAMING_POST_SIZES[args.choices.size],
+    });
+    return {
+        post: createFramingPost({
+            position: args.point,
+            size: args.choices.size,
+            base: args.choices.base,
+            levelId: args.levelId,
+            height: top - base,
+        }),
+        beamId,
+    };
+}
+/**
+ * Posts under a beam: one at each end and evenly between, no further apart than `spacing`, each
+ * from its foot up to this beam's underside. Skips a station a post already stands at.
+ */
+export function framingPostsUnderBeam(args) {
+    const levelId = args.beam.parentId;
+    if (!levelId)
+        return [];
+    const standing = Object.values(args.nodes).filter((node) => node.type === 'column' && node.parentId === levelId);
+    const underside = beamBottomElevation(args.nodes, args.beam);
+    return postStationsAlong(args.beam.start, args.beam.end, args.spacing ?? FRAMING_POST_SPACING)
+        .filter((point) => !standing.some((post) => Math.hypot(post.position[0] - point[0], post.position[2] - point[1]) <
+        Math.max(post.width, FRAMING_POST_SIZES[args.choices.size])))
+        .map((point) => {
+        const fields = { position: point, ...args.choices, levelId };
+        const foot = args.foot(createFramingPost(fields));
+        return createFramingPost({ ...fields, height: underside - foot });
+    });
+}

package/dist/column/post-section.d.ts

@@ -0,0 +1,17 @@
+import { type AnyNode, type AnyNodeId, type ColumnNode, type FramingPostSize } from '@pascal-app/core';
+/** The fields that make a post another square size, its base kept in proportion. */
+export declare function framingPostSizePatch(post: ColumnNode, size: FramingPostSize): Partial<ColumnNode>;
+/** Where a post's top goes: the beam over it, else the ceiling plane, and its height to it from its foot. */
+export declare function framingPostFit(nodes: Record<AnyNodeId, AnyNode>, post: ColumnNode, foot: number): {
+    height: number;
+    beamId: string | null;
+} | null;
+/**
+ * A framing post's settings in the column panel, in place of a column's styles: its size, its
+ * base, its wood, its height with a fit to the beam over it, and the deck-post height check.
+ */
+export declare function FramingPostSection({ node, onUpdate, }: {
+    node: ColumnNode;
+    onUpdate: (updates: Partial<ColumnNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=post-section.d.ts.map

package/dist/column/post-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-section.d.ts","sourceRoot":"","sources":["../../src/column/post-section.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,UAAU,EAKf,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAczB,oFAAoF;AACpF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAWjG;AAED,6GAA6G;AAC7G,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,CASlD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;CACjD,+BAyHA"}

package/dist/column/post-section.js

@@ -0,0 +1,95 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FRAMING_POST_BASE_LABELS, FRAMING_POST_MATERIAL_REF, FRAMING_POST_SIZES, framingPostBasePatch, framingPostHeightLimit, framingPostSize, framingPostTopAt, usePascalI18n, useScene, } from '@pascal-app/core';
+import { formatLinearMeasurement, MetricControl, PanelSection, SegmentedControl, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { electedPostFoot } from './post-placement.js';
+/** Sawn lumber for a post kept dry inside; a post's default is treated (`FRAMING_POST_MATERIAL_REF`). */
+const UNTREATED_REF = 'library:wood-woodfine2';
+const CUSTOM = 'custom';
+/** The fields that make a post another square size, its base kept in proportion. */
+export function framingPostSizePatch(post, size) {
+    const side = FRAMING_POST_SIZES[size];
+    return {
+        width: side,
+        depth: side,
+        radius: side / 2,
+        ...framingPostBasePatch({ width: side, depth: side, slots: post.slots }, post.postBase ?? 'none'),
+    };
+}
+/** Where a post's top goes: the beam over it, else the ceiling plane, and its height to it from its foot. */
+export function framingPostFit(nodes, post, foot) {
+    if (!post.parentId)
+        return null;
+    const { top, beamId } = framingPostTopAt(nodes, post.parentId, [post.position[0], post.position[2]], { baseElevation: foot, side: post.width });
+    return { height: top - foot, beamId };
+}
+/**
+ * A framing post's settings in the column panel, in place of a column's styles: its size, its
+ * base, its wood, its height with a fit to the beam over it, and the deck-post height check.
+ */
+export function FramingPostSection({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
+    const unit = useViewer((state) => state.unit);
+    const metricNotation = useViewer((state) => state.metricNotation);
+    const nodes = useScene((state) => state.nodes);
+    const size = framingPostSize(node) ?? CUSTOM;
+    const treated = (node.slots?.shaft ?? FRAMING_POST_MATERIAL_REF) === FRAMING_POST_MATERIAL_REF;
+    const limit = framingPostHeightLimit(node);
+    const length = (meters) => formatLinearMeasurement(meters, unit, metricNotation);
+    const fit = node.parentId !== null
+        ? framingPostFit(nodes, node, electedPostFoot(nodes, node.parentId)(node))
+        : null;
+    const fitBeam = fit?.beamId ? nodes[fit.beamId] : undefined;
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.column.postSection.post', message: 'Post' }), children: [_jsx(SegmentedControl, { onChange: (next) => {
+                    if (next !== CUSTOM)
+                        onUpdate(framingPostSizePatch(node, next));
+                }, options: [
+                    ...Object.keys(FRAMING_POST_SIZES).map((value) => ({
+                        label: value,
+                        value,
+                    })),
+                    ...(size === CUSTOM
+                        ? [
+                            {
+                                label: i18n._({ id: 'node.column.postSection.custom', message: 'Custom' }),
+                                value: CUSTOM,
+                            },
+                        ]
+                        : []),
+                ], value: size }), _jsx(SegmentedControl, { onChange: (base) => onUpdate(framingPostBasePatch(node, base)), options: ['none', 'post-base', 'pier'].map((value) => ({
+                    label: FRAMING_POST_BASE_LABELS[value],
+                    value,
+                })), value: node.postBase ?? 'none' }), _jsx(SegmentedControl, { onChange: (wood) => onUpdate({
+                    slots: {
+                        ...node.slots,
+                        shaft: wood === 'treated' ? FRAMING_POST_MATERIAL_REF : UNTREATED_REF,
+                    },
+                }), options: [
+                    {
+                        label: i18n._({ id: 'node.column.postSection.treated', message: 'Treated' }),
+                        value: 'treated',
+                    },
+                    {
+                        label: i18n._({ id: 'node.column.postSection.untreated', message: 'Untreated' }),
+                        value: 'untreated',
+                    },
+                ], value: treated ? 'treated' : 'untreated' }), _jsx(MetricControl, { label: i18n._({ id: 'node.column.postSection.height', message: 'Height' }), min: 0.3, onChange: (height) => onUpdate({ height }), precision: 3, step: 0.01, unit: "m", value: node.height }), fit && Math.abs(fit.height - node.height) > 0.001 && fit.height > 0.3 && (_jsx("button", { className: "self-start rounded-full border border-border/50 px-3 py-1 text-muted-foreground text-xs hover:text-foreground", "data-post-fit": true, onClick: () => onUpdate({ height: fit.height }), type: "button", children: fitBeam
+                    ? i18n._({
+                        id: 'node.column.postSection.fitToTheBeamOverIt',
+                        message: 'Fit to the beam over it ({height})',
+                        values: { height: length(fit.height) },
+                    })
+                    : i18n._({
+                        id: 'node.column.postSection.fitToTheCeilingPlane',
+                        message: 'Fit to the ceiling plane ({height})',
+                        values: { height: length(fit.height) },
+                    }) })), limit && (_jsx("p", { className: "rounded-lg bg-accent/30 px-2.5 py-2 text-muted-foreground text-xs", role: "status", children: i18n._({
+                    id: 'node.column.postSection.aSizeDeckPostStandsNo',
+                    message: 'A {size} deck post stands no taller than {limit} (IRC Table R507.4, by species and the area it carries): check it, or use the next size up.',
+                    values: { size: limit.size, limit: length(limit.limit) },
+                }) })), _jsx("button", { className: "self-start rounded-full border border-border/50 px-3 py-1 text-muted-foreground text-xs hover:text-foreground", onClick: () => onUpdate({ role: undefined, postBase: undefined }), title: i18n._({
+                    id: 'node.column.postSection.keepItsShapeAndStyleIt',
+                    message: 'Keep its shape and style it as a column',
+                }), type: "button", children: i18n._({ id: 'node.column.postSection.makeItAColumn', message: 'Make it a column' }) })] }));
+}

package/dist/column/post-tool.d.ts

@@ -0,0 +1,11 @@
+import { type FramingPostToolChoices } from './post-placement.js';
+/**
+ * The Post tool: the column tool armed with a framing post (`framingPostToolChoices`). The post
+ * snaps under a beam's end, anywhere along a beam, onto another post, else to the grid (Alt free);
+ * it stands from what it lands on up to the underside of the beam over it, else to the ceiling
+ * plane, and the ghost shows that height before the click. Repeats as the column tool does.
+ */
+export declare function FramingPostTool({ choices }: {
+    choices: FramingPostToolChoices;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=post-tool.d.ts.map

package/dist/column/post-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-tool.d.ts","sourceRoot":"","sources":["../../src/column/post-tool.tsx"],"names":[],"mappings":"AA2BA,OAAO,EAEL,KAAK,sBAAsB,EAG5B,MAAM,kBAAkB,CAAA;AAKzB;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,sBAAsB,CAAA;CAAE,sCA2F/E"}

package/dist/column/post-tool.js

@@ -0,0 +1,94 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ColumnNode as ColumnNodeSchema, emitter, resolveSupportSlabPatch, useScene, } from '@pascal-app/core';
+import { getFloorStackPreviewPosition, triggerSFX, useEditor, usePlacementPreview, useWallSnapIndicator, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useRef, useState } from 'react';
+import { stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement.js';
+import { electedPostFoot, framingPostAt, snapPostPoint, } from './post-placement.js';
+import { ColumnPreview } from './renderer.js';
+/**
+ * The Post tool: the column tool armed with a framing post (`framingPostToolChoices`). The post
+ * snaps under a beam's end, anywhere along a beam, onto another post, else to the grid (Alt free);
+ * it stands from what it lands on up to the underside of the beam over it, else to the ceiling
+ * plane, and the ghost shows that height before the click. Repeats as the column tool does.
+ */
+export function FramingPostTool({ choices }) {
+    const levelId = useViewer((state) => state.selection.levelId);
+    const cursorRef = useRef(null);
+    const [ghost, setGhost] = useState(null);
+    useEffect(() => {
+        if (!levelId)
+            return;
+        let last = null;
+        setGhost(null);
+        const place = (raw, free) => {
+            const nodes = useScene.getState().nodes;
+            const { point, snap } = snapPostPoint({ point: raw, nodes, levelId, free });
+            if (snap)
+                useWallSnapIndicator.getState().set({ x: point[0], z: point[1], kind: snap });
+            else
+                useWallSnapIndicator.getState().clear();
+            return {
+                point,
+                ...framingPostAt({ nodes, levelId, point, choices, foot: electedPostFoot(nodes, levelId) }),
+            };
+        };
+        const show = (placed) => {
+            const visual = getFloorStackPreviewPosition({
+                node: placed.post,
+                position: placed.post.position,
+                rotation: 0,
+                levelId,
+            });
+            cursorRef.current?.position.set(...visual);
+            usePlacementPreview.getState().set(placed.post);
+            setGhost(placed.post);
+        };
+        const onMove = (event) => {
+            const next = place([event.localPosition[0], event.localPosition[2]], event.nativeEvent?.altKey === true);
+            if (last &&
+                last.point[0] === next.point[0] &&
+                last.point[1] === next.point[1] &&
+                Math.abs(last.post.height - next.post.height) < 1e-6)
+                return;
+            if (!last || last.point[0] !== next.point[0] || last.point[1] !== next.point[1])
+                triggerSFX('sfx:grid-snap');
+            last = next;
+            show(next);
+        };
+        const onClick = (event) => {
+            // A click on a beam or a post is a node event, its point not the level's: use the move's.
+            const placed = last ??
+                place([event.localPosition[0], event.localPosition[2]], event.nativeEvent?.altKey === true);
+            stopPlacementCommitPropagation(event);
+            const nodes = useScene.getState().nodes;
+            const posts = Object.values(nodes).filter((node) => node.type === 'column' && node.role === 'post').length;
+            const post = ColumnNodeSchema.parse({
+                ...placed.post,
+                name: `Post ${posts + 1}`,
+                ...resolveSupportSlabPatch(placed.post, { ...nodes, [placed.post.id]: placed.post }),
+            });
+            useScene.getState().createNode(post, levelId);
+            triggerSFX('sfx:structure-build');
+            last = null;
+            if (useEditor.getState().getContinuation('point') === 'repeat')
+                return;
+            useViewer.getState().setSelection({ selectedIds: [post.id] });
+            usePlacementPreview.getState().clear();
+            useEditor.getState().setTool(null);
+            useEditor.getState().setMode('select');
+        };
+        emitter.on('grid:move', onMove);
+        const unsubscribeClicks = subscribeFloorPlacementClicks(onClick);
+        return () => {
+            emitter.off('grid:move', onMove);
+            unsubscribeClicks();
+            usePlacementPreview.getState().clear();
+            useWallSnapIndicator.getState().clear();
+        };
+    }, [levelId, choices]);
+    if (!levelId)
+        return null;
+    return (_jsx("group", { ref: cursorRef, visible: ghost !== null, children: ghost && _jsx(ColumnPreview, { node: ghost }) }));
+}

package/dist/column/tool.d.ts

@@ -1,14 +1,7 @@
 /**
- * Registry-driven column placement tool. Mirrors the shelf build tool:
- * a translucent `ColumnPreview` ghost follows the cursor (the piece the
- * legacy editor-side `ColumnTool` lacked — it only showed a sphere), grid
- * snap is layered with Figma-style alignment, and a `grid:click` commits.
- *
- * Lives in `packages/nodes` (not the editor) specifically so it can import
- * the column geometry for the ghost — the editor package can't depend on
- * `nodes`. Wired via `def.tool`, so `ToolManager`'s registry-first path
- * mounts it and the legacy `<ColumnTool>` branch no longer fires.
+ * The column tool, or the Post tool while the Build panel's Post tile has armed it with a framing
+ * post's fields (`toolDefaults.column`, `framingPostToolChoices`).
  */
-declare const ColumnTool: () => import("react").JSX.Element | null;
+declare const ColumnTool: () => import("react").JSX.Element;
 export default ColumnTool;
 //# sourceMappingURL=tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/column/tool.tsx"],"names":[],"mappings":"AAwDA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,UAAU,0CAkMf,CAAA;eAEc,UAAU"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/column/tool.tsx"],"names":[],"mappings":"AAyQA;;;GAGG;AACH,QAAA,MAAM,UAAU,mCAOf,CAAA;eAEc,UAAU"}

package/dist/column/tool.js

@@ -7,6 +7,8 @@ import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement.js';
 import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination.js';
+import { framingPostToolChoices } from './post-placement.js';
+import { FramingPostTool } from './post-tool.js';
 import { ColumnPreview } from './renderer.js';
 const DEFAULT_COLUMN_PRESET_ID = 'basicPillar';
 function createColumnFromPreset(presetId, position) {
@@ -29,7 +31,7 @@ function createColumnFromPreset(presetId, position) {
  * `nodes`. Wired via `def.tool`, so `ToolManager`'s registry-first path
  * mounts it and the legacy `<ColumnTool>` branch no longer fires.
  */
-const ColumnTool = () => {
+const PillarTool = () => {
     const activeLevelId = useViewer((state) => state.selection.levelId);
     const camera = useThree((state) => state.camera);
     const cameraRef = useRef(camera);
@@ -192,4 +194,14 @@ const ColumnTool = () => {
         return null;
     return (_jsx("group", { ref: cursorRef, visible: cursorVisible, children: _jsx(ColumnPreview, { node: previewNode }) }));
 };
+/**
+ * The column tool, or the Post tool while the Build panel's Post tile has armed it with a framing
+ * post's fields (`toolDefaults.column`, `framingPostToolChoices`).
+ */
+const ColumnTool = () => {
+    const size = useEditor((state) => framingPostToolChoices(state.toolDefaults.column)?.size ?? null);
+    const base = useEditor((state) => framingPostToolChoices(state.toolDefaults.column)?.base ?? 'none');
+    const choices = useMemo(() => (size ? { size, base } : null), [size, base]);
+    return choices ? _jsx(FramingPostTool, { choices: choices }) : _jsx(PillarTool, {});
+};
 export default ColumnTool;

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCA4OlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/cupola/panel.tsx"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAuPlC"}

package/dist/cupola/panel.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getActiveRoofHeight, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getActiveRoofHeight, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
@@ -11,6 +11,7 @@ import { useCallback } from 'react';
  * flow the placement tool uses. Mirrors the box-vent panel.
  */
 export default function CupolaPanel() {
+    const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
     const updateNode = useScene((s) => s.updateNode);
@@ -78,11 +79,17 @@ export default function CupolaPanel() {
     }, [selectedId, node, deleteNode, setSelection]);
     if (!(node && node.type === 'cupola' && selectedId))
         return null;
-    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Cupola', width: 300, children: [_jsxs(PanelSection, { title: "Style", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ roofStyle: v }), options: [
-                            { label: 'Dome', value: 'dome' },
-                            { label: 'Pyramid', value: 'pyramid' },
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || i18n._({ id: 'node.cupola.panel.cupola', message: 'Cupola' }), width: 300, children: [_jsxs(PanelSection, { title: i18n._({ id: 'node.cupola.panel.style', message: 'Style' }), children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ roofStyle: v }), options: [
+                            { label: i18n._({ id: 'node.cupola.panel.dome', message: 'Dome' }), value: 'dome' },
+                            {
+                                label: i18n._({ id: 'node.cupola.panel.pyramid', message: 'Pyramid' }),
+                                value: 'pyramid',
+                            },
                         ], value: node.roofStyle ?? 'dome' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ finial: v === 'on' }), options: [
-                            { label: 'Finial', value: 'on' },
-                            { label: 'No Finial', value: 'off' },
-                        ], value: (node.finial ?? true) ? 'on' : 'off' })] }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: "Depth", max: 1000, min: 0.3, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => handleUpdate({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.depth }), _jsx(SliderControl, { label: "Height", max: 1000, min: 0.4, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[0] ?? 0 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[1] ?? 0 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[2] ?? 0 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+                            { label: i18n._({ id: 'node.cupola.panel.finial', message: 'Finial' }), value: 'on' },
+                            {
+                                label: i18n._({ id: 'node.cupola.panel.noFinial', message: 'No Finial' }),
+                                value: 'off',
+                            },
+                        ], value: (node.finial ?? true) ? 'on' : 'off' })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.cupola.panel.dimensions', message: 'Dimensions' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.width', message: 'Width' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ width: v }), onCommit: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), _jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.depth', message: 'Depth' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => handleUpdate({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.depth }), _jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.height', message: 'Height' }), max: 1000, min: 0.4, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.height })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.cupola.panel.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[0] ?? 0 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[1] ?? 0 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.position[2] ?? 0 }), _jsx(SliderControl, { label: i18n._({ id: 'node.cupola.panel.rotation', message: 'Rotation' }), max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: i18n._({ id: 'node.cupola.panel.actions', message: 'Actions' }), children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.cupola.panel.move', message: 'Move' }), onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.cupola.panel.duplicate', message: 'Duplicate' }), onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: i18n._({ id: 'node.cupola.panel.delete', message: 'Delete' }), onClick: handleDelete })] }) })] }));
 }

package/dist/door/actions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The door's action-menu contributions, in 2D and 3D: swap the hinge side and swap the swing
+ * side without opening the panel's Swing section. One undo step each; a closed door opens so
+ * the new swing shows.
+ */
+export default function DoorActions(): import("react").JSX.Element | null;
+//# sourceMappingURL=actions.d.ts.map

package/dist/door/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/door/actions.tsx"],"names":[],"mappings":"AASA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,uCAiClC"}

package/dist/door/actions.js

@@ -0,0 +1,32 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { ActionMenuButton } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { ArrowLeftRight, ArrowUpDown } from 'lucide-react';
+import { applyOpeningSwap } from '../shared/opening-swap.js';
+import { doorMechanism } from './mechanism.js';
+import { canSwapDoorHinge, canSwapDoorSwing, swapDoorHingePatch, swapDoorSwingPatch } from './swing.js';
+/**
+ * The door's action-menu contributions, in 2D and 3D: swap the hinge side and swap the swing
+ * side without opening the panel's Swing section. One undo step each; a closed door opens so
+ * the new swing shows.
+ */
+export default function DoorActions() {
+    const i18n = usePascalI18n();
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const door = useScene((s) => {
+        const node = selected.length === 1 ? s.nodes[selected[0]] : undefined;
+        return node?.type === 'door' ? node : undefined;
+    });
+    const readOnly = useScene((s) => s.readOnly);
+    if (!door || readOnly || !canSwapDoorSwing(door))
+        return null;
+    return (_jsxs(_Fragment, { children: [canSwapDoorHinge(door) ? (_jsx(ActionMenuButton, { label: i18n._({ id: 'node.door.actions.swapHingeSide', message: 'Swap hinge side' }), onClick: (event) => {
+                    event.stopPropagation();
+                    applyOpeningSwap(door, swapDoorHingePatch(door), doorMechanism);
+                }, children: _jsx(ArrowLeftRight, { className: "h-4 w-4" }) })) : null, _jsx(ActionMenuButton, { label: i18n._({ id: 'node.door.actions.swapSwingSide', message: 'Swap swing side' }), onClick: (event) => {
+                    event.stopPropagation();
+                    applyOpeningSwap(door, swapDoorSwingPatch(door), doorMechanism);
+                }, children: _jsx(ArrowUpDown, { className: "h-4 w-4" }) })] }));
+}

package/dist/door/contextual-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/door/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGpF,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAK1B"}
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/door/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIpF,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAkB1B"}

package/dist/door/contextual-dimensions.js

@@ -1,6 +1,16 @@
+import { getDoorOpeningSize, openingHostFacing } from '@pascal-app/core';
 import { buildWallHostedOpeningContextualDimensions } from '../wall/contextual-dimensions.js';
 export function buildDoorContextualDimensions(node, ctx) {
-    return buildWallHostedOpeningContextualDimensions(node, ctx, {
+    const size = getDoorOpeningSize(node);
+    return buildWallHostedOpeningContextualDimensions({
+        ...node,
+        width: size.width,
+        position: [
+            node.position[0] - size.leafOffsetX * openingHostFacing(node),
+            node.position[1],
+            node.position[2],
+        ],
+    }, ctx, {
         showClearancesWhileMoving: false,
         useExteriorNormal: false,
     });

package/dist/door/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AA2BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAiKnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA+H1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/door/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,cAAc,EAGf,MAAM,kBAAkB,CAAA;AA4BzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA8KnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAiJ1D,CAAA"}