@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/column/definition.js

@@ -1,436 +1,4 @@
-import { ColumnNode as ColumnNodeSchema, columnSlots, } from '@pascal-app/core';
-import { withHostedChildren } from '../shared/hosted-resize.js';
-import { columnBatchable } from '../shared/node-batch/batchable.js';
-import { rebuildScriptedSize } from '../shared/scripted-opening-handles.js';
-import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination.js';
-import { buildColumnFloorplan, computeColumnFloorplanLevelData } from './floorplan.js';
-import { columnResizeAffordance, columnRotateAffordance } from './floorplan-affordances.js';
-import { columnFloorplanMoveTarget } from './floorplan-move.js';
-import { columnHostedPolicy } from './hosted-resize.js';
-import { columnPaint } from './paint.js';
-import { columnParametrics } from './parametrics.js';
-import { ColumnNode } from './schema.js';
-import { columnSurfaceProvider } from './surface.js';
-// Limits + offsets shared with the in-world arrows. Mirrors the floors
-// the renderer clamps to (`Math.max(0.2, node.height)` etc.) so a drag
-// can't push values past what the renderer will accept.
-const SIDE_HANDLE_OFFSET = 0.18;
-const HEIGHT_HANDLE_OFFSET = 0.22;
-const BRACE_HANDLE_OFFSET = 0.3;
-const SPREAD_HANDLE_OFFSET = 0.22;
-const ROTATE_CORNER_OFFSET = 0.32;
-const ROTATE_RING_OFFSET = 0.04;
-const MOVE_FRONT_OFFSET = 0.35;
-const MIN_COLUMN_HEIGHT = 0.2;
-const MIN_COLUMN_WIDTH = 0.1;
-const MIN_COLUMN_DEPTH = 0.1;
-const MIN_COLUMN_RADIUS = 0.05;
-const MIN_BRACE_DIMENSION = 0.04;
-const MIN_BRACE_BOTTOM_SPREAD = 0.2;
-const MIN_BRACE_TOP_SPREAD = 0;
-const ROUND_CROSS_SECTIONS = new Set([
-    'round',
-    'octagonal',
-    'sixteen-sided',
-]);
-function columnHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_COLUMN_HEIGHT,
-        currentValue: (n) => n.height,
-        apply: (_n, newValue) => ({ height: newValue }),
-        placement: {
-            position: (n) => [0, n.height + HEIGHT_HANDLE_OFFSET, 0],
-        },
-    };
-}
-function columnRadiusHandle() {
-    return {
-        kind: 'radial-resize',
-        axis: 'x',
-        min: MIN_COLUMN_RADIUS,
-        currentValue: (n) => n.radius,
-        apply: (_n, newValue) => ({ radius: newValue }),
-        placement: {
-            position: (n) => [n.radius + SIDE_HANDLE_OFFSET, n.height / 2, 0],
-        },
-        // Guide ring traces the column's footprint at mid-height while the
-        // user is hovering or dragging the radius arrow — clarifies which
-        // edge the drag controls on round / octagonal / sixteen-sided shafts.
-        decoration: {
-            kind: 'ring',
-            radius: (n) => n.radius + SIDE_HANDLE_OFFSET * 0.5,
-            y: (n) => n.height / 2,
-        },
-    };
-}
-function columnAxisHandle(axis) {
-    return {
-        kind: 'linear-resize',
-        axis,
-        anchor: 'center',
-        min: axis === 'x' ? MIN_COLUMN_WIDTH : MIN_COLUMN_DEPTH,
-        currentValue: (n) => (axis === 'x' ? n.width : n.depth),
-        apply: (_n, newValue) => (axis === 'x' ? { width: newValue } : { depth: newValue }),
-        placement: {
-            position: (n) => {
-                const half = axis === 'x' ? n.width / 2 : n.depth / 2;
-                return axis === 'x'
-                    ? [half + SIDE_HANDLE_OFFSET, n.height / 2, 0]
-                    : [0, n.height / 2, half + SIDE_HANDLE_OFFSET];
-            },
-        },
-    };
-}
-function columnUniformHandle() {
-    // Square columns keep width === depth. We anchor the arrow on the +X
-    // side and write BOTH fields from the same delta.
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'center',
-        min: MIN_COLUMN_WIDTH,
-        currentValue: (n) => n.width,
-        apply: (_n, newValue) => ({ width: newValue, depth: newValue }),
-        placement: {
-            position: (n) => [n.width / 2 + SIDE_HANDLE_OFFSET, n.height / 2, 0],
-        },
-    };
-}
-// Bottom-spread arrow — sits just outside the right foot of the splay
-// (a-frame / x-brace etc.), one beam-width above the floor plate so it
-// clears the support legs. Drags symmetrically: anchor='center' so
-// pointer Δ of d grows the full leg-to-leg distance by 2d, both legs
-// moving ±d. Defaults mirror the renderer fall-throughs.
-function columnBraceBottomSpreadHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'center',
-        min: MIN_BRACE_BOTTOM_SPREAD,
-        currentValue: (n) => Math.max(MIN_BRACE_BOTTOM_SPREAD, n.braceBottomSpread ?? Math.max(n.width * 3, 1.2)),
-        apply: (_n, newValue) => ({ braceBottomSpread: newValue }),
-        placement: {
-            position: (n) => {
-                const spread = Math.max(MIN_BRACE_BOTTOM_SPREAD, n.braceBottomSpread ?? Math.max(n.width * 3, 1.2));
-                return [spread / 2 + SPREAD_HANDLE_OFFSET, 0.08, 0];
-            },
-        },
-    };
-}
-// Top-spread arrow — at the right tip of the brace's top edge. Same
-// symmetric anchor as the bottom spread. For a-frame this is the small
-// "pinch" at the top; for y/v-frame and x-brace it's the wider opening.
-function columnBraceTopSpreadHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'center',
-        min: MIN_BRACE_TOP_SPREAD,
-        currentValue: (n) => Math.max(MIN_BRACE_TOP_SPREAD, n.braceTopSpread ?? 0.12),
-        apply: (_n, newValue) => ({ braceTopSpread: newValue }),
-        placement: {
-            position: (n) => {
-                const spread = Math.max(MIN_BRACE_TOP_SPREAD, n.braceTopSpread ?? 0.12);
-                return [spread / 2 + SPREAD_HANDLE_OFFSET, n.height + 0.08, 0];
-            },
-        },
-    };
-}
-function columnBraceHandle(axis) {
-    return {
-        kind: 'linear-resize',
-        axis,
-        anchor: 'center',
-        min: MIN_BRACE_DIMENSION,
-        currentValue: (n) => (axis === 'x' ? (n.braceWidth ?? n.width) : (n.braceDepth ?? n.depth)),
-        apply: (_n, newValue) => (axis === 'x' ? { braceWidth: newValue } : { braceDepth: newValue }),
-        placement: {
-            position: (n) => {
-                // Position outside any splay so the arrow clears the legs.
-                const half = axis === 'x'
-                    ? Math.max(n.braceBottomSpread ?? 0, n.braceTopSpread ?? 0, n.braceWidth ?? n.width) / 2
-                    : (n.braceDepth ?? n.depth) / 2;
-                return axis === 'x'
-                    ? [half + BRACE_HANDLE_OFFSET, n.height / 2, 0]
-                    : [0, n.height / 2, half + BRACE_HANDLE_OFFSET];
-            },
-        },
-    };
-}
-// Which supports surface bottom-spread / top-spread in the renderer. Phase
-// 1 covers the simple two-leg / single-foot supports; x-brace / k-brace /
-// tripod / trestle / portal-frame / box-frame will hook the same handles
-// in a follow-up once we audit their leg geometry.
-const STYLES_WITH_BOTTOM_SPREAD = new Set(['a-frame']);
-const STYLES_WITH_TOP_SPREAD = new Set([
-    'a-frame',
-    'y-frame',
-    'v-frame',
-]);
-function isLeanToManagedColumn(node) {
-    const metadata = node.metadata;
-    return (metadata !== null &&
-        typeof metadata === 'object' &&
-        !Array.isArray(metadata) &&
-        metadata.managedByLeanTo !== undefined &&
-        metadata.leanToRole === 'post');
-}
-// Resolve the column's visible XZ footprint half-extents per supportStyle
-// + crossSection. Vertical supports use the shaft geometry (radius for
-// round / octagonal / sixteen-sided, width/depth for square / rectangular);
-// non-vertical supports fall back to the widest sensible brace bound so
-// the rotation handle clears the splay.
-function columnFootprintHalf(n) {
-    if (n.source)
-        return { halfX: n.width / 2, halfZ: n.depth / 2 };
-    if (n.supportStyle === 'vertical') {
-        if (ROUND_CROSS_SECTIONS.has(n.crossSection)) {
-            return { halfX: n.radius, halfZ: n.radius };
-        }
-        if (n.crossSection === 'square') {
-            return { halfX: n.width / 2, halfZ: n.width / 2 };
-        }
-        return { halfX: n.width / 2, halfZ: n.depth / 2 };
-    }
-    return {
-        halfX: Math.max(n.width, n.braceWidth ?? 0, n.braceBottomSpread ?? 0, n.braceTopSpread ?? 0) / 2,
-        halfZ: Math.max(n.depth, n.braceDepth ?? 0) / 2,
-    };
-}
-// Whole-column rotation gizmo — same pattern as the elevator. Curved
-// two-headed arrow at the +X / +Z corner of the footprint, a guide ring
-// at the corner-diagonal radius on hover/drag. `apply` negates the
-// angular delta so dragging the cursor CCW around the column rotates
-// the column CCW (cursor atan2 ticks opposite-handed from three.js Ry).
-function columnRotateHandle() {
-    return {
-        kind: 'arc-resize',
-        axis: 'angular',
-        shape: 'rotate',
-        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
-        placement: {
-            // Offset along +Z only so the gizmo sticks out the front of the
-            // column rather than diagonally at the corner — keeps the rotate
-            // arrow from crowding the +X side handles (radius / axis / uniform)
-            // while still reading as attached to the column.
-            position: (n) => {
-                const { halfX, halfZ } = columnFootprintHalf(n);
-                const yMid = Math.max(n.height, MIN_COLUMN_HEIGHT) / 2;
-                return [halfX, yMid, halfZ + ROTATE_CORNER_OFFSET];
-            },
-            // Fixed −45° tilt — leans the curve clockwise (as seen from above)
-            // toward the column's front face.
-            rotationY: () => -Math.PI / 4,
-        },
-        decoration: {
-            kind: 'ring',
-            radius: (n) => {
-                const { halfX, halfZ } = columnFootprintHalf(n);
-                return Math.hypot(halfX, halfZ) + ROTATE_RING_OFFSET;
-            },
-            y: (n) => Math.max(n.height, MIN_COLUMN_HEIGHT) / 2,
-        },
-    };
-}
-function columnMoveHandle() {
-    return {
-        kind: 'translate',
-        placement: {
-            // Low to the floor at the front edge (matches the item move grip) so it
-            // reads as a floor-move grip and stays clear of the body resize / rotate
-            // handles that sit at mid-height.
-            position: (n) => {
-                const { halfZ } = columnFootprintHalf(n);
-                return [0, 0.02, halfZ + MOVE_FRONT_OFFSET];
-            },
-        },
-        apply: (_n, pos) => ({ position: [pos[0], pos[1], pos[2]] }),
-        snapExtents: (n) => {
-            const { halfX, halfZ } = columnFootprintHalf(n);
-            const dimX = Math.max(halfX * 2, MIN_COLUMN_WIDTH);
-            const dimZ = Math.max(halfZ * 2, MIN_COLUMN_DEPTH);
-            const swap = Math.abs(Math.sin(n.rotation ?? 0)) > 0.9;
-            return [swap ? dimZ : dimX, swap ? dimX : dimZ];
-        },
-    };
-}
-function columnHandles(node) {
-    if (node.source) {
-        const declared = new Set(node.source.manifest.params.map((param) => param.id));
-        const sizes = [];
-        if (declared.has('height'))
-            sizes.push(columnHeightHandle());
-        if (declared.has('width'))
-            sizes.push(columnAxisHandle('x'));
-        if (declared.has('depth'))
-            sizes.push(columnAxisHandle('z'));
-        return [
-            ...sizes.map((handle) => ({
-                ...handle,
-                commit: (initial, patch) => rebuildScriptedSize(initial, patch),
-            })),
-            columnRotateHandle(),
-            columnMoveHandle(),
-        ];
-    }
-    // 1. Height (universal).
-    // 2. Footprint arrows depending on supportStyle + crossSection:
-    //    - non-vertical supports → braceWidth + braceDepth (skips crossSection)
-    //      plus per-style spread arrows at the splay endpoints.
-    //    - round / octagonal / sixteen-sided → single radius arrow
-    //    - square                            → uniform width+depth
-    //    - rectangular                       → width + depth (independent)
-    const handles = [];
-    const managedByLeanTo = isLeanToManagedColumn(node);
-    if (!managedByLeanTo)
-        handles.push(columnHeightHandle());
-    if (node.supportStyle !== 'vertical') {
-        handles.push(columnBraceHandle('x'), columnBraceHandle('z'));
-        if (STYLES_WITH_BOTTOM_SPREAD.has(node.supportStyle)) {
-            handles.push(columnBraceBottomSpreadHandle());
-        }
-        if (STYLES_WITH_TOP_SPREAD.has(node.supportStyle)) {
-            handles.push(columnBraceTopSpreadHandle());
-        }
-    }
-    else if (managedByLeanTo) {
-        // Lean-to sync owns the post's structural height and footprint. Keep
-        // rotation user-owned so asymmetric styles such as K-braces can be flipped.
-    }
-    else if (ROUND_CROSS_SECTIONS.has(node.crossSection)) {
-        handles.push(columnRadiusHandle());
-    }
-    else if (node.crossSection === 'square') {
-        handles.push(columnUniformHandle());
-    }
-    else {
-        handles.push(columnAxisHandle('x'), columnAxisHandle('z'));
-    }
-    handles.push(columnRotateHandle());
-    if (!managedByLeanTo)
-        handles.push(columnMoveHandle());
-    return handles.map((handle) => withHostedChildren(handle, columnHostedPolicy));
-}
-function resolveColumnStructuralGridMoveSnap({ candidatePosition, nodes, levelId, }) {
-    const snap = resolveStructuralGridSnap([candidatePosition[0], candidatePosition[2]], collectStructuralGridAxes(nodes, levelId));
-    return snap ? { position: [snap.point[0], candidatePosition[1], snap.point[1]] } : null;
-}
-/**
- * Column — Stage A registration. Wrap-export of the legacy
- * `ColumnRenderer` (no system — column geometry is computed inline in
- * the renderer). Inspector / floorplan still go through legacy paths via
- * panel-manager.tsx / floorplan-panel.tsx (their hardcoded `case 'column':`
- * entries fire before the registry fallback).
- *
- * Capabilities: column declares the generic `movable` (translate on XZ
- * with grid snap), so its 3D move runs through the shared
- * `MoveRegistryNodeTool` — which gives it grid/line/off snapping, alignment,
- * R/T rotation, slab-elevation lift, and the `collides` red/green placement
- * box for free. (2D move still routes through `floorplanMoveTarget`, which
- * wins the 2D dispatch.)
- *
- * Defaults computed via stub-parse so we leverage every zod
- * `.default()` annotation on the schema (~60 fields).
- */
-export const columnDefinition = {
-    kind: 'column',
-    snapProfile: 'item',
-    facingIndicator: true,
-    schemaVersion: 1,
-    schema: ColumnNode,
-    category: 'structure',
-    surfaceRole: 'wall',
-    defaults: () => {
-        const stub = ColumnNodeSchema.parse({ id: 'column_default', type: 'column' });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        reveal: { phase: 'structure', style: 'drop', height: 4 },
-        revealOnEdit: ['height', 'radius', 'width', 'depth', 'crossSection', 'shaftProfile', 'style'],
-        batchable: columnBatchable,
-        surfacePlacement: 'floor-only',
-        selectable: { hitVolume: 'bbox' },
-        surfaces: {
-            top: { height: (node) => node.height },
-            hosting: columnSurfaceProvider,
-        },
-        duplicable: { subtree: true },
-        deletable: true,
-        // Generic 3D translate-on-XZ via `MoveRegistryNodeTool` (grid snap + the
-        // mode-driven snapping the overhaul standardised). 2D move keeps using
-        // `floorplanMoveTarget`, which wins the 2D move dispatch.
-        movable: {
-            axes: ['x', 'z'],
-            gridSnap: true,
-            groupMoveSnapPose: resolveColumnStructuralGridMoveSnap,
-        },
-        slots: (node) => columnSlots(node),
-        paint: columnPaint,
-        // Slab elevation lift via the generic `<FloorElevationSystem>` + the
-        // placement/collision box. Use the VISIBLE footprint (round → radius,
-        // square → width, rectangular → width/depth, plus brace spread) so the
-        // box, slab-overlap, and collision all track the real column size rather
-        // than the raw width/depth (stale for a round column resized by radius).
-        floorPlaced: {
-            footprint: (node) => {
-                const column = node;
-                const { halfX, halfZ } = columnFootprintHalf(column);
-                return {
-                    dimensions: [halfX * 2, column.height, halfZ * 2],
-                    // Column stores Y rotation as a scalar; the slab-overlap query
-                    // expects the full Euler tuple.
-                    rotation: [0, column.rotation, 0],
-                };
-            },
-            collides: true,
-        },
-    },
-    parametrics: columnParametrics,
-    handles: columnHandles,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./renderer.js').then(({ ColumnPreview }) => ({ default: ColumnPreview })),
-    // Registry-driven placement tool — renders a translucent `ColumnPreview`
-    // ghost at the cursor (mirroring the shelf build tool) instead of the
-    // bare sphere the legacy editor-side `ColumnTool` showed. `ToolManager`'s
-    // registry-first path mounts this and skips the legacy `<ColumnTool>`.
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Left click', label: 'Place column' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    computeFloorplanLevelData: computeColumnFloorplanLevelData,
-    floorplanDependsOnSiblings: true,
-    floorplan: buildColumnFloorplan,
-    // 2D body move routes through this kind-specific target so the column
-    // aligns by its footprint *edges* (and snaps flush to wall faces) instead
-    // of the overlay's generic free-translate path, which aligned by bbox
-    // centre and gathered candidates from SVG bounding boxes only. Mirrors the
-    // shelf move target.
-    floorplanMoveTarget: columnFloorplanMoveTarget,
-    // 2D drag affordances — `column-resize` handles every dimension arrow
-    // the floor-plan builder emits per cross-section / support style (the
-    // payload's `dim` field discriminates radius / uniform / width / depth
-    // / brace-width / brace-depth / spreads). `column-rotate` powers the
-    // corner rotate-arrow.
-    floorplanAffordances: {
-        'column-resize': columnResizeAffordance,
-        'column-rotate': columnRotateAffordance,
-    },
-    presentation: {
-        label: 'Column',
-        description: 'A parametric column with configurable cross-section, base, and capital.',
-        icon: { kind: 'url', src: '/icons/column.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 70,
-    },
-    mcp: {
-        description: 'A parametric column placed on a slab or level.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { columnEditContribution } from './definition.edit.js';
+import { columnRenderDefinition } from './definition.render.js';
+export const columnDefinition = composeNodeDefinition(columnRenderDefinition, columnEditContribution);

package/dist/column/definition.render.d.ts

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

package/dist/column/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/column/definition.render.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAQvE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAerC,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAAC,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAuE5F,CAAA"}

package/dist/column/definition.render.js

@@ -0,0 +1,81 @@
+import { ColumnNode as ColumnNodeSchema, columnSlots, NEW_COLUMN_SLOTS, } from '@pascal-app/core';
+import { columnBatchable } from '../shared/node-batch/batchable.js';
+import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination.js';
+import { columnFootprintHalf } from './bounds.js';
+import { isManagedColumn } from './edit-policy.js';
+import { ColumnNode } from './schema.js';
+import { columnSurfaceProvider } from './surface.js';
+function resolveColumnStructuralGridMoveSnap({ candidatePosition, nodes, levelId, }) {
+    const snap = resolveStructuralGridSnap([candidatePosition[0], candidatePosition[2]], collectStructuralGridAxes(nodes, levelId));
+    return snap ? { position: [snap.point[0], candidatePosition[1], snap.point[1]] } : null;
+}
+export const columnRenderDefinition = {
+    kind: 'column',
+    schemaVersion: 1,
+    schema: ColumnNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => {
+        const stub = ColumnNodeSchema.parse({ id: 'column_default', type: 'column' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return { ...rest, slots: { ...NEW_COLUMN_SLOTS } };
+    },
+    capabilities: {
+        reveal: { phase: 'structure', style: 'drop', height: 4 },
+        revealOnEdit: ['height', 'radius', 'width', 'depth', 'crossSection', 'shaftProfile', 'style'],
+        batchable: columnBatchable,
+        surfacePlacement: 'floor-only',
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            top: { height: (node) => node.height },
+            hosting: columnSurfaceProvider,
+        },
+        duplicable: {
+            subtree: true,
+            allow: ({ node }) => !isManagedColumn(node),
+        },
+        deletable: true,
+        // Generic 3D translate-on-XZ via `MoveRegistryNodeTool` (grid snap + the
+        // mode-driven snapping the overhaul standardised). 2D move keeps using
+        // `floorplanMoveTarget`, which wins the 2D move dispatch.
+        movable: {
+            override: ({ node }) => isManagedColumn(node) ? { axes: [], gridSnap: false } : null,
+            axes: ['x', 'z'],
+            gridSnap: true,
+            groupMoveSnapPose: resolveColumnStructuralGridMoveSnap,
+        },
+        slots: (node) => columnSlots(node),
+        // Slab elevation lift via the generic `<FloorElevationSystem>` + the
+        // placement/collision box. Use the VISIBLE footprint (round → radius,
+        // square → width, rectangular → width/depth, plus brace spread) so the
+        // box, slab-overlap, and collision all track the real column size rather
+        // than the raw width/depth (stale for a round column resized by radius).
+        floorPlaced: {
+            footprint: (node) => {
+                const column = node;
+                const { halfX, halfZ } = columnFootprintHalf(column);
+                return {
+                    dimensions: [halfX * 2, column.height, halfZ * 2],
+                    // Column stores Y rotation as a scalar; the slab-overlap query
+                    // expects the full Euler tuple.
+                    rotation: [0, column.rotation, 0],
+                };
+            },
+            collides: true,
+        },
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Column',
+        description: 'A parametric column with configurable cross-section, base, and capital.',
+        icon: { kind: 'url', src: '/icons/column.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 70,
+    },
+    mcp: {
+        description: 'A parametric column placed on a slab or level.',
+    },
+};

package/dist/column/edit-policy.d.ts

@@ -0,0 +1,5 @@
+import type { ColumnNode } from '@pascal-app/core';
+export declare function isManagedColumn(node: ColumnNode): boolean;
+/** Normalize edits, not loaded scenes: legacy independent dimensions remain readable. */
+export declare function columnEditPatch(node: ColumnNode, updates: Partial<ColumnNode>): Partial<ColumnNode>;
+//# sourceMappingURL=edit-policy.d.ts.map

package/dist/column/edit-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-policy.d.ts","sourceRoot":"","sources":["../../src/column/edit-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAEzD;AAgBD,yFAAyF;AACzF,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,CAuBrB"}

package/dist/column/edit-policy.js

@@ -0,0 +1,43 @@
+export function isManagedColumn(node) {
+    return node.metadata?.managedByLeanTo !== undefined && node.metadata?.leanToRole === 'post';
+}
+const managedFields = new Set([
+    'position',
+    'height',
+    'width',
+    'depth',
+    'radius',
+    'crossSection',
+    'baseStyle',
+    'baseHeight',
+    'baseWidthScale',
+    'baseDepthScale',
+    'slots',
+]);
+/** Normalize edits, not loaded scenes: legacy independent dimensions remain readable. */
+export function columnEditPatch(node, updates) {
+    const patch = { ...updates };
+    if (!node.source && (patch.supportStyle ?? node.supportStyle) === 'vertical') {
+        const section = patch.crossSection ?? node.crossSection;
+        if (['round', 'octagonal', 'sixteen-sided'].includes(section)) {
+            if (patch.radius !== undefined && patch.width === undefined) {
+                patch.width = patch.radius * 2;
+                patch.depth = patch.radius * 2;
+            }
+            else if (patch.width !== undefined || patch.crossSection !== undefined) {
+                patch.radius = (patch.width ?? node.width) / 2;
+                patch.depth = patch.width ?? node.width;
+            }
+        }
+        else if (section === 'square' &&
+            (patch.width !== undefined || patch.depth !== undefined || patch.crossSection !== undefined)) {
+            patch.width = patch.width ?? patch.depth ?? node.width;
+            patch.depth = patch.width;
+            patch.radius = patch.width / 2;
+        }
+    }
+    if (isManagedColumn(node))
+        for (const key of managedFields)
+            delete patch[key];
+    return patch;
+}

package/dist/column/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAezB;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EACC,OAAO,GACP,OAAO,GACP,SAAS,GACT,QAAQ,GACR,aAAa,GACb,aAAa,GACb,qBAAqB,GACrB,kBAAkB,CAAA;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CA0FlE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CAgClE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAgBzB;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EACC,OAAO,GACP,OAAO,GACP,SAAS,GACT,QAAQ,GACR,aAAa,GACb,aAAa,GACb,qBAAqB,GACrB,kBAAkB,CAAA;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CA2FlE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CAgClE,CAAA"}

package/dist/column/floorplan-affordances.js

@@ -2,6 +2,7 @@ import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
 import { rebuildScriptedSize } from '../shared/scripted-opening-handles.js';
+import { columnEditPatch } from './edit-policy.js';
 import { planColumnEdit } from './hosted-resize.js';
 // Floor minimums — mirror the 3D handles in `column/definition.ts` so a
 // drag can't push a value past what the renderer accepts.
@@ -26,6 +27,7 @@ export const columnResizeAffordance = {
         const initialBraceTopSpread = node.braceTopSpread ?? 0.12;
         let lastPatch = {};
         const previewPatch = (patch) => {
+            patch = columnEditPatch(node, patch);
             if (!planColumnEdit(columnId, patch))
                 return;
             lastPatch = patch;

package/dist/column/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAgBzB;;;;;;;GAOG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAsErE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAiBzB;;;;;;;GAOG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAyErE,CAAA"}

package/dist/column/floorplan-move.js

@@ -2,6 +2,7 @@ import { collectAlignmentAnchors, movingFootprintAnchors, sceneRegistry, useLive
 import { applyFloorplanAlignment, getFloorStackPreviewPosition, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
 import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination.js';
+import { isManagedColumn } from './edit-policy.js';
 /**
  * 2D floor-plan move handler for column. Columns need the same footprint-edge
  * alignment as shelf / item, but they must preview through live transforms and
@@ -11,6 +12,8 @@ import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../struct
  * Column stores rotation as a scalar (not a tuple); position is `[x, y, z]`.
  */
 export const columnFloorplanMoveTarget = ({ node, nodes }) => {
+    if (isManagedColumn(node))
+        return { affectedIds: [], apply() { }, canCommit: () => false, commit() { } };
     const columnId = node.id;
     const originalPosition = [...node.position];
     const rotationY = node.rotation ?? 0;
@@ -22,6 +25,7 @@ export const columnFloorplanMoveTarget = ({ node, nodes }) => {
     let lastSnapKey = null;
     // Alignment candidates gathered once — scene is stable during the drag.
     const candidates = collectAlignmentAnchors(nodes, columnId);
+    const structuralGrids = collectStructuralGridAxes(nodes, node.parentId);
     const session = {
         affectedIds: [columnId],
         apply({ planPoint }) {
@@ -35,7 +39,7 @@ export const columnFloorplanMoveTarget = ({ node, nodes }) => {
             // Figma-style alignment layered on the active snap mode.
             const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], rotationY), candidates, { applySnap: isMagneticSnapActive() });
             const structuralSnap = isGridSnapActive() || isMagneticSnapActive()
-                ? resolveStructuralGridSnap(snapped, collectStructuralGridAxes(nodes, node.parentId))
+                ? resolveStructuralGridSnap(snapped, structuralGrids)
                 : null;
             const coordinated = structuralSnap?.point ?? snapped;
             const next = [coordinated[0], originalPosition[1], coordinated[1]];

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/column/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAA;AAsBzB,MAAM,MAAM,wBAAwB,GAAG;IACrC,eAAe,EAAE,kBAAkB,EAAE,CAAA;CACtC,CAAA;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAA;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,wBAAwB,CAI3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAsN1B;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,CAiB9E"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/column/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAA;AAwBzB,MAAM,MAAM,wBAAwB,GAAG;IACrC,eAAe,EAAE,kBAAkB,EAAE,CAAA;CACtC,CAAA;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAA;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,wBAAwB,CAI3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAoP1B;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,CAiB9E"}