@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/column/surface.js

@@ -25,8 +25,10 @@ export function columnTopSurfaces(node) {
     let region;
     if (cap) {
         y = cap.y + cap.height;
-        if (cap.kind === 'round')
-            region = roundRegion(cap.radius, getSegments(node));
+        if (cap.kind === 'round') {
+            const bevel = Math.min(node.edgeSoftness, cap.height * 0.35, cap.radius * 0.35);
+            region = roundRegion(cap.radius - bevel, getSegments(node));
+        }
         else {
             const bevel = Math.min(Math.max(0, node.edgeSoftness ?? 0.025), Math.min(cap.width, cap.depth, cap.height) * 0.35);
             region = { kind: 'rect', size: [cap.width / 2 - bevel, cap.depth / 2 - bevel] };
@@ -34,13 +36,14 @@ export function columnTopSurfaces(node) {
     }
     else {
         const segments = getShaftSegmentCount(node);
-        const scale = getShaftScaleAt(node, (segments - 0.5) / segments);
+        const scale = getShaftScaleAt(node, 1);
         const yaw = getShaftTwistRadians(node, segments - 1);
-        y = layout.shaftY + layout.shaftHeight + (layout.shaftHeight / segments) * 0.015;
+        y = layout.shaftY + layout.shaftHeight;
         if (node.crossSection === 'square' || node.crossSection === 'rectangular') {
             const corner = Math.min(Math.max(0, node.shaftCornerRadius ?? 0.035), Math.min(node.width, node.depth) * 0.45) * scale;
-            const x = (node.width * scale) / 2 - corner;
-            const z = (node.depth * scale) / 2 - corner;
+            const bevel = Math.min(node.edgeSoftness, layout.shaftHeight * 0.35, (Math.min(node.width, node.depth) / 2) * Math.min(getShaftScaleAt(node, 0), scale) * 0.35);
+            const x = (node.width * scale) / 2 - corner - bevel;
+            const z = (node.depth * scale) / 2 - corner - bevel;
             region = {
                 kind: 'polygon',
                 points: [
@@ -54,8 +57,12 @@ export function columnTopSurfaces(node) {
                 ]),
             };
         }
-        else
-            region = roundRegion(node.radius * scale, getSegments(node), yaw);
+        else {
+            const fluted = node.crossSection === 'round' && (node.fluteCount > 0 || node.shaftDetail === 'fluted');
+            const inset = (fluted ? Math.min(node.fluteDepth, node.radius * scale * 0.35) : 0) +
+                Math.min(node.edgeSoftness, layout.shaftHeight * 0.35, node.radius * Math.min(getShaftScaleAt(node, 0), scale) * 0.35);
+            region = roundRegion(node.radius * scale - inset, getSegments(node), yaw);
+        }
     }
     return [{ id: 'top', position: [0, y, 0], normal: [0, 1, 0], region }];
 }

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":"AA8QA;;;GAGG;AACH,QAAA,MAAM,UAAU,mCAOf,CAAA;eAEc,UAAU"}

package/dist/column/tool.js

@@ -1,12 +1,14 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { COLUMN_PRESETS, ColumnNode, collectAlignmentAnchors, emitter, resolveFrozenFloorPlacementPatch, resolveSupportSlabPatch, useScene, } from '@pascal-app/core';
+import { COLUMN_PRESETS, ColumnNode, collectAlignmentAnchors, emitter, NEW_COLUMN_SLOTS, resolveFrozenFloorPlacementPatch, resolveSupportSlabPatch, useScene, } from '@pascal-app/core';
 import { getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, resolvePointerSupportSurface, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 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) {
@@ -16,6 +18,7 @@ function createColumnFromPreset(presetId, position) {
         position,
         rotation: 0,
         ...preset,
+        slots: { ...NEW_COLUMN_SLOTS },
     });
 }
 /**
@@ -29,7 +32,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);
@@ -53,7 +56,17 @@ const ColumnTool = () => {
         // here and refreshed after each placement so a just-placed column becomes a
         // target for the next one. `previewNode.id` never collides with a scene
         // node, so nothing real is excluded.
-        let alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+        let candidateNodes = useScene.getState().nodes;
+        let alignmentCandidates = collectAlignmentAnchors(candidateNodes, previewNode.id);
+        let structuralGrids = collectStructuralGridAxes(candidateNodes, activeLevelId);
+        const refreshCandidates = () => {
+            const nodes = useScene.getState().nodes;
+            if (nodes === candidateNodes)
+                return;
+            candidateNodes = nodes;
+            alignmentCandidates = collectAlignmentAnchors(nodes, previewNode.id);
+            structuralGrids = collectStructuralGridAxes(nodes, activeLevelId);
+        };
         const pointedSurfaceFor = (event) => typeof HTMLCanvasElement !== 'undefined' &&
             event.nativeEvent?.target instanceof HTMLCanvasElement
             ? resolvePointerSupportSurface(cameraRef.current, event.position, {
@@ -61,11 +74,8 @@ const ColumnTool = () => {
             })
             : null;
         const resolveColumnPlacement = (position, surface) => {
-            const column = ColumnNode.parse({
-                ...createColumnFromPreset(DEFAULT_COLUMN_PRESET_ID, position),
-                parentId: activeLevelId,
-            });
-            const nodes = { ...useScene.getState().nodes, [column.id]: column };
+            const column = { ...previewNode, position, parentId: activeLevelId };
+            const nodes = useScene.getState().nodes;
             const patch = surface?.sourceNodeId
                 ? resolveFrozenFloorPlacementPatch(column, nodes, {
                     position,
@@ -82,6 +92,7 @@ const ColumnTool = () => {
             return { column, patch };
         };
         const onGridMove = (event) => {
+            refreshCandidates();
             if (!cursorVisibleRef.current) {
                 cursorVisibleRef.current = true;
                 setCursorVisible(true);
@@ -99,7 +110,7 @@ const ColumnTool = () => {
                 bypassGrid: !isGridSnapActive(),
             });
             const structuralSnap = isGridSnapActive() || isMagneticSnapActive()
-                ? resolveStructuralGridSnap([alignedPosition[0], alignedPosition[2]], collectStructuralGridAxes(useScene.getState().nodes, activeLevelId))
+                ? resolveStructuralGridSnap([alignedPosition[0], alignedPosition[2]], structuralGrids)
                 : null;
             const planPosition = structuralSnap
                 ? [structuralSnap.point[0], alignedPosition[1], structuralSnap.point[1]]
@@ -143,12 +154,13 @@ const ColumnTool = () => {
             }
         };
         const commitAtCursor = (event) => {
+            refreshCandidates();
             const pointed = pointedSurfaceFor(event) ?? supportSurfaceRef.current;
             supportSurfaceRef.current = pointed;
             const fallbackPosition = lastCursorRef.current ??
                 getLevelLocalSnappedPosition(activeLevelId, event, useEditor.getState().gridSnapStep, !isGridSnapActive());
             const structuralSnap = isGridSnapActive() || isMagneticSnapActive()
-                ? resolveStructuralGridSnap([fallbackPosition[0], fallbackPosition[2]], collectStructuralGridAxes(useScene.getState().nodes, activeLevelId))
+                ? resolveStructuralGridSnap([fallbackPosition[0], fallbackPosition[2]], structuralGrids)
                 : null;
             const planPosition = structuralSnap
                 ? [structuralSnap.point[0], 0, structuralSnap.point[1]]
@@ -157,6 +169,7 @@ const ColumnTool = () => {
             const committedColumn = ColumnNode.parse({
                 ...column,
                 ...patch,
+                id: undefined,
             });
             useScene.getState().createNode(committedColumn, activeLevelId);
             useViewer.getState().setSelection({ selectedIds: [committedColumn.id] });
@@ -165,7 +178,7 @@ const ColumnTool = () => {
             usePlacementPreview.getState().clear();
             if (useEditor.getState().getContinuation('point') === 'repeat') {
                 // The placed column is now a valid alignment target for the next one.
-                alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, previewNode.id);
+                refreshCandidates();
             }
             else {
                 cursorVisibleRef.current = false;
@@ -192,4 +205,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/construction-dimension/definition.d.ts

@@ -1,4 +1,130 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { ConstructionDimensionNode } from './schema.js';
-export declare const constructionDimensionDefinition: NodeDefinition<typeof ConstructionDimensionNode>;
+export declare const constructionDimensionDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`construction-dimension_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"construction-dimension">>;
+    anchors: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"feature">;
+        reference: import("zod").ZodObject<{
+            nodeId: import("zod").ZodString;
+            featureId: import("zod").ZodString;
+            parameters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber]>>>;
+        }, import("zod/v4/core").$strip>;
+        fallback: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    }, import("zod/v4/core").$strip>]>>>;
+    baseline: import("zod").ZodDefault<import("zod").ZodObject<{
+        origin: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+        direction: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    }, import("zod/v4/core").$strip>>;
+    chainMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        continuous: "continuous";
+        "point-to-point": "point-to-point";
+    }>>;
+    mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        angular: "angular";
+        "arc-length": "arc-length";
+        "center-mark": "center-mark";
+        chord: "chord";
+        coordinate: "coordinate";
+        diameter: "diameter";
+        linear: "linear";
+        radius: "radius";
+    }>>;
+    featureCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    showCenterMark: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    prefix: import("zod").ZodDefault<import("zod").ZodString>;
+    suffix: import("zod").ZodDefault<import("zod").ZodString>;
+    textOverride: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    datumPolicy: import("zod").ZodDefault<import("zod").ZodEnum<{
+        centerline: "centerline";
+        "finish-face": "finish-face";
+        "structural-face": "structural-face";
+        "wall-face": "wall-face";
+    }>>;
+    terminator: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "architectural-tick": "architectural-tick";
+        dot: "dot";
+        "filled-arrow": "filled-arrow";
+        "open-arrow": "open-arrow";
+    }>>;
+    textPosition: import("zod").ZodDefault<import("zod").ZodEnum<{
+        above: "above";
+        centered: "centered";
+    }>>;
+    imperialPrecision: import("zod").ZodDefault<import("zod").ZodEnum<{
+        1: "1";
+        "1/16": "1/16";
+        "1/2": "1/2";
+        "1/4": "1/4";
+        "1/8": "1/8";
+    }>>;
+    metricNotation: import("zod").ZodDefault<import("zod").ZodEnum<{
+        meters: "meters";
+        millimeters: "millimeters";
+    }>>;
+    extensionStartGap: import("zod").ZodDefault<import("zod").ZodNumber>;
+    extensionOvershoot: import("zod").ZodDefault<import("zod").ZodNumber>;
+    drawingType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "floor-plan": "floor-plan";
+        "foundation-plan": "foundation-plan";
+        "reflected-ceiling-plan": "reflected-ceiling-plan";
+        "roof-plan": "roof-plan";
+        "site-plan": "site-plan";
+    }>>;
+    drawingOverrides: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+        drawingType: import("zod").ZodEnum<{
+            "floor-plan": "floor-plan";
+            "foundation-plan": "foundation-plan";
+            "reflected-ceiling-plan": "reflected-ceiling-plan";
+            "roof-plan": "roof-plan";
+            "site-plan": "site-plan";
+        }>;
+        presentation: import("zod").ZodEnum<{
+            controlled: "controlled";
+            omit: "omit";
+            shown: "shown";
+        }>;
+        suppressedSegmentIndexes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodNumber>>;
+    }, import("zod/v4/core").$strip>>>;
+    controllingDimensionId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`construction-dimension_${string}`>>>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/construction-dimension/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASzF,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAEpD,eAAO,MAAM,+BAA+B,EAAE,cAAc,CAAC,OAAO,yBAAyB,CAgF5F,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG3C,CAAA"}

package/dist/construction-dimension/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { ConstructionDimensionNode } from './schema.js';
+export declare const constructionDimensionEditContribution: NodeEditContribution<typeof ConstructionDimensionNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/construction-dimension/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/definition.edit.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAQvE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAEzD,eAAO,MAAM,qCAAqC,EAAE,oBAAoB,CACtE,OAAO,yBAAyB,CA2BjC,CAAA"}

package/dist/construction-dimension/definition.edit.js

@@ -0,0 +1,32 @@
+import { measurementAnchorReferenceNodeIds } from '@pascal-app/core';
+import { resolveConstructionDimensionForDrawing } from './drawing-coordination.js';
+import { buildConstructionDimensionFloorplan } from './floorplan.js';
+import { moveConstructionDimensionBaselineAffordance, moveConstructionDimensionWitnessAffordance, } from './floorplan-affordances.js';
+import { constructionDimensionParametrics } from './parametrics.js';
+export const constructionDimensionEditContribution = {
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool.js'),
+            availableModes: ['expert'],
+            resolveForDrawing: resolveConstructionDimensionForDrawing,
+        },
+    },
+    snapProfile: 'item',
+    parametrics: constructionDimensionParametrics,
+    floorplan: buildConstructionDimensionFloorplan,
+    floorplanDependencies: (node) => [
+        ...measurementAnchorReferenceNodeIds(node.anchors),
+        ...(node.controllingDimensionId ? [node.controllingDimensionId] : []),
+    ],
+    floorplanAffordances: {
+        'move-construction-dimension-baseline': moveConstructionDimensionBaselineAffordance,
+        'move-construction-dimension-witness': moveConstructionDimensionWitnessAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Pick witness point' },
+        { key: 'Enter', label: 'Finish multi-point witnesses' },
+        { key: 'Left click', label: 'Place dimension line when needed' },
+        { key: 'Backspace', label: 'Remove last witness' },
+        { key: 'Esc', label: 'Step back or cancel' },
+    ],
+};

package/dist/construction-dimension/definition.js

@@ -1,83 +1,4 @@
-import { measurementAnchorReferenceNodeIds } from '@pascal-app/core';
-import { resolveConstructionDimensionForDrawing } from './drawing-coordination.js';
-import { buildConstructionDimensionFloorplan } from './floorplan.js';
-import { moveConstructionDimensionBaselineAffordance, moveConstructionDimensionWitnessAffordance, } from './floorplan-affordances.js';
-import { constructionDimensionParametrics } from './parametrics.js';
-import { ConstructionDimensionNode } from './schema.js';
-export const constructionDimensionDefinition = {
-    kind: 'construction-dimension',
-    bake: 'strip',
-    schemaVersion: 7,
-    schema: ConstructionDimensionNode,
-    category: 'analysis',
-    extensions: {
-        'pascal:editor/floorplan': {
-            tool: () => import('./floorplan-tool.js'),
-            availableModes: ['expert'],
-            resolveForDrawing: resolveConstructionDimensionForDrawing,
-        },
-    },
-    snapProfile: 'item',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        anchors: [
-            [0, 0, 0],
-            [1, 0, 0],
-        ],
-        baseline: { origin: [0, 0.6], direction: [1, 0] },
-        chainMode: 'point-to-point',
-        mode: 'linear',
-        featureCount: 1,
-        showCenterMark: true,
-        prefix: '',
-        suffix: '',
-        textOverride: null,
-        datumPolicy: 'centerline',
-        terminator: 'architectural-tick',
-        textPosition: 'above',
-        imperialPrecision: '1/16',
-        metricNotation: 'meters',
-        extensionStartGap: 0.075,
-        extensionOvershoot: 0.12,
-        drawingType: 'floor-plan',
-        drawingOverrides: [],
-        controllingDimensionId: null,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        deletable: true,
-        duplicable: true,
-        presettable: false,
-    },
-    dirtyTracking: false,
-    parametrics: constructionDimensionParametrics,
-    floorplan: buildConstructionDimensionFloorplan,
-    floorplanDependencies: (node) => [
-        ...measurementAnchorReferenceNodeIds(node.anchors),
-        ...(node.controllingDimensionId ? [node.controllingDimensionId] : []),
-    ],
-    floorplanAffordances: {
-        'move-construction-dimension-baseline': moveConstructionDimensionBaselineAffordance,
-        'move-construction-dimension-witness': moveConstructionDimensionWitnessAffordance,
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Pick witness point' },
-        { key: 'Enter', label: 'Finish multi-point witnesses' },
-        { key: 'Left click', label: 'Place dimension line when needed' },
-        { key: 'Backspace', label: 'Remove last witness' },
-        { key: 'Esc', label: 'Step back or cancel' },
-    ],
-    presentation: {
-        label: 'Construction Dimension',
-        description: 'Associative linear, curved, circular, angular, or coordinate plan dimension.',
-        icon: { kind: 'iconify', name: 'lucide:ruler-dimension-line' },
-        hidden: true,
-        actionMenu: false,
-    },
-    mcp: {
-        description: 'An associative construction dimension with linear, curved, circular, angular, and coordinate modes, semantic witness anchors, document notation overrides, and coordinated plan-view presentation.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { constructionDimensionEditContribution } from './definition.edit.js';
+import { constructionDimensionRenderDefinition } from './definition.render.js';
+export const constructionDimensionDefinition = composeNodeDefinition(constructionDimensionRenderDefinition, constructionDimensionEditContribution);

package/dist/construction-dimension/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { ConstructionDimensionNode } from './schema.js';
+export declare const constructionDimensionRenderDefinition: NodeRenderDefinition<typeof ConstructionDimensionNode> & {
+    kind: 'construction-dimension';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/construction-dimension/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAEpD,eAAO,MAAM,qCAAqC,EAAE,oBAAoB,CACtE,OAAO,yBAAyB,CACjC,GAAG;IAAE,IAAI,EAAE,wBAAwB,CAAA;CAoDnC,CAAA"}

package/dist/construction-dimension/definition.render.js

@@ -0,0 +1,53 @@
+import { ConstructionDimensionNode } from './schema.js';
+export const constructionDimensionRenderDefinition = {
+    kind: 'construction-dimension',
+    bake: 'strip',
+    schemaVersion: 7,
+    schema: ConstructionDimensionNode,
+    category: 'analysis',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        anchors: [
+            [0, 0, 0],
+            [1, 0, 0],
+        ],
+        baseline: { origin: [0, 0.6], direction: [1, 0] },
+        chainMode: 'point-to-point',
+        mode: 'linear',
+        featureCount: 1,
+        showCenterMark: true,
+        prefix: '',
+        suffix: '',
+        textOverride: null,
+        datumPolicy: 'centerline',
+        terminator: 'architectural-tick',
+        textPosition: 'above',
+        imperialPrecision: '1/16',
+        metricNotation: 'meters',
+        extensionStartGap: 0.075,
+        extensionOvershoot: 0.12,
+        drawingType: 'floor-plan',
+        drawingOverrides: [],
+        controllingDimensionId: null,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        duplicable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    presentation: {
+        label: 'Construction Dimension',
+        description: 'Associative linear, curved, circular, angular, or coordinate plan dimension.',
+        icon: { kind: 'iconify', name: 'lucide:ruler-dimension-line' },
+        hidden: true,
+        actionMenu: false,
+    },
+    mcp: {
+        description: 'An associative construction dimension with linear, curved, circular, angular, and coordinate modes, semantic witness anchors, document notation overrides, and coordinated plan-view presentation.',
+    },
+};

package/dist/construction-dimension/floorplan-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/floorplan-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAI9B,KAAK,iBAAiB,EAItB,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,KAAK,oBAAoB,EAW1B,MAAM,oBAAoB,CAAA;AAY3B,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAC1B,KAAK,EAAE,WAAW,GAAG,UAAU,CAAA;CAChC,CAAA;AA2ED,wBAAgB,0CAA0C,CACxD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,CAAC,EAAE,SAAS,iBAAiB,EAAE,EACtC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC3C,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAUzB;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,aAAa,EAAE,gBAAgB,EAC/B,IAAI,EAAE,QAAQ,GAAG,UAAU,EAC3B,IAAI,GAAE,yBAAoC,EAC1C,cAAc,GAAE,QAAQ,GAAG,aAAwB,EACnD,iBAAiB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,GACnD,iBAAiB,EAAE,CAqLrB;AAED,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,OAAO,GACb,8BAA8B,CAEhC;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAY5F;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAE1F;AAED,wBAAgB,8CAA8C,CAAC,KAAK,EAAE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAGV;AAcD,wBAAgB,yCAAyC,CACvD,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,yBAAyB,GAC9B,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC,GAAG,IAAI,CA6B1C;AAED,wBAAgB,uCAAuC,CAAC,EACtD,aAAa,EACb,UAAU,EACV,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,IAAI,GACL,EAAE,oBAAoB,sCAqVtB;eAEc,uCAAuC"}
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/floorplan-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAI9B,KAAK,iBAAiB,EAKtB,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,KAAK,oBAAoB,EAU1B,MAAM,oBAAoB,CAAA;AAY3B,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAC1B,KAAK,EAAE,WAAW,GAAG,UAAU,CAAA;CAChC,CAAA;AA2ED,wBAAgB,0CAA0C,CACxD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,CAAC,EAAE,SAAS,iBAAiB,EAAE,EACtC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC3C,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAUzB;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,aAAa,EAAE,gBAAgB,EAC/B,IAAI,EAAE,QAAQ,GAAG,UAAU,EAC3B,IAAI,GAAE,yBAAoC,EAC1C,cAAc,GAAE,QAAQ,GAAG,aAAwB,EACnD,iBAAiB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,GACnD,iBAAiB,EAAE,CAqLrB;AAED,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,OAAO,GACb,8BAA8B,CAEhC;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAY5F;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAE1F;AAED,wBAAgB,8CAA8C,CAAC,KAAK,EAAE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAGV;AAcD,wBAAgB,yCAAyC,CACvD,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,yBAAyB,GAC9B,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC,GAAG,IAAI,CA6B1C;AAED,wBAAgB,uCAAuC,CAAC,EACtD,aAAa,EACb,UAAU,EACV,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,IAAI,GACL,EAAE,oBAAoB,sCAqVtB;eAEc,uCAAuC"}

package/dist/construction-dimension/floorplan-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ConstructionDimensionNode, closestMeasurementFeatureBinding, constructionDimensionRequiredAnchorCount, getWallArcData, getWallCurveFrameAt, nodeRegistry, } from '@pascal-app/core';
-import { buildSvgArcPath, clearSurfacePlanSnapFeedback, FloorplanGeometryRenderer, formatLinearMeasurement, getArcPlanPoint, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, resolveSurfacePlanPointSnap, triggerSFX, useDrawingView, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
+import { ConstructionDimensionNode, closestMeasurementFeatureBinding, constructionDimensionRequiredAnchorCount, formatLinearMeasurement, getWallArcData, getWallCurveFrameAt, nodeRegistry, } from '@pascal-app/core';
+import { buildSvgArcPath, clearSurfacePlanSnapFeedback, FloorplanGeometryRenderer, getArcPlanPoint, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, resolveSurfacePlanPointSnap, triggerSFX, useDrawingView, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { alignConstructionDimensionDirectionToSharedWall, resolveCircularConstructionDimensionLayout, } from './geometry.js';
 const SEMANTIC_SNAP_DISTANCE = 0.2;