@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/ceiling/definition.js

@@ -1,6 +1,7 @@
 import { getCeilingClampBound, resolveCeilingHeight, useScene, } from '@pascal-app/core';
 import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts';
 import { buildCeilingFloorplan } from './floorplan';
 import { ceilingAddVertexAffordance, ceilingDeleteVertexAffordance, ceilingMoveEdgeAffordance, ceilingMoveVertexAffordance, } from './floorplan-affordances';
 import { ceilingFloorplanMoveTarget } from './floorplan-move';
@@ -105,6 +106,9 @@ export const ceilingDefinition = {
             kind: 'ceiling',
             raycast: 'underside',
         },
+        'pascal:editor/floorplan': {
+            selectionCounterparts: sameOutlineSurfaceCounterparts,
+        },
     },
     // Height-less on purpose: a new ceiling follows the level top until the
     // user gives it an explicit custom height.
@@ -122,6 +126,7 @@ export const ceilingDefinition = {
     capabilities: {
         selectable: { hitVolume: 'bbox' },
         surfaces: {
+            hosting: false,
             top: {
                 height: (n) => resolveCeilingHeight(n, useScene.getState().nodes),
             },
@@ -134,7 +139,7 @@ export const ceilingDefinition = {
         paint: ceilingPaint,
     },
     relations: {
-        hosts: ['item'],
+        hosts: ['item', 'procedural-item'],
         cascadeDelete: 'descendants',
     },
     parametrics: ceilingParametrics,

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

@@ -5,7 +5,7 @@ export declare const ceilingMoveVertexAffordance: import("@pascal-app/core").Flo
     metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
@@ -50,7 +50,7 @@ export declare const ceilingAddVertexAffordance: import("@pascal-app/core").Floo
     metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
@@ -95,7 +95,7 @@ export declare const ceilingMoveEdgeAffordance: import("@pascal-app/core").Floor
     metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {
@@ -140,7 +140,7 @@ export declare const ceilingDeleteVertexAffordance: import("@pascal-app/core").F
     metadata: Record<string, unknown>;
     id: `ceiling_${string}`;
     type: "ceiling";
-    children: `item_${string}`[];
+    children: (`item_${string}` | `procedural-item_${string}`)[];
     polygon: [number, number][];
     holes: [number, number][][];
     holeMetadata: {

package/dist/ceiling/panel.js

@@ -185,7 +185,7 @@ export function CeilingPanel() {
     return (_jsxs(PanelWrapper, { icon: "/icons/ceiling.webp", onClose: handleClose, title: node.name || 'Ceiling', width: 320, children: [_jsxs(PanelSection, { title: "Height", children: [_jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
                             { label: 'Follows level', value: 'storey' },
                             { label: 'Custom height', value: 'custom' },
-                        ], value: isFollows ? 'storey' : 'custom' }), isFollows ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(resolvedHeight, unit, metricNotation)] })) : (_jsx(SliderControl, { label: "Height", max: Math.min(1000, maxHeight), min: 0, onChange: handleHeightChange, precision: 3, step: 0.01, unit: "m", value: Math.round((node.height ?? resolvedHeight) * 1000) / 1000 })), _jsx("div", { className: "mt-2 grid grid-cols-3 gap-1.5 px-1 pb-1", children: heightPresets.map((preset) => {
+                        ], value: isFollows ? 'storey' : 'custom' }), isFollows ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(resolvedHeight, unit, metricNotation)] })) : (_jsx(SliderControl, { label: "Height", max: Math.min(1000, maxHeight), min: 0, onChange: handleHeightChange, precision: 3, step: 0.01, unit: "m", value: node.height ?? resolvedHeight })), _jsx("div", { className: "mt-2 grid grid-cols-3 gap-1.5 px-1 pb-1", children: heightPresets.map((preset) => {
                             const fits = preset.height <= maxHeight;
                             return (_jsx(ActionButton, { className: fits ? undefined : 'cursor-not-allowed opacity-40', disabled: !fits, label: preset.label, onClick: () => handleHeightChange(preset.height), title: fits
                                     ? undefined

package/dist/ceiling/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ceiling/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAiBzB,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,gCAwG9D,CAAA;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ceiling/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAkBzB,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,gCA2G9D,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/ceiling/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { getMaterialPresetByRef, resolveCeilingHeight, resolveMaterial, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
-import { createSurfaceRoleMaterial, NodeRenderer, resolveSurfaceColor, useViewer, } from '@pascal-app/viewer';
+import { createSurfaceRoleMaterial, NodeRenderer, resolveSurfaceColor, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { BackSide } from 'three/webgpu';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
@@ -12,6 +12,7 @@ function createEmptyGeometry() {
 }
 export const CeilingRenderer = ({ node }) => {
     const ref = useRef(null);
+    const handlers = useNodeEvents(node, 'ceiling');
     const placeholderGeometry = useMemo(createEmptyGeometry, []);
     const gridPlaceholderGeometry = useMemo(createEmptyGeometry, []);
     useRegistry(node.id, 'ceiling', ref);
@@ -86,6 +87,6 @@ export const CeilingRenderer = ({ node }) => {
         node.material?.properties,
         node.material?.texture,
     ]);
-    return (_jsxs("mesh", { geometry: placeholderGeometry, material: materials.bottomMaterial, position: position, ref: ref, children: [_jsx("mesh", { geometry: gridPlaceholderGeometry, material: materials.topMaterial, name: "ceiling-grid", scale: 0, visible: false }), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
+    return (_jsxs("mesh", { geometry: placeholderGeometry, material: materials.bottomMaterial, position: position, ref: ref, visible: node.visible !== false, ...handlers, children: [_jsx("mesh", { geometry: gridPlaceholderGeometry, material: materials.topMaterial, name: "ceiling-grid", scale: 0, visible: false }), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId)))] }));
 };
 export default CeilingRenderer;

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/chimney/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAqUtC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAqEhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/chimney/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAqUtC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAsEhE,CAAA"}

package/dist/chimney/definition.js

@@ -365,6 +365,7 @@ export const chimneyDefinition = {
     parametrics: chimneyParametrics,
     handles: chimneyHandles,
     floorplan: buildChimneyFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/chimney/panel.js

@@ -283,7 +283,7 @@ export default function ChimneyPanel() {
                     value: activePreset ?? '' }) }), _jsxs(PanelSection, { title: "Footprint", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ bodyShape: v }), options: [
                             { label: 'Square', value: 'square' },
                             { label: 'Round', value: 'round' },
-                        ], value: node.bodyShape ?? 'square' }), _jsx(SliderControl, { label: (node.bodyShape ?? 'square') === 'round' ? 'Diameter' : 'Width', max: 1000, min: 0.2, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.width * 100) / 100 }), (node.bodyShape ?? 'square') !== 'round' && (_jsx(SliderControl, { label: "Depth", max: 1000, min: 0.2, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => commitProp({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.depth * 100) / 100 })), _jsx(SliderControl, { label: "Hollow Depth", max: 3, min: 0, onChange: (v) => previewProp({ bodyHollowDepth: v }), onCommit: (v) => commitProp({ bodyHollowDepth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.bodyHollowDepth ?? 0.6) * 100) / 100 }), _jsx(SliderControl, { label: "Wall Thickness", max: 0.3, min: 0, onChange: (v) => previewProp({ bodyHollowMargin: v }), onCommit: (v) => commitProp({ bodyHollowMargin: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.bodyHollowMargin ?? 0.08) * 1000) / 1000 }), (node.bodyShape ?? 'square') !== 'round' && (_jsx(SliderControl, { label: "Corner Bevel", max: Math.max(0, Math.min(node.width, node.depth) / 2 - 0.005), min: 0, onChange: (v) => previewProp({ cornerBevel: v }), onCommit: (v) => commitProp({ cornerBevel: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.cornerBevel ?? 0) * 1000) / 1000 }))] }), _jsxs(PanelSection, { title: "Height", children: [_jsx(SliderControl, { label: "Above Ridge", max: 1000, min: 0.1, onChange: (v) => previewProp({ heightAboveRidge: v }), onCommit: (v) => commitProp({ heightAboveRidge: v }), precision: 2, restoreOnCommit: false, step: 0.1, unit: "m", value: Math.round(node.heightAboveRidge * 100) / 100 }), _jsx(SliderControl, { label: "Cutout Offset", max: 0.5, min: 0, onChange: (v) => previewProp({ cutoutOffset: v }), onCommit: (v) => commitProp({ cutoutOffset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.cutoutOffset ?? 0) * 1000) / 1000 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
+                        ], value: node.bodyShape ?? 'square' }), _jsx(SliderControl, { label: (node.bodyShape ?? 'square') === 'round' ? 'Diameter' : 'Width', max: 1000, min: 0.2, onChange: (v) => previewProp({ width: v }), onCommit: (v) => commitProp({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.width }), (node.bodyShape ?? 'square') !== 'round' && (_jsx(SliderControl, { label: "Depth", max: 1000, min: 0.2, onChange: (v) => previewProp({ depth: v }), onCommit: (v) => commitProp({ depth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.depth })), _jsx(SliderControl, { label: "Hollow Depth", max: 3, min: 0, onChange: (v) => previewProp({ bodyHollowDepth: v }), onCommit: (v) => commitProp({ bodyHollowDepth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.bodyHollowDepth ?? 0.6 }), _jsx(SliderControl, { label: "Wall Thickness", max: 0.3, min: 0, onChange: (v) => previewProp({ bodyHollowMargin: v }), onCommit: (v) => commitProp({ bodyHollowMargin: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.bodyHollowMargin ?? 0.08 }), (node.bodyShape ?? 'square') !== 'round' && (_jsx(SliderControl, { label: "Corner Bevel", max: Math.max(0, Math.min(node.width, node.depth) / 2 - 0.005), min: 0, onChange: (v) => previewProp({ cornerBevel: v }), onCommit: (v) => commitProp({ cornerBevel: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.cornerBevel ?? 0 }))] }), _jsxs(PanelSection, { title: "Height", children: [_jsx(SliderControl, { label: "Above Ridge", max: 1000, min: 0.1, onChange: (v) => previewProp({ heightAboveRidge: v }), onCommit: (v) => commitProp({ heightAboveRidge: v }), precision: 2, restoreOnCommit: false, step: 0.1, unit: "m", value: node.heightAboveRidge }), _jsx(SliderControl, { label: "Cutout Offset", max: 0.5, min: 0, onChange: (v) => previewProp({ cutoutOffset: v }), onCommit: (v) => commitProp({ cutoutOffset: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.cutoutOffset ?? 0 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(worldMaxX * 10) / 10, min: Math.round(worldMinX * 10) / 10, onChange: (newWorldX) => {
                             // Live preview: keep the chimney parented to its current segment
                             // and update its segment-local position so the visual matches the
                             // dragged world X. Reparenting (if any) happens on commit.
@@ -291,12 +291,12 @@ export default function ChimneyPanel() {
                                 return;
                             const local = worldToSegLocal(newWorldX, worldZ_now, segment);
                             previewProp({ position: [local.localX, 0, local.localZ] });
-                        }, onCommit: (newWorldX) => commitWorldPosition(newWorldX, worldZ_now), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(worldX_now * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(worldMaxZ * 10) / 10, min: Math.round(worldMinZ * 10) / 10, onChange: (newWorldZ) => {
+                        }, onCommit: (newWorldX) => commitWorldPosition(newWorldX, worldZ_now), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldX_now }), _jsx(SliderControl, { label: "Z", max: Math.round(worldMaxZ * 10) / 10, min: Math.round(worldMinZ * 10) / 10, onChange: (newWorldZ) => {
                             if (!segment)
                                 return;
                             const local = worldToSegLocal(worldX_now, newWorldZ, segment);
                             previewProp({ position: [local.localX, 0, local.localZ] });
-                        }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(worldZ_now * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
+                        }, onCommit: (newWorldZ) => commitWorldPosition(worldX_now, newWorldZ), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: worldZ_now }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
                             // World rotation → segment-local rotation for the current segment.
                             const newWorldRot = (degrees * Math.PI) / 180;
                             let ancestorWorldY = 0;
@@ -326,25 +326,25 @@ export default function ChimneyPanel() {
                                     { label: 'Sloped', value: 'sloped' },
                                     { label: 'Flat', value: 'flat' },
                                     { label: 'Stepped', value: 'stepped' },
-                                ], value: node.capShape ?? 'sloped' }), (node.capShape ?? 'sloped') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Overhang", max: 0.2, min: 0, onChange: (v) => previewProp({ capOverhang: v }), onCommit: (v) => commitProp({ capOverhang: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.capOverhang ?? 0.04) * 1000) / 1000 }), _jsx(SliderControl, { label: "Thickness", max: 0.3, min: 0.02, onChange: (v) => previewProp({ capThickness: v }), onCommit: (v) => commitProp({ capThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.capThickness ?? 0.08) * 1000) / 1000 })] }))] })), chimneyType === 'shoulder' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ shoulderStyle: v }), options: [
+                                ], value: node.capShape ?? 'sloped' }), (node.capShape ?? 'sloped') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Overhang", max: 0.2, min: 0, onChange: (v) => previewProp({ capOverhang: v }), onCommit: (v) => commitProp({ capOverhang: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.capOverhang ?? 0.04 }), _jsx(SliderControl, { label: "Thickness", max: 0.3, min: 0.02, onChange: (v) => previewProp({ capThickness: v }), onCommit: (v) => commitProp({ capThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.capThickness ?? 0.08 })] }))] })), chimneyType === 'shoulder' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ shoulderStyle: v }), options: [
                                     { label: 'None', value: 'none' },
                                     { label: 'Tapered', value: 'tapered' },
                                     { label: 'Corbeled', value: 'corbeled' },
-                                ], value: node.shoulderStyle ?? 'none' }), (node.shoulderStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Height", max: 3, min: 0.1, onChange: (v) => previewProp({ shoulderHeight: v }), onCommit: (v) => commitProp({ shoulderHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.shoulderHeight ?? 0.5) * 100) / 100 }), _jsx(SliderControl, { label: "Extent", max: 0.5, min: 0, onChange: (v) => previewProp({ shoulderExtent: v }), onCommit: (v) => commitProp({ shoulderExtent: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.shoulderExtent ?? 0.1) * 100) / 100 })] }))] })), chimneyType === 'flues' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Count", max: 4, min: 0, onChange: (v) => previewProp({ flueCount: Math.round(v) }), onCommit: (v) => commitProp({ flueCount: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, unit: "", value: node.flueCount ?? 1 }), (node.flueCount ?? 1) > 0 && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ flueShape: v }), options: [
+                                ], value: node.shoulderStyle ?? 'none' }), (node.shoulderStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Height", max: 3, min: 0.1, onChange: (v) => previewProp({ shoulderHeight: v }), onCommit: (v) => commitProp({ shoulderHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.shoulderHeight ?? 0.5 }), _jsx(SliderControl, { label: "Extent", max: 0.5, min: 0, onChange: (v) => previewProp({ shoulderExtent: v }), onCommit: (v) => commitProp({ shoulderExtent: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: node.shoulderExtent ?? 0.1 })] }))] })), chimneyType === 'flues' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Count", max: 4, min: 0, onChange: (v) => previewProp({ flueCount: Math.round(v) }), onCommit: (v) => commitProp({ flueCount: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, unit: "", value: node.flueCount ?? 1 }), (node.flueCount ?? 1) > 0 && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ flueShape: v }), options: [
                                             { label: 'Round', value: 'round' },
                                             { label: 'Square', value: 'square' },
-                                        ], value: node.flueShape ?? 'round' }), _jsx(SliderControl, { label: "Diameter", max: Math.max(0.4, node.width), min: 0.05, onChange: (v) => previewProp({ flueDiameter: v }), onCommit: (v) => commitProp({ flueDiameter: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.flueDiameter ?? 0.22) * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 1.5, min: 0.05, onChange: (v) => previewProp({ flueHeight: v }), onCommit: (v) => commitProp({ flueHeight: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.flueHeight ?? 0.3) * 100) / 100 }), (node.flueCount ?? 1) > 1 && (_jsx(SliderControl, { label: "Spacing", max: 1, min: 0, onChange: (v) => previewProp({ flueSpacing: v }), onCommit: (v) => commitProp({ flueSpacing: v }), precision: 2, restoreOnCommit: false, step: 0.05, value: Math.round((node.flueSpacing ?? 1) * 100) / 100 })), _jsx(SliderControl, { label: "Wall Thickness", max: Math.max(0.1, (node.flueDiameter ?? 0.22) / 2 - 0.01), min: 0, onChange: (v) => previewProp({ flueWallThickness: v }), onCommit: (v) => commitProp({ flueWallThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.flueWallThickness ?? 0.02) * 1000) / 1000 })] }))] })), chimneyType === 'bands' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ bandStyle: v }), options: [
+                                        ], value: node.flueShape ?? 'round' }), _jsx(SliderControl, { label: "Diameter", max: Math.max(0.4, node.width), min: 0.05, onChange: (v) => previewProp({ flueDiameter: v }), onCommit: (v) => commitProp({ flueDiameter: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: node.flueDiameter ?? 0.22 }), _jsx(SliderControl, { label: "Height", max: 1.5, min: 0.05, onChange: (v) => previewProp({ flueHeight: v }), onCommit: (v) => commitProp({ flueHeight: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: node.flueHeight ?? 0.3 }), (node.flueCount ?? 1) > 1 && (_jsx(SliderControl, { label: "Spacing", max: 1, min: 0, onChange: (v) => previewProp({ flueSpacing: v }), onCommit: (v) => commitProp({ flueSpacing: v }), precision: 2, restoreOnCommit: false, step: 0.05, value: Math.round((node.flueSpacing ?? 1) * 100) / 100 })), _jsx(SliderControl, { label: "Wall Thickness", max: Math.max(0.1, (node.flueDiameter ?? 0.22) / 2 - 0.01), min: 0, onChange: (v) => previewProp({ flueWallThickness: v }), onCommit: (v) => commitProp({ flueWallThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.flueWallThickness ?? 0.02 })] }))] })), chimneyType === 'bands' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ bandStyle: v }), options: [
                                     { label: 'None', value: 'none' },
                                     { label: 'Single', value: 'single' },
                                     { label: 'Double', value: 'double' },
-                                ], value: node.bandStyle ?? 'none' }), (node.bandStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Thickness", max: 0.4, min: 0.02, onChange: (v) => previewProp({ bandHeight: v }), onCommit: (v) => commitProp({ bandHeight: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.bandHeight ?? 0.1) * 100) / 100 }), _jsx(SliderControl, { label: "Extent", max: 0.2, min: 0, onChange: (v) => previewProp({ bandExtent: v }), onCommit: (v) => commitProp({ bandExtent: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.bandExtent ?? 0.04) * 1000) / 1000 }), _jsx(SliderControl, { label: "Offset", max: 3, min: 0, onChange: (v) => previewProp({ bandOffset: v }), onCommit: (v) => commitProp({ bandOffset: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.bandOffset ?? 0.4) * 100) / 100 })] }))] })), chimneyType === 'cricket' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ cricketStyle: v }), options: [
+                                ], value: node.bandStyle ?? 'none' }), (node.bandStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Thickness", max: 0.4, min: 0.02, onChange: (v) => previewProp({ bandHeight: v }), onCommit: (v) => commitProp({ bandHeight: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: node.bandHeight ?? 0.1 }), _jsx(SliderControl, { label: "Extent", max: 0.2, min: 0, onChange: (v) => previewProp({ bandExtent: v }), onCommit: (v) => commitProp({ bandExtent: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.bandExtent ?? 0.04 }), _jsx(SliderControl, { label: "Offset", max: 3, min: 0, onChange: (v) => previewProp({ bandOffset: v }), onCommit: (v) => commitProp({ bandOffset: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.bandOffset ?? 0.4 })] }))] })), chimneyType === 'cricket' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ cricketStyle: v }), options: [
                                     { label: 'None', value: 'none' },
                                     { label: 'Simple', value: 'simple' },
                                 ], value: node.cricketStyle ?? 'none' }), (node.cricketStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ cricketSide: v }), options: [
                                             { label: 'Front', value: 'front' },
                                             { label: 'Back', value: 'back' },
-                                        ], value: node.cricketSide ?? 'front' }), _jsx(SliderControl, { label: "Length", max: 2, min: 0.1, onChange: (v) => previewProp({ cricketLength: v }), onCommit: (v) => commitProp({ cricketLength: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.cricketLength ?? 0.6) * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 1.5, min: 0.05, onChange: (v) => previewProp({ cricketHeight: v }), onCommit: (v) => commitProp({ cricketHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.cricketHeight ?? 0.4) * 100) / 100 })] }))] })), chimneyType === 'panels' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ panelStyle: v }), options: [
+                                        ], value: node.cricketSide ?? 'front' }), _jsx(SliderControl, { label: "Length", max: 2, min: 0.1, onChange: (v) => previewProp({ cricketLength: v }), onCommit: (v) => commitProp({ cricketLength: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.cricketLength ?? 0.6 }), _jsx(SliderControl, { label: "Height", max: 1.5, min: 0.05, onChange: (v) => previewProp({ cricketHeight: v }), onCommit: (v) => commitProp({ cricketHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.cricketHeight ?? 0.4 })] }))] })), chimneyType === 'panels' && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { className: "mt-2", onChange: (v) => handleUpdate({ panelStyle: v }), options: [
                                     { label: 'None', value: 'none' },
                                     { label: 'Rectangular', value: 'rectangular' },
-                                ], value: node.panelStyle ?? 'none' }), (node.panelStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Depth", max: 0.15, min: 0.005, onChange: (v) => previewProp({ panelDepth: v }), onCommit: (v) => commitProp({ panelDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: Math.round((node.panelDepth ?? 0.03) * 1000) / 1000 }), _jsx(SliderControl, { label: "Height", max: 3, min: 0.1, onChange: (v) => previewProp({ panelHeight: v }), onCommit: (v) => commitProp({ panelHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.panelHeight ?? 0.8) * 100) / 100 }), _jsx(SliderControl, { label: "Top Offset", max: 2, min: 0, onChange: (v) => previewProp({ panelOffsetTop: v }), onCommit: (v) => commitProp({ panelOffsetTop: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.panelOffsetTop ?? 0.15) * 100) / 100 }), _jsx(SliderControl, { label: "Side Margin", max: Math.max(0.5, node.width / 2 - 0.05), min: 0.02, onChange: (v) => previewProp({ panelMargin: v }), onCommit: (v) => commitProp({ panelMargin: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.panelMargin ?? 0.1) * 100) / 100 })] }))] }))] }), _jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete }) }) })] }));
+                                ], value: node.panelStyle ?? 'none' }), (node.panelStyle ?? 'none') !== 'none' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Depth", max: 0.15, min: 0.005, onChange: (v) => previewProp({ panelDepth: v }), onCommit: (v) => commitProp({ panelDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: node.panelDepth ?? 0.03 }), _jsx(SliderControl, { label: "Height", max: 3, min: 0.1, onChange: (v) => previewProp({ panelHeight: v }), onCommit: (v) => commitProp({ panelHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.panelHeight ?? 0.8 }), _jsx(SliderControl, { label: "Top Offset", max: 2, min: 0, onChange: (v) => previewProp({ panelOffsetTop: v }), onCommit: (v) => commitProp({ panelOffsetTop: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: node.panelOffsetTop ?? 0.15 }), _jsx(SliderControl, { label: "Side Margin", max: Math.max(0.5, node.width / 2 - 0.05), min: 0.02, onChange: (v) => previewProp({ panelMargin: v }), onCommit: (v) => commitProp({ panelMargin: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: node.panelMargin ?? 0.1 })] }))] }))] }), _jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete }) }) })] }));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/column/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA2TrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAiG9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/column/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4TrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}

