@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/column/floorplan.js

@@ -1,6 +1,8 @@
 import { scriptImages, } from '@pascal-app/core';
 import { floorplanGeometryMetadata } from '@pascal-app/editor';
 import { collectStructuralGridAxes, resolveStructuralGridReference, } from '../structural-grid/coordination.js';
+import { columnFootprintHalf } from './bounds.js';
+import { isManagedColumn } from './edit-policy.js';
 // Offsets for the floor-plan selection arrows. Resize chevrons hug the
 // footprint a hair off the rim; the rotate-arrow corner sits a bit
 // further out so it doesn't crowd the resize arrows.
@@ -39,7 +41,12 @@ export function buildColumnFloorplan(node, ctx) {
     const isSelected = view?.selected ?? false;
     const isHighlighted = view?.highlighted ?? false;
     const showSelectedChrome = isSelected || isHighlighted;
-    const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#374151';
+    const hovered = view?.hovered ?? false;
+    const stroke = hovered
+        ? (palette?.wallHoverStroke ?? '#38bdf8')
+        : showSelectedChrome && palette
+            ? palette.selectedStroke
+            : '#374151';
     const fill = showSelectedChrome ? '#fed7aa' : '#9ca3af';
     // A scripted column draws its floor-plan image the way a catalog item does.
     const floorPlanUrl = scriptImages(node)?.floorPlan;
@@ -49,7 +56,7 @@ export function buildColumnFloorplan(node, ctx) {
         // Transparent, not none: the body stays the hit target under the image.
         fill: floorPlanUrl ? 'transparent' : fill,
         stroke,
-        strokeWidth: showSelectedChrome ? 0.03 : 0.02,
+        strokeWidth: hovered ? 0.045 : showSelectedChrome ? 0.03 : 0.02,
         opacity: 0.92,
         metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
     };
@@ -85,7 +92,7 @@ export function buildColumnFloorplan(node, ctx) {
         if (showSelectedChrome)
             children.push({ ...body, fill: 'none', pointerEvents: 'none', metadata: undefined });
     }
-    const { halfX, halfZ } = columnPlanHalfExtents(node);
+    const { halfX, halfZ } = columnFootprintHalf(node);
     const centerMarkHalf = Math.min(0.09, Math.max(0.035, Math.min(halfX, halfZ) * 0.45));
     const centerX = node.position[0];
     const centerZ = node.position[2];
@@ -112,6 +119,23 @@ export function buildColumnFloorplan(node, ctx) {
         pointerEvents: 'none',
         metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
     });
+    // A framing post reads as a framing plan draws one: its own square (not its base's) crossed
+    // corner to corner.
+    if (node.role === 'post') {
+        const square = getRotatedRectanglePolygon({ x: centerX, y: centerZ }, node.width, node.depth, -node.rotation);
+        for (const [a, b] of [[square[0], square[2]], [square[1], square[3]]])
+            children.push({
+                kind: 'line',
+                x1: a.x,
+                y1: a.y,
+                x2: b.x,
+                y2: b.y,
+                stroke,
+                strokeWidth: 0.9,
+                vectorEffect: 'non-scaling-stroke',
+                pointerEvents: 'none',
+            });
+    }
     const levelData = ctx.levelData;
     const gridReference = resolveStructuralGridReference([centerX, centerZ], levelData?.structuralGrids ?? []);
     if (gridReference) {
@@ -145,10 +169,11 @@ export function buildColumnFloorplan(node, ctx) {
     // `column/definition.ts`'s handle selection so what users can
     // manipulate in 3D top-view is the same in the floor plan.
     if (isSelected) {
-        children.push({
-            kind: 'move-handle',
-            point: [node.position[0], node.position[2]],
-        });
+        if (!isManagedColumn(node))
+            children.push({
+                kind: 'move-handle',
+                point: [node.position[0], node.position[2]],
+            });
         const cx = node.position[0];
         const cz = node.position[2];
         // Floor-plan plots at `-rotation` so SVG-CW maps to Three.js-CCW.
@@ -192,6 +217,9 @@ export function buildColumnFloorplan(node, ctx) {
             emitArrowAlong('brace-width', 'x', halfBraceX + RESIZE_ARROW_OFFSET);
             emitArrowAlong('brace-depth', 'z', halfBraceZ + RESIZE_ARROW_OFFSET);
         }
+        else if (isManagedColumn(node)) {
+            // The parent assembly owns this post's footprint.
+        }
         else if (ROUND_CROSS_SECTIONS.has(node.crossSection)) {
             // Round shafts — single radius arrow. `radial-resize` factor 1
             // (cursor delta = radius delta), so dragging the chevron
@@ -242,32 +270,6 @@ export function getColumnFloorplanFootprint(node) {
     }
     return getColumnPlanFootprint(node).map((point) => [point.x, point.y]);
 }
-/**
- * XZ half-extents for the column's plan footprint. Mirrors the 3D
- * `columnFootprintHalf` so side-arrows + rotate-arrow ring the same
- * bounding box the in-world handles use. Vertical supports read the
- * shaft geometry; non-vertical supports use the widest brace bound so
- * arrows clear the splay.
- */
-function columnPlanHalfExtents(column) {
-    if (column.source)
-        return { halfX: column.width / 2, halfZ: column.depth / 2 };
-    if (column.supportStyle !== 'vertical') {
-        return {
-            halfX: Math.max(column.width, column.braceWidth ?? 0, column.braceBottomSpread ?? 0, column.braceTopSpread ?? 0) / 2,
-            halfZ: Math.max(column.depth, column.braceDepth ?? 0) / 2,
-        };
-    }
-    if (column.crossSection === 'round' ||
-        column.crossSection === 'octagonal' ||
-        column.crossSection === 'sixteen-sided') {
-        return { halfX: column.radius, halfZ: column.radius };
-    }
-    if (column.crossSection === 'square') {
-        return { halfX: column.width / 2, halfZ: column.width / 2 };
-    }
-    return { halfX: column.width / 2, halfZ: column.depth / 2 };
-}
 function rotatePlanVector(x, y, rotation) {
     const c = Math.cos(rotation);
     const s = Math.sin(rotation);
@@ -288,63 +290,20 @@ function getRotatedRectanglePolygon(center, width, depth, rotation) {
     });
 }
 function getColumnPlanFootprint(column) {
-    const center = { x: column.position[0], y: column.position[2] };
-    // Brace-support columns: rotated rectangle spanning the base spread.
-    if (column.supportStyle === 'a-frame' ||
-        column.supportStyle === 'y-frame' ||
-        column.supportStyle === 'v-frame' ||
-        column.supportStyle === 'x-brace' ||
-        column.supportStyle === 'k-brace' ||
-        column.supportStyle === 'single-strut' ||
-        column.supportStyle === 'tripod' ||
-        column.supportStyle === 'trestle' ||
-        column.supportStyle === 'portal-frame' ||
-        column.supportStyle === 'box-frame') {
-        const width = Math.max(column.supportStyle === 'a-frame' ||
-            column.supportStyle === 'x-brace' ||
-            column.supportStyle === 'k-brace' ||
-            column.supportStyle === 'single-strut' ||
-            column.supportStyle === 'tripod' ||
-            column.supportStyle === 'trestle' ||
-            column.supportStyle === 'portal-frame' ||
-            column.supportStyle === 'box-frame'
-            ? (column.braceBottomSpread ?? 1.2)
-            : 0, column.braceTopSpread ??
-            (column.supportStyle === 'y-frame' ||
-                column.supportStyle === 'v-frame' ||
-                column.supportStyle === 'x-brace' ||
-                column.supportStyle === 'k-brace' ||
-                column.supportStyle === 'single-strut' ||
-                column.supportStyle === 'tripod' ||
-                column.supportStyle === 'trestle' ||
-                column.supportStyle === 'portal-frame' ||
-                column.supportStyle === 'box-frame'
-                ? 1
-                : 0), (column.braceWidth ?? column.width) * 2);
-        const depth = Math.max(column.supportStyle === 'tripod' ||
-            column.supportStyle === 'trestle' ||
-            column.supportStyle === 'box-frame'
-            ? (column.braceTopSpread ?? 1)
-            : 0, column.braceDepth ?? column.depth, 0.08);
-        return getRotatedRectanglePolygon(center, width, depth, -column.rotation);
-    }
-    // Standalone column: shaft profile expanded for base + capital.
-    const isRound = column.crossSection === 'round' ||
-        column.crossSection === 'octagonal' ||
-        column.crossSection === 'sixteen-sided';
-    const shaftWidth = isRound ? column.radius * 2 : column.width;
-    const shaftDepth = isRound ? column.radius * 2 : column.depth;
-    const width = Math.max(shaftWidth, column.width * column.baseWidthScale, column.width * column.capitalWidthScale);
-    const depth = Math.max(shaftDepth, column.depth * column.baseDepthScale, column.depth * column.capitalDepthScale);
-    if (column.crossSection === 'square' || column.crossSection === 'rectangular') {
-        return getRotatedRectanglePolygon(center, width, depth, -column.rotation);
+    const { halfX, halfZ } = columnFootprintHalf(column);
+    if (column.supportStyle === 'vertical' &&
+        column.style !== 'cluster' &&
+        ROUND_CROSS_SECTIONS.has(column.crossSection) &&
+        column.baseStyle === 'none' &&
+        ['none', 'simple', 'simple-slab'].includes(column.capitalStyle) &&
+        column.panelCount === 0 &&
+        column.shaftDetail !== 'panelled') {
+        const segments = column.crossSection === 'octagonal' ? 8 : column.crossSection === 'sixteen-sided' ? 16 : 32;
+        return Array.from({ length: segments }, (_, i) => {
+            const angle = (i * Math.PI * 2) / segments;
+            const [x, z] = rotatePlanVector(Math.sin(angle) * halfX, Math.cos(angle) * halfZ, -column.rotation);
+            return { x: column.position[0] + x, y: column.position[2] + z };
+        });
     }
-    const segmentCount = column.crossSection === 'octagonal' ? 8 : column.crossSection === 'sixteen-sided' ? 16 : 32;
-    return Array.from({ length: segmentCount }, (_, index) => {
-        const angle = (index / segmentCount) * Math.PI * 2;
-        const localX = Math.cos(angle) * (width / 2);
-        const localY = Math.sin(angle) * (depth / 2);
-        const [offsetX, offsetY] = rotatePlanVector(localX, localY, -column.rotation);
-        return { x: center.x + offsetX, y: center.y + offsetY };
-    });
+    return getRotatedRectanglePolygon({ x: column.position[0], y: column.position[2] }, halfX * 2, halfZ * 2, -column.rotation);
 }

package/dist/column/geometry.d.ts

@@ -0,0 +1,13 @@
+import type { ColumnNode } from '@pascal-app/core';
+import { BufferGeometry } from 'three';
+export declare function createColumnShaftGeometry(node: Pick<ColumnNode, 'crossSection' | 'radius' | 'width' | 'depth' | 'shaftProfile' | 'shaftTaper' | 'shaftBulge' | 'shaftStartScale' | 'shaftEndScale' | 'shaftSegmentCount' | 'shaftTwistStep' | 'shaftCornerRadius' | 'edgeSoftness' | 'fluteCount' | 'fluteWidth' | 'fluteDepth' | 'shaftDetail'>, height: number, range?: {
+    start: number;
+    end: number;
+    outset: number;
+}): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+type ShaftSurfaceNode = Pick<ColumnNode, 'radius' | 'width' | 'depth' | 'crossSection' | 'shaftProfile' | 'shaftTaper' | 'shaftBulge' | 'shaftStartScale' | 'shaftEndScale' | 'shaftSegmentCount' | 'shaftTwistStep' | 'shaftCornerRadius' | 'fluteCount' | 'fluteWidth' | 'fluteDepth' | 'shaftDetail'>;
+export declare function createColumnSpiralGeometry(node: ShaftSurfaceNode & Pick<ColumnNode, 'spiralRibCount' | 'spiralTwist'>, height: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap> | null;
+export declare function createColumnPanelGeometry(node: ColumnNode, height: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap> | null;
+export declare function createColumnBandGeometry(node: ColumnNode, height: number): BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap> | null;
+export {};
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/column/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,cAAc,EAA+D,MAAM,OAAO,CAAA;AAenG,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CACR,UAAU,EACR,cAAc,GACd,QAAQ,GACR,OAAO,GACP,OAAO,GACP,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,aAAa,CAChB,EACD,MAAM,EAAE,MAAM,EACd,KAAK;IAAK,KAAK;IAAK,GAAG;IAAK,MAAM;CAAK,kGA+HxC;AAED,KAAK,gBAAgB,GAAG,IAAI,CAC1B,UAAU,EACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,cAAc,GACd,cAAc,GACd,YAAY,GACZ,YAAY,GACZ,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,gBAAgB,GAChB,mBAAmB,GACnB,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,aAAa,CAChB,CAAA;AAgFD,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC,UAAU,EAAE,gBAAgB,GAAG,aAAa,CAAC,EAC3E,MAAM,EAAE,MAAM,yGAqBf;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,yGAsDzE;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,yGA2ExE"}

package/dist/column/geometry.js

@@ -0,0 +1,294 @@
+import { BufferGeometry, Curve, Float32BufferAttribute, Shape, TubeGeometry, Vector3 } from 'three';
+import { mergeGeometries, toCreasedNormals } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { getSegments, getShaftScaleAt, getShaftSegmentCount, getShaftTwistRadians } from './shape.js';
+function mergeOwned(parts) {
+    if (!parts.length)
+        return null;
+    const mixed = parts.some((part) => part.index) && parts.some((part) => !part.index);
+    const compatible = mixed ? parts.map((part) => (part.index ? part.toNonIndexed() : part)) : parts;
+    try {
+        return mergeGeometries(compatible);
+    }
+    finally {
+        for (const part of new Set([...parts, ...compatible]))
+            part.dispose();
+    }
+}
+export function createColumnShaftGeometry(node, height, range = { start: 0, end: 1, outset: 0 }) {
+    const count = getShaftSegmentCount(node);
+    const rectangular = node.crossSection === 'square' || node.crossSection === 'rectangular';
+    const fluteCount = node.crossSection === 'round'
+        ? Math.max(node.fluteCount, node.shaftDetail === 'fluted' ? 16 : 0)
+        : 0;
+    const radialSegments = fluteCount ? Math.max(32, fluteCount * 6) : getSegments(node);
+    const shape = new Shape();
+    if (rectangular) {
+        const x = node.width / 2, z = node.depth / 2;
+        const r = Math.min(Math.max(0, node.shaftCornerRadius), Math.min(node.width, node.depth) * 0.45);
+        shape.moveTo(-x + r, -z);
+        shape.lineTo(x - r, -z);
+        if (r > 0)
+            shape.absarc(x - r, -z + r, r, -Math.PI / 2, 0, false);
+        shape.lineTo(x, z - r);
+        if (r > 0)
+            shape.absarc(x - r, z - r, r, 0, Math.PI / 2, false);
+        shape.lineTo(-x + r, z);
+        if (r > 0)
+            shape.absarc(-x + r, z - r, r, Math.PI / 2, Math.PI, false);
+        shape.lineTo(-x, -z + r);
+        if (r > 0)
+            shape.absarc(-x + r, -z + r, r, Math.PI, Math.PI * 1.5, false);
+        shape.closePath();
+    }
+    const contour = rectangular
+        ? shape
+            .getPoints(5)
+            .filter((point, i, points) => i === 0 || point.distanceTo(points[i - 1]) > 1e-8)
+        : Array.from({ length: radialSegments }, (_, i) => {
+            const angle = (i * Math.PI * 2) / radialSegments;
+            return { x: Math.sin(angle) * node.radius, y: Math.cos(angle) * node.radius };
+        }).reverse();
+    const first = contour[0], last = contour.at(-1);
+    if (Math.hypot(first.x - last.x, first.y - last.y) < 1e-8)
+        contour.pop();
+    const positions = [], uvs = [], indices = [];
+    const perimeter = [0];
+    for (let j = 0; j < contour.length; j++) {
+        const a = contour[j], b = contour[(j + 1) % contour.length];
+        perimeter.push(perimeter[j] + Math.hypot(b.x - a.x, b.y - a.y));
+    }
+    const ringSize = contour.length + 1;
+    const endScale = Math.min(getShaftScaleAt(node, range.start), getShaftScaleAt(node, range.end)) + range.outset;
+    const bevel = Math.min(Math.max(0, node.edgeSoftness), height * 0.35, (rectangular ? Math.min(node.width, node.depth) / 2 : node.radius) * endScale * 0.35);
+    const levels = Array.from({ length: count + 1 }, (_, i) => (height * i) / count);
+    if (bevel > 0) {
+        for (let step = 1; step <= 4; step++)
+            levels.push(bevel * (1 - Math.cos((step * Math.PI) / 8)));
+        // Keep top-edge ray hits stable for objects placed on the pillar.
+        for (let step = 1; step <= 12; step++)
+            levels.push(height - bevel * (1 - Math.cos((step * Math.PI) / 24)));
+    }
+    const rows = [...new Set(levels)].sort((a, b) => a - b);
+    const lastRow = rows.length - 1;
+    for (let i = 0; i <= lastRow; i++) {
+        const t = range.start + ((range.end - range.start) * rows[i]) / height, scale = getShaftScaleAt(node, t) + range.outset;
+        const yaw = getShaftTwistRadians(node, t * Math.max(0, count - 1));
+        for (let j = 0; j <= contour.length; j++) {
+            const p = contour[j % contour.length];
+            const groove = fluteCount ? fluteInset(node, Math.atan2(p.y, p.x), scale) : 0;
+            const radialScale = scale - groove / node.radius;
+            const distanceToEnd = Math.min(rows[i], height - rows[i]);
+            const inset = distanceToEnd < bevel
+                ? bevel - Math.sqrt(Math.max(0, bevel ** 2 - (bevel - distanceToEnd) ** 2))
+                : 0;
+            const length = Math.hypot(p.x, p.y);
+            const softenedScale = Math.max(0.001, radialScale - inset / length);
+            positions.push(softenedScale * (p.x * Math.cos(yaw) + p.y * Math.sin(yaw)), rows[i], softenedScale * (-p.x * Math.sin(yaw) + p.y * Math.cos(yaw)));
+            uvs.push(perimeter[j] * scale, rows[i]);
+            if (i < lastRow && j < contour.length) {
+                const a = i * ringSize + j, b = a + ringSize;
+                indices.push(a, b, a + 1, a + 1, b, b + 1);
+            }
+        }
+    }
+    // Separate cap vertices keep the rim sharp and planar UVs in metres.
+    for (const row of [0, lastRow]) {
+        const start = positions.length / 3;
+        positions.push(0, row === 0 ? 0 : height, 0);
+        uvs.push(0, 0);
+        for (let j = 0; j < contour.length; j++) {
+            const offset = (row * ringSize + j) * 3;
+            positions.push(positions[offset], positions[offset + 1], positions[offset + 2]);
+            uvs.push(positions[offset], positions[offset + 2]);
+            const a = start + 1 + j, b = start + 1 + ((j + 1) % contour.length);
+            indices.push(...(row === 0 ? [start, a, b] : [start, b, a]));
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+    geometry.setAttribute('uv2', geometry.getAttribute('uv').clone());
+    geometry.setIndex(indices);
+    geometry.computeVertexNormals();
+    const normals = geometry.getAttribute('normal');
+    for (let i = 0; i <= lastRow; i++) {
+        const a = i * ringSize, b = a + contour.length;
+        const normal = new Vector3()
+            .fromBufferAttribute(normals, a)
+            .add(new Vector3().fromBufferAttribute(normals, b))
+            .normalize();
+        normals.setXYZ(a, normal.x, normal.y, normal.z);
+        normals.setXYZ(b, normal.x, normal.y, normal.z);
+    }
+    if (node.crossSection !== 'round') {
+        const creased = toCreasedNormals(geometry, 0.2);
+        geometry.dispose();
+        return creased;
+    }
+    return geometry;
+}
+function fluteInset(node, angle, scale) {
+    const count = Math.max(node.fluteCount, node.shaftDetail === 'fluted' ? 16 : 0);
+    if (!count)
+        return 0;
+    const phase = Math.atan2(Math.sin(angle * count), Math.cos(angle * count)) / count;
+    const halfWidth = Math.min(node.fluteWidth / 2, ((node.radius * scale * Math.PI) / count) * 0.8);
+    const distance = Math.abs(phase) * node.radius * scale;
+    if (distance >= halfWidth)
+        return 0;
+    return ((Math.min(node.fluteDepth, node.radius * scale * 0.35) *
+        (1 + Math.cos((Math.PI * distance) / halfWidth))) /
+        2);
+}
+/** Interpolate the same sections as the shaft so details stay attached between rings. */
+function shaftPoint(node, height, angle, t) {
+    const count = getShaftSegmentCount(node), row = Math.min(count - 1, Math.floor(t * count));
+    const pointAt = (i) => {
+        const scale = getShaftScaleAt(node, i / count);
+        const c = Math.cos(angle), s = Math.sin(angle);
+        let radius = node.radius;
+        if (node.crossSection === 'square' || node.crossSection === 'rectangular') {
+            const x = node.width / 2, z = node.depth / 2;
+            radius = Math.min(x / Math.max(1e-9, Math.abs(c)), z / Math.max(1e-9, Math.abs(s)));
+            const corner = Math.min(node.shaftCornerRadius, Math.min(node.width, node.depth) * 0.45);
+            if (Math.abs(radius * c) > x - corner && Math.abs(radius * s) > z - corner) {
+                const dot = Math.abs(c) * (x - corner) + Math.abs(s) * (z - corner);
+                radius =
+                    dot +
+                        Math.sqrt(Math.max(0, dot * dot - (x - corner) ** 2 - (z - corner) ** 2 + corner ** 2));
+            }
+        }
+        else {
+            const segments = getSegments(node);
+            const phase = (((angle - Math.PI / 2) % ((2 * Math.PI) / segments)) + (2 * Math.PI) / segments) %
+                ((2 * Math.PI) / segments);
+            if (node.crossSection !== 'round')
+                radius *= Math.cos(Math.PI / segments) / Math.cos(phase - Math.PI / segments);
+        }
+        const distance = radius * scale - (node.crossSection === 'round' ? fluteInset(node, angle, scale) : 0);
+        const yaw = getShaftTwistRadians(node, (i / count) * Math.max(0, count - 1));
+        return new Vector3(Math.cos(angle - yaw) * distance, (height * i) / count, Math.sin(angle - yaw) * distance);
+    };
+    return pointAt(row).lerp(pointAt(row + 1), t * count - row);
+}
+class SurfaceCurve extends Curve {
+    sample;
+    constructor(sample) {
+        super();
+        this.sample = sample;
+    }
+    getPoint(t, target = new Vector3()) {
+        return target.copy(this.sample(t));
+    }
+}
+function surfaceTube(sample, steps, radius) {
+    const curve = new SurfaceCurve(sample);
+    const geometry = new TubeGeometry(curve, steps, radius, 6, false);
+    const uv = geometry.getAttribute('uv'), length = curve.getLength();
+    for (let i = 0; i < uv.count; i++)
+        uv.setXY(i, uv.getX(i) * length, uv.getY(i) * Math.PI * 2 * radius);
+    geometry.setAttribute('uv2', uv.clone());
+    return geometry;
+}
+export function createColumnSpiralGeometry(node, height) {
+    const count = Math.min(Math.max(node.spiralRibCount, node.shaftDetail === 'spiral' ? 12 : 0), 32);
+    if (!count || !node.spiralTwist || height <= 0)
+        return null;
+    const parts = [];
+    for (let i = 0; i < count; i++) {
+        parts.push(surfaceTube((t) => shaftPoint(node, height, (i / count) * Math.PI * 2 + t * node.spiralTwist * Math.PI * 2, 0.02 + t * 0.96), Math.max(32, Math.ceil(Math.abs(node.spiralTwist) * 32), getShaftSegmentCount(node) * 2), Math.max(0.012, node.radius * 0.06)));
+    }
+    return mergeOwned(parts);
+}
+export function createColumnPanelGeometry(node, height) {
+    const count = Math.max(node.panelCount, node.style === 'dravidian-carved' || node.shaftDetail === 'panelled' ? 3 : 0);
+    if (!count || height <= 0)
+        return null;
+    const parts = [];
+    const halfHeight = Math.min(0.42, height / Math.max(4, count + 2)) / height / 2;
+    const rail = Math.max(0.006, node.width * 0.014);
+    const halfAngle = 0.33;
+    for (let row = 0; row < count; row++) {
+        const center = (row + 1) / (count + 1);
+        for (let face = 0; face < 4; face++) {
+            const angle = (face * Math.PI) / 2;
+            const line = (a, b, c, d) => {
+                parts.push(surfaceTube((t) => {
+                    const point = shaftPoint(node, height, angle + a + (c - a) * t, b + (d - b) * t);
+                    const radial = new Vector3(point.x, 0, point.z).normalize();
+                    return point.addScaledVector(radial, Math.max(0, node.panelInsetDepth) / 2);
+                }, Math.max(16, getShaftSegmentCount(node) * 2), rail));
+            };
+            line(-halfAngle, center - halfHeight, halfAngle, center - halfHeight);
+            line(-halfAngle, center + halfHeight, halfAngle, center + halfHeight);
+            line(-halfAngle, center - halfHeight, -halfAngle, center + halfHeight);
+            line(halfAngle, center - halfHeight, halfAngle, center + halfHeight);
+            if (node.panelShape === 'diamond') {
+                line(0, center + halfHeight * 0.8, halfAngle * 0.8, center);
+                line(halfAngle * 0.8, center, 0, center - halfHeight * 0.8);
+                line(0, center - halfHeight * 0.8, -halfAngle * 0.8, center);
+                line(-halfAngle * 0.8, center, 0, center + halfHeight * 0.8);
+            }
+            else if (node.panelShape === 'arched') {
+                parts.push(surfaceTube((t) => shaftPoint(node, height, angle + Math.cos(t * Math.PI) * halfAngle * 0.8, center + Math.sin(t * Math.PI) * halfHeight * 0.8), 32, rail));
+            }
+        }
+    }
+    return mergeOwned(parts);
+}
+export function createColumnBandGeometry(node, height) {
+    const parts = [];
+    const band = (t, thickness, outset) => {
+        const start = Math.max(0, t - thickness / height / 2);
+        const end = Math.min(1, t + thickness / height / 2);
+        const geometry = createColumnShaftGeometry({ ...node, fluteCount: 0, shaftDetail: 'none' }, (end - start) * height, { start, end, outset });
+        geometry.translate(0, start * height, 0);
+        parts.push(geometry);
+    };
+    const ringSpread = Math.min(0.45, Math.max(0.04, node.ringSpread));
+    for (let i = 0; i < node.ringCount; i++) {
+        const pairCount = Math.ceil(node.ringCount / 2);
+        const pairT = pairCount <= 1 ? 0 : Math.floor(i / 2) / (pairCount - 1);
+        const offset = Math.min(0.48, 0.06 + pairT * Math.max(0, ringSpread - 0.06));
+        const oneSide = Math.min(0.48, 0.06 + (i / Math.max(1, node.ringCount - 1)) * Math.max(0, ringSpread - 0.06));
+        const t = node.ringPlacement === 'even'
+            ? (i + 1) / (node.ringCount + 1)
+            : node.ringPlacement === 'top'
+                ? 1 - oneSide
+                : node.ringPlacement === 'bottom'
+                    ? oneSide
+                    : i % 2
+                        ? 1 - offset
+                        : offset;
+        band(t, Math.min(node.ringThickness, height / Math.max(8, node.ringCount * 3)), 0.12);
+    }
+    const count = Math.max(node.latheRingCount, node.shaftDetail === 'lathe-turned' ? 8 : 0);
+    for (let i = 0; i < count; i++) {
+        const offset = Math.min(0.48, 0.1 + Math.floor(i / 2) * 0.04);
+        const oneSide = Math.min(0.48, 0.08 + i * 0.04);
+        const t = node.latheRingSpacing === 'even'
+            ? (i + 1) / (count + 1)
+            : node.latheRingSpacing === 'top'
+                ? 1 - oneSide
+                : node.latheRingSpacing === 'bottom'
+                    ? oneSide
+                    : i % 2
+                        ? 1 - offset
+                        : offset;
+        band(t, Math.min(0.04, height / Math.max(12, count * 3)), 0.1 + (i % 2) * 0.08);
+    }
+    if (node.lowerBandEnabled && ['shaft', 'all'].includes(node.carvingPlacement)) {
+        const size = Math.min(node.lowerBandHeight, height * 0.35);
+        band(0.12 + size / height / 2, size, 0.12);
+        const ribs = Math.max(6, node.lowerBandCarvingLevel * 6);
+        for (let i = 0; i < ribs; i++) {
+            parts.push(surfaceTube((t) => {
+                const point = shaftPoint(node, height, (i / ribs) * Math.PI * 2, 0.12 + (size / height) * (0.19 + t * 0.62));
+                point.x *= 1 + 0.12 / getShaftScaleAt(node, point.y / height);
+                point.z *= 1 + 0.12 / getShaftScaleAt(node, point.y / height);
+                return point;
+            }, 24, 0.012));
+        }
+    }
+    return mergeOwned(parts);
+}

package/dist/column/hosted-resize.d.ts

@@ -1,5 +1,6 @@
-import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type ColumnNode } from '@pascal-app/core';
 export declare const columnHostedPolicy: {
+    localSurfaces: boolean;
     host: (node: AnyNode) => node is {
         type: "column";
         object: "node";
@@ -92,6 +93,16 @@ export declare const columnHostedPolicy: {
                     color: string;
                     intensity: number;
                     distance?: number | undefined;
+                    spot?: {
+                        direction: [number, number, number];
+                        angle: number;
+                        softness: number;
+                    } | undefined;
+                    shadows?: boolean | undefined;
+                    glow?: {
+                        size: number;
+                        strength: number;
+                    } | undefined;
                 }[];
                 undersides: {
                     part?: string | undefined;
@@ -110,6 +121,17 @@ export declare const columnHostedPolicy: {
                 }[] | undefined;
                 cutout: boolean;
                 collider: boolean;
+                shape?: {
+                    tolerance: number;
+                    bands: {
+                        y0: number;
+                        y1: number;
+                        polygons: {
+                            outer: [number, number][];
+                            holes?: [number, number][][] | undefined;
+                        }[];
+                    }[];
+                } | undefined;
                 triangles: number;
                 coverage?: number | undefined;
                 uncovered?: {
@@ -194,7 +216,8 @@ export declare const columnHostedPolicy: {
         braceBottomSpread: number;
         braceTopSpread: number;
         bracePlateEnabled: boolean;
-        role?: "ornament" | undefined;
+        role?: "ornament" | "post" | undefined;
+        postBase?: "none" | "pier" | "post-base" | undefined;
         material?: {
             id?: string | undefined;
             preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
@@ -210,6 +233,11 @@ export declare const columnHostedPolicy: {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         materialPreset?: string | undefined;
@@ -217,5 +245,5 @@ export declare const columnHostedPolicy: {
     };
     child: (_node: AnyNode) => boolean;
 };
-export declare function planColumnEdit(id: AnyNodeId, patch: Partial<AnyNode>): import("../shared/hosted-resize.js").HostedUpdate[] | null;
+export declare function planColumnEdit(id: AnyNodeId, patch: Partial<ColumnNode>): import("../shared/hosted-resize.js").HostedUpdate[] | null;
 //# sourceMappingURL=hosted-resize.d.ts.map

package/dist/column/hosted-resize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosted-resize.d.ts","sourceRoot":"","sources":["../../src/column/hosted-resize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAA4B,MAAM,kBAAkB,CAAA;AAGzF,eAAO,MAAM,kBAAkB;iBAChB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBACL,OAAO;CACvB,CAAA;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,2DAMpE"}
+{"version":3,"file":"hosted-resize.d.ts","sourceRoot":"","sources":["../../src/column/hosted-resize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,UAAU,EAGhB,MAAM,kBAAkB,CAAA;AAIzB,eAAO,MAAM,kBAAkB;;iBAEhB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBACL,OAAO;CACvB,CAAA;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,2DASvE"}

package/dist/column/hosted-resize.js

@@ -1,9 +1,15 @@
-import { createSceneApi, useScene } from '@pascal-app/core';
+import { createSceneApi, useScene, } from '@pascal-app/core';
 import { planHostedEdit } from '../shared/hosted-resize.js';
+import { columnEditPatch } from './edit-policy.js';
 export const columnHostedPolicy = {
+    localSurfaces: true,
     host: (node) => node.type === 'column',
     child: (_node) => true,
 };
 export function planColumnEdit(id, patch) {
+    const node = useScene.getState().nodes[id];
+    if (node?.type !== 'column')
+        return null;
+    patch = columnEditPatch(node, patch);
     return planHostedEdit(createSceneApi(useScene), (scene) => scene.update(id, patch), columnHostedPolicy);
 }

package/dist/column/inspector-highlight.d.ts

@@ -0,0 +1,29 @@
+import type { AnyNodeId, ColumnNode, ColumnSlotId } from '@pascal-app/core';
+import { type ReactNode, type RefObject } from 'react';
+import { type Group } from 'three';
+type Target = {
+    part: ColumnSlotId | 'all';
+    axis?: 'x' | 'y' | 'z';
+};
+type Highlight = Target & {
+    owner: symbol;
+    nodeId: AnyNodeId;
+};
+export declare const useColumnInspectorHighlight: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    active: Highlight | null;
+}>>;
+export declare function clearColumnInspectorHighlight(owner: symbol): void;
+export declare function setColumnInspectorHighlight(owner: symbol, nodeId: AnyNodeId, target: Target): void;
+export declare function ColumnInspectorHover({ nodeId, children, }: {
+    nodeId: AnyNodeId;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function ColumnInspectorOverlay({ nodeId, body, node, position, rotation, }: {
+    nodeId: AnyNodeId;
+    body: RefObject<Group | null>;
+    node: ColumnNode;
+    position: [number, number, number];
+    rotation: number;
+}): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=inspector-highlight.d.ts.map

package/dist/column/inspector-highlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspector-highlight.d.ts","sourceRoot":"","sources":["../../src/column/inspector-highlight.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE3E,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAA8B,MAAM,OAAO,CAAA;AAClF,OAAO,EAAwB,KAAK,KAAK,EAAwC,MAAM,OAAO,CAAA;AAI9F,KAAK,MAAM,GAAG;IAAE,IAAI,EAAE,YAAY,GAAG,KAAK,CAAC;IAAC,IAAI,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;CAAE,CAAA;AACpE,KAAK,SAAS,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAC9D,eAAO,MAAM,2BAA2B;YAAoB,SAAS,GAAG,IAAI;GAEzE,CAAA;AAEH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,QAK1D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,QAW3F;AAmBD,wBAAgB,oBAAoB,CAAC,EACnC,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,SAAS,CAAA;IACjB,QAAQ,EAAE,SAAS,CAAA;CACpB,+BAyDA;AAED,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,SAAS,CAAA;IACjB,IAAI,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;IAC7B,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,+BAmFA"}