@pascal-app/nodes 0.1.1

package/dist/chimney/tool.js

@@ -0,0 +1,126 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ChimneyNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { chimneyDefinition } from './definition';
+import ChimneyPreview from './preview';
+/**
+ * Chimney placement tool. Listens to `roof:*` events; the preview
+ * follows the cursor across the segment with the segment's yaw applied
+ * (chimney itself stays world-vertical, so no slope tilt wrap). Click
+ * creates a new ChimneyNode parented to that segment with
+ * segment-local position.
+ */
+const tmpMatrix = new THREE.Matrix4();
+const tmpInv = new THREE.Matrix4();
+const tmpPos = new THREE.Vector3();
+const tmpQuat = new THREE.Quaternion();
+const tmpScale = new THREE.Vector3();
+const ChimneyTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    // Building-local matrix of the host segment — drives the ghost's
+    // outer-group transform so the preview lands inside the actual
+    // segment's frame (matches the real renderer in `renderer.tsx`).
+    const [segmentXform, setSegmentXform] = useState(null);
+    // Cursor position expressed in segment-local coords. Layered inside
+    // the segment frame so the ghost slides with the cursor across the
+    // segment's footprint.
+    const [hitLocal, setHitLocal] = useState(null);
+    const [previewSegment, setPreviewSegment] = useState(null);
+    const lastSnapRef = useRef(null);
+    const previewNode = useMemo(() => ChimneyNode.parse({
+        ...chimneyDefinition.defaults(),
+        name: 'Chimney',
+        position: [0, 0, 0],
+        rotation: 0,
+    }), []);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const computeSegmentXform = (segmentId) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            const segObj = sceneRegistry.nodes.get(segmentId);
+            if (!(buildingObj && segObj))
+                return null;
+            buildingObj.updateWorldMatrix(true, false);
+            segObj.updateWorldMatrix(true, false);
+            tmpInv.copy(buildingObj.matrixWorld).invert();
+            tmpMatrix.multiplyMatrices(tmpInv, segObj.matrixWorld);
+            tmpMatrix.decompose(tmpPos, tmpQuat, tmpScale);
+            return {
+                position: [tmpPos.x, tmpPos.y, tmpPos.z],
+                quaternion: [tmpQuat.x, tmpQuat.y, tmpQuat.z, tmpQuat.w],
+            };
+        };
+        const updatePreview = (event) => {
+            const wx = event.position[0];
+            const wy = event.position[1];
+            const wz = event.position[2];
+            const sx = Math.round(wx * 20) / 20;
+            const sz = Math.round(wz * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            const hit = resolveRoofSegmentHit(event.node, wx, wy, wz);
+            if (!hit)
+                return;
+            const xform = computeSegmentXform(hit.segment.id);
+            if (!xform)
+                return;
+            setSegmentXform(xform);
+            setHitLocal([hit.localX, hit.localY, hit.localZ]);
+            setPreviewSegment(hit.segment);
+            publishRoofSurfacePlacementGuides({
+                roof: event.node,
+                segment: hit.segment,
+                center: [hit.localX, hit.localY, hit.localZ],
+                footprint: roofSurfaceFootprintFromNode(previewNode, { segment: hit.segment }),
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const state = useScene.getState();
+            const chimney = ChimneyNode.parse({
+                ...chimneyDefinition.defaults(),
+                name: 'Chimney',
+                roofSegmentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                rotation: 0,
+            });
+            state.createNode(chimney, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [chimney.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(ChimneyPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
+                    setSegmentXform(null);
+                    setHitLocal(null);
+                    setPreviewSegment(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && segmentXform && hitLocal && previewSegment && (_jsx("group", { position: segmentXform.position, quaternion: segmentXform.quaternion, children: _jsx("group", { position: [hitLocal[0], 0, hitLocal[2]], children: _jsx(ChimneyPreview, { node: previewNode, segment: previewSegment }) }) }))] }));
+};
+export default ChimneyTool;

package/dist/column/definition.d.ts

@@ -0,0 +1,21 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { ColumnNode } from './schema';
+/**
+ * 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 declare const columnDefinition: NodeDefinition<typeof ColumnNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/column/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA8RrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAyF9D,CAAA"}

package/dist/column/definition.js

@@ -0,0 +1,375 @@
+import { ColumnNode as ColumnNodeSchema, } from '@pascal-app/core';
+import { buildColumnFloorplan } from './floorplan';
+import { columnResizeAffordance, columnRotateAffordance } from './floorplan-affordances';
+import { columnFloorplanMoveTarget } from './floorplan-move';
+import { columnPaint } from './paint';
+import { columnParametrics } from './parametrics';
+import { ColumnNode } from './schema';
+import { columnSlots } from './slots';
+// 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',
+]);
+// 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.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) {
+    // 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 = [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 (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(), columnMoveHandle());
+    return handles;
+}
+/**
+ * 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: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: 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 },
+        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'),
+    },
+    // 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'),
+    toolHints: [
+        { key: 'Left click', label: 'Place column' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    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.',
+    },
+};

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

@@ -0,0 +1,32 @@
+import { type ColumnNode, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * One drag pattern for every column size handle. The arrow's outward
+ * direction in plan coords (`planAxis`) is captured at emit-time; the
+ * affordance projects the cursor along that axis and applies the delta
+ * to the dimension named by `dim`.
+ *
+ * Sign / factor mirror the 3D `column/definition.ts` handles:
+ *
+ *   - `width` / `depth` / `uniform` / `brace-width` / `brace-depth` /
+ *     `brace-bottom-spread` / `brace-top-spread`: `anchor: 'center'` —
+ *     a cursor delta of `d` along the outward axis grows the dimension
+ *     by `2·d` (both faces move ±d so the centre stays put).
+ *   - `radius`: `kind: 'radial-resize'` — cursor delta `d` grows the
+ *     radius by `d` (the visible edge follows the cursor 1:1).
+ */
+export type ColumnResizePayload = {
+    dim: 'width' | 'depth' | 'uniform' | 'radius' | 'brace-width' | 'brace-depth' | 'brace-bottom-spread' | 'brace-top-spread';
+    planAxis: [number, number];
+};
+export declare const columnResizeAffordance: FloorplanAffordance<ColumnNode>;
+/**
+ * Column rotation drag (floor-plan). Sister to the 3D
+ * `columnRotateHandle` (arc-resize). Same `- delta` convention as the
+ * 3D handle: the floor-plan builder plots the footprint at
+ * `-column.rotation` (see `buildColumnFloorplan`'s `rot = -node.rotation`),
+ * so the 2D view rotates the same direction as 3D for the same
+ * `rotation` value, and the same cursor gesture writes the same sign
+ * in both views.
+ */
+export declare const columnRotateAffordance: FloorplanAffordance<ColumnNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +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,EAEzB,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;;;;;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,CAkFlE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CA8BlE,CAAA"}