package/dist/column/definition.js

@@ -1,12 +1,15 @@
 import { ColumnNode as ColumnNodeSchema, } from '@pascal-app/core';
+import { withHostedChildren } from '../shared/hosted-resize';
 import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination';
 import { buildColumnFloorplan, computeColumnFloorplanLevelData } from './floorplan';
 import { columnResizeAffordance, columnRotateAffordance } from './floorplan-affordances';
 import { columnFloorplanMoveTarget } from './floorplan-move';
+import { columnHostedPolicy } from './hosted-resize';
 import { columnPaint } from './paint';
 import { columnParametrics } from './parametrics';
 import { ColumnNode } from './schema';
 import { columnSlots } from './slots';
+import { columnSurfaceProvider } from './surface';
 // 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.
@@ -288,7 +291,7 @@ function columnHandles(node) {
     handles.push(columnRotateHandle());
     if (!managedByLeanTo)
         handles.push(columnMoveHandle());
-    return handles;
+    return handles.map((handle) => withHostedChildren(handle, columnHostedPolicy));
 }
 function resolveColumnStructuralGridMoveSnap({ candidatePosition, nodes, levelId, }) {
     const snap = resolveStructuralGridSnap([candidatePosition[0], candidatePosition[2]], collectStructuralGridAxes(nodes, levelId));
@@ -325,9 +328,13 @@ export const columnDefinition = {
         return rest;
     },
     capabilities: {
+        surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
-        surfaces: { top: { height: (node) => node.height } },
-        duplicable: true,
+        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

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;AAazB;;;;;;;;;;;;;;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,CAoFlE,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;AAczB;;;;;;;;;;;;;;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,CAsFlE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CAgClE,CAAA"}

package/dist/column/floorplan-affordances.js

@@ -1,6 +1,7 @@
 import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+import { planColumnEdit } from './hosted-resize';
 // Floor minimums — mirror the 3D handles in `column/definition.ts` so a
 // drag can't push a value past what the renderer accepts.
 const MIN_COLUMN_WIDTH = 0.1;
@@ -24,6 +25,8 @@ export const columnResizeAffordance = {
         const initialBraceTopSpread = node.braceTopSpread ?? 0.12;
         let lastPatch = {};
         const previewPatch = (patch) => {
+            if (!planColumnEdit(columnId, patch))
+                return;
             lastPatch = patch;
             useLiveNodeOverrides.getState().set(columnId, patch);
             useScene.getState().markDirty(columnId);
@@ -82,7 +85,9 @@ export const columnResizeAffordance = {
             commit() {
                 if (Object.keys(lastPatch).length > 0) {
                     useLiveNodeOverrides.getState().clear(columnId);
-                    useScene.getState().updateNode(columnId, lastPatch);
+                    const updates = planColumnEdit(columnId, lastPatch);
+                    if (updates)
+                        useScene.getState().updateNodes(updates.map(([id, data]) => ({ id, data })));
                 }
             },
         };

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,KAAK,EACV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,kBAAkB,EACnB,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,CAiL1B;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,CAE9E"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/column/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,kBAAkB,EACnB,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,CA6L1B;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,CAE9E"}

package/dist/column/floorplan.js

@@ -40,17 +40,29 @@ export function buildColumnFloorplan(node, ctx) {
     const showSelectedChrome = isSelected || isHighlighted;
     const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#374151';
     const fill = showSelectedChrome ? '#fed7aa' : '#9ca3af';
-    const children = [
-        {
-            kind: 'polygon',
-            points,
-            fill,
-            stroke,
-            strokeWidth: showSelectedChrome ? 0.03 : 0.02,
-            opacity: 0.92,
-            metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
-        },
-    ];
+    const body = {
+        kind: 'polygon',
+        points,
+        fill,
+        stroke,
+        strokeWidth: showSelectedChrome ? 0.03 : 0.02,
+        opacity: 0.92,
+        metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+    };
+    const children = node.children.length
+        ? [
+            // Occupied columns keep label bounds in the overlay without covering their children.
+            {
+                kind: 'polygon',
+                points,
+                fill: 'none',
+                stroke: 'none',
+                pointerEvents: 'none',
+                metadata: body.metadata,
+            },
+            { ...body, metadata: undefined },
+        ]
+        : [body];
     const { halfX, halfZ } = columnPlanHalfExtents(node);
     const centerMarkHalf = Math.min(0.09, Math.max(0.035, Math.min(halfX, halfZ) * 0.45));
     const centerX = node.position[0];

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

@@ -0,0 +1,116 @@
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+export declare const columnHostedPolicy: {
+    host: (node: AnyNode) => node is {
+        object: "node";
+        style: "plain" | "faceted" | "fluted" | "lathe-turned" | "dravidian-carved" | "cluster";
+        metadata: Record<string, unknown>;
+        id: `column_${string}`;
+        parentId: string | null;
+        visible: boolean;
+        position: [number, number, number];
+        rotation: number;
+        children: string[];
+        width: number;
+        depth: number;
+        radius: number;
+        height: number;
+        crossSection: "round" | "square" | "rectangular" | "octagonal" | "sixteen-sided";
+        edgeSoftness: number;
+        baseHeight: number;
+        capitalHeight: number;
+        shaftProfile: "straight" | "tapered" | "bulged" | "baluster" | "hourglass";
+        shaftTaper: number;
+        shaftBulge: number;
+        shaftStartScale: number;
+        shaftEndScale: number;
+        shaftSegmentCount: number;
+        shaftTwistStep: number;
+        shaftCornerRadius: number;
+        shaftDetail: "none" | "fluted" | "lathe-turned" | "spiral" | "panelled";
+        baseStyle: "none" | "simple-square" | "round-rings" | "square-plinth" | "stepped-square" | "lotus" | "ribbed-lotus" | "panelled-pedestal";
+        baseWidthScale: number;
+        baseDepthScale: number;
+        baseTierCount: number;
+        baseStepSpread: number;
+        basePlinthHeightRatio: number;
+        baseRoundBandScale: number;
+        baseNeckScale: number;
+        baseRoundBandCount: number;
+        baseRibCount: number;
+        baseCarvingLevel: number;
+        basePanelInset: number;
+        capitalStyle: "none" | "simple" | "simple-slab" | "rounded" | "stepped" | "doric" | "volute" | "ionic-volute" | "leaf-carved" | "corinthian-leaf" | "south-indian-bracket" | "wood-bracket";
+        capitalWidthScale: number;
+        capitalDepthScale: number;
+        capitalTierCount: number;
+        capitalStepSpread: number;
+        capitalBandCount: number;
+        voluteSize: number;
+        voluteCount: number;
+        leafCount: number;
+        leafRows: number;
+        bracketDepth: number;
+        bracketTierCount: number;
+        pendantCount: number;
+        capitalCarvingLevel: number;
+        ringCount: number;
+        ringPlacement: "top" | "ends" | "even" | "bottom";
+        ringThickness: number;
+        ringSpread: number;
+        fluteCount: number;
+        fluteDepth: number;
+        fluteWidth: number;
+        spiralTwist: number;
+        spiralRibCount: number;
+        panelCount: number;
+        panelInsetDepth: number;
+        panelShape: "rectangle" | "arched" | "diamond";
+        latheRingCount: number;
+        latheRingSpacing: "top" | "ends" | "even" | "bottom";
+        carvingLevel: number;
+        carvingPlacement: "base" | "shaft" | "capital" | "all";
+        lowerBandEnabled: boolean;
+        lowerBandHeight: number;
+        lowerBandCarvingLevel: number;
+        dentilCount: number;
+        beadCount: number;
+        supportStyle: "vertical" | "a-frame" | "y-frame" | "v-frame" | "x-brace" | "k-brace" | "single-strut" | "tripod" | "trestle" | "portal-frame" | "box-frame";
+        braceWidth: number;
+        braceDepth: number;
+        braceBottomSpread: number;
+        braceTopSpread: number;
+        bracePlateEnabled: boolean;
+        type: "column";
+        material?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        name?: string | undefined;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "perspective" | "orthographic";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        supportSlabId?: string | undefined;
+    };
+    child: (_node: AnyNode) => boolean;
+};
+export declare function planColumnEdit(id: AnyNodeId, patch: Partial<AnyNode>): import("../shared/hosted-resize").HostedUpdate[] | null;
+//# sourceMappingURL=hosted-resize.d.ts.map

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

@@ -0,0 +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"}

package/dist/column/hosted-resize.js

@@ -0,0 +1,9 @@
+import { createSceneApi, useScene } from '@pascal-app/core';
+import { planHostedEdit } from '../shared/hosted-resize';
+export const columnHostedPolicy = {
+    host: (node) => node.type === 'column',
+    child: (_node) => true,
+};
+export function planColumnEdit(id, patch) {
+    return planHostedEdit(createSceneApi(useScene), (scene) => scene.update(id, patch), columnHostedPolicy);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/column/panel.tsx"],"names":[],"mappings":"AAgSA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAo1BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/column/panel.tsx"],"names":[],"mappings":"AAkSA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAq1BlC"}

package/dist/column/panel.js

@@ -5,6 +5,7 @@ import { ActionButton, ActionGroup, cn, PanelSection, PanelWrapper, SliderContro
 import { useViewer } from '@pascal-app/viewer';
 import { Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
+import { planColumnEdit } from './hosted-resize';
 const SELECT_CLASS = 'h-10 w-full rounded-lg border border-border/50 bg-[#2C2C2E] px-3 text-sm text-foreground outline-none transition-colors hover:bg-[#3e3e3e] focus:ring-1 focus:ring-border';
 const MANAGED_LEAN_TO_LAYOUT_FIELDS = new Set([
     'position',
@@ -246,7 +247,7 @@ export default function ColumnPanel() {
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const selectedCount = useViewer((s) => s.selection.selectedIds.length);
     const setSelection = useViewer((s) => s.setSelection);
-    const updateNode = useScene((s) => s.updateNode);
+    const updateNodes = useScene((s) => s.updateNodes);
     const deleteNode = useScene((s) => s.deleteNode);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
@@ -256,8 +257,10 @@ export default function ColumnPanel() {
         const nextUpdates = node && isManagedLeanToPost(node) ? filterManagedLeanToLayoutUpdates(updates) : updates;
         if (Object.keys(nextUpdates).length === 0)
             return;
-        updateNode(selectedId, nextUpdates);
-    }, [node, selectedId, updateNode]);
+        const updatesToApply = planColumnEdit(selectedId, nextUpdates);
+        if (updatesToApply)
+            updateNodes(updatesToApply.map(([id, data]) => ({ id, data })));
+    }, [node, selectedId, updateNodes]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
     }, [setSelection]);

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/column/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAwwEzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA6C3D,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCAgDrE,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/column/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,kBAAkB,CAAA;AA6nEzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA6C3D,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCAgErE,CAAA;AAED,eAAe,cAAc,CAAA"}