@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/column/bounds.js

@@ -0,0 +1,127 @@
+import { columnCapitalBlocks, columnShaftLayout, getShaftScaleAt, getShaftSegmentCount, getShaftTwistRadians, } from './shape.js';
+/** Conservative, origin-centred XZ envelope shared by plan, collision and handles. */
+export function columnFootprintHalf(n) {
+    if (n.source) {
+        const { min, max } = n.source.manifest.bounds;
+        return {
+            halfX: Math.max(Math.abs(min[0]), Math.abs(max[0])),
+            halfZ: Math.max(Math.abs(min[2]), Math.abs(max[2])),
+        };
+    }
+    let halfX = 0, halfZ = 0;
+    const include = (x, z = x) => {
+        halfX = Math.max(halfX, x);
+        halfZ = Math.max(halfZ, z);
+    };
+    const rectangular = n.crossSection === 'square' || n.crossSection === 'rectangular';
+    const block = (scale) => include(rectangular ? (n.width * scale) / 2 : n.radius * scale, rectangular ? (n.depth * scale) / 2 : n.radius * scale);
+    if (n.supportStyle !== 'vertical') {
+        const w = Math.max(0.04, n.braceWidth), d = Math.max(0.04, n.braceDepth);
+        const bottom = Math.max(0.2, n.braceBottomSpread), top = Math.max(0.2, n.braceTopSpread);
+        const plateX = n.bracePlateEnabled ? w * 0.95 : w / 2;
+        const plateZ = n.bracePlateEnabled ? d * 0.875 : d / 2;
+        const fork = n.supportStyle === 'y-frame' || n.supportStyle === 'v-frame';
+        const spatial = ['tripod', 'trestle', 'box-frame'].includes(n.supportStyle);
+        const span = fork
+            ? top
+            : n.supportStyle === 'a-frame' || n.supportStyle === 'portal-frame' || spatial
+                ? bottom
+                : Math.max(bottom, top);
+        include(span / 2 + plateX, (spatial ? top / 2 : 0) + plateZ);
+        if (n.supportStyle === 'a-frame' && n.bracePlateEnabled)
+            include(w * 1.1, plateZ);
+        return { halfX, halfZ };
+    }
+    const layout = columnShaftLayout(n);
+    if (n.style === 'cluster') {
+        include(Math.max(n.radius * 0.78, n.width * 0.22) + Math.max(0.04, n.radius * 0.36));
+    }
+    else {
+        const count = getShaftSegmentCount(n);
+        for (let i = 0; i <= count; i++) {
+            const scale = getShaftScaleAt(n, i / count);
+            const yaw = getShaftTwistRadians(n, (i / count) * Math.max(0, count - 1));
+            const c = Math.abs(Math.cos(yaw)), s = Math.abs(Math.sin(yaw));
+            if (rectangular)
+                include(((n.width * c + n.depth * s) * scale) / 2, ((n.width * s + n.depth * c) * scale) / 2);
+            else
+                include(n.radius * scale);
+        }
+    }
+    if (n.style !== 'cluster' && n.edgeSoftness > 0) {
+        // Bevel rings also sample between the main profile sections.
+        const scale = Math.max(n.shaftStartScale, n.shaftEndScale) + Math.abs(n.shaftBulge);
+        if (rectangular && Math.abs(n.shaftTwistStep) > 0.001)
+            include((Math.hypot(n.width, n.depth) * scale) / 2);
+        else
+            block(scale);
+    }
+    if (layout.baseHeight > 0) {
+        const w = (n.width * n.baseWidthScale) / 2, d = (n.depth * n.baseDepthScale) / 2;
+        if (n.baseStyle === 'lotus' || n.baseStyle === 'ribbed-lotus') {
+            include(n.width * 0.64, n.depth * 0.64);
+            include(Math.max(n.radius * n.baseWidthScale, w) * 0.86 +
+                (n.baseRibCount > 0 ? Math.max(0.01, n.width * 0.025) : 0));
+        }
+        else if (n.baseStyle === 'panelled-pedestal') {
+            const x = n.width * n.baseWidthScale, z = n.depth * n.baseWidthScale;
+            include(x * 0.51 + n.basePanelInset / 2, z * 0.51 + n.basePanelInset / 2);
+            include(n.width * 0.18);
+        }
+        else if (n.baseStyle === 'square-plinth')
+            include(Math.max(w, n.width * 0.45), Math.max(d, n.depth * 0.45));
+        else if (n.baseStyle === 'stepped-square')
+            include(Math.max(w, n.width * 0.25), Math.max(d, n.depth * 0.25));
+        else if (n.baseStyle === 'round-rings')
+            include(w * Math.max(1, n.baseRoundBandScale, n.baseNeckScale), d * Math.max(1, n.baseRoundBandScale, n.baseNeckScale));
+        else
+            include(w, d);
+        if (n.baseCarvingLevel > 0 && ['base', 'all'].includes(n.carvingPlacement))
+            include(Math.max(n.radius * 1.04, Math.max(n.width, n.depth) / 2) +
+                layout.baseHeight * 0.14 +
+                0.014);
+    }
+    for (const cap of columnCapitalBlocks(n, layout.baseHeight + layout.shaftHeight, layout.capitalHeight)) {
+        if (cap.kind === 'round')
+            include(cap.radius);
+        else if (cap.kind === 'column')
+            block(cap.scale);
+        else
+            include(cap.width / 2, cap.depth / 2);
+    }
+    if (layout.capitalHeight > 0) {
+        if (['volute', 'ionic-volute'].includes(n.capitalStyle) && n.voluteCount > 0)
+            include(Math.max(n.width * 0.46, n.depth * 0.7) + n.voluteSize * 1.18);
+        if (['leaf-carved', 'corinthian-leaf'].includes(n.capitalStyle) &&
+            n.leafCount > 0 &&
+            n.leafRows > 0)
+            include(Math.max(n.radius * 1.05, Math.max(n.width, n.depth) * 0.48) +
+                layout.capitalHeight * 0.14 +
+                0.018);
+        if (['south-indian-bracket', 'wood-bracket'].includes(n.capitalStyle) && n.pendantCount > 0)
+            include(Math.max(n.width, n.depth) * 0.56 + 0.035);
+        if (['capital', 'all'].includes(n.carvingPlacement) &&
+            (n.capitalBandCount > 0 || n.carvingLevel > 0 || n.capitalCarvingLevel > 0)) {
+            block(rectangular ? 1.28 : 1.24);
+            if (rectangular)
+                include(n.width * 0.56 + Math.max(0.025, n.width / 7) / 2, n.depth * 0.56 + Math.max(0.025, n.depth / 7) / 2);
+            else
+                include(n.radius * 1.24 + Math.max(0.012, Math.min(0.03, n.radius * 0.12)));
+        }
+    }
+    const shaftRadius = rectangular ? Math.hypot(n.width, n.depth) / 2 : n.radius;
+    const maxScale = Math.max(n.shaftStartScale, n.shaftEndScale) +
+        Math.max(0, n.shaftBulge) +
+        Math.max(0, -n.shaftBulge);
+    if (n.ringCount > 0)
+        include(shaftRadius * (maxScale + 0.12));
+    if (n.latheRingCount > 0 || n.shaftDetail === 'lathe-turned')
+        include(shaftRadius * (maxScale + 0.18));
+    if (n.panelCount > 0 || n.style === 'dravidian-carved' || n.shaftDetail === 'panelled')
+        include(shaftRadius * maxScale + n.panelInsetDepth / 2 + Math.max(0.006, n.width * 0.014));
+    if ((n.spiralRibCount > 0 || n.shaftDetail === 'spiral') && n.spiralTwist !== 0)
+        include(shaftRadius * maxScale + Math.max(0.012, n.radius * 0.06));
+    if (n.lowerBandEnabled && ['shaft', 'all'].includes(n.carvingPlacement))
+        include(shaftRadius * (maxScale + 0.12) + 0.012);
+    return { halfX, halfZ };
+}

package/dist/column/definition.d.ts

@@ -1,21 +1,373 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { ColumnNode } from './schema.js';
-/**
- * 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>;
+export declare const columnDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`column_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"column">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    source: import("zod").ZodOptional<import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"script">;
+        meta: import("zod").ZodOptional<import("zod").ZodObject<{
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            category: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            parent: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+        language: import("zod").ZodDefault<import("zod").ZodEnum<{
+            bpy: "bpy";
+            three: "three";
+        }>>;
+        script: import("zod").ZodString;
+        params: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>>>;
+        artifact: import("zod").ZodString;
+        manifest: import("zod").ZodObject<{
+            bounds: import("zod").ZodObject<{
+                min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>;
+            params: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                kind: import("zod").ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                }>;
+                default: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>;
+                min: import("zod").ZodOptional<import("zod").ZodNumber>;
+                max: import("zod").ZodOptional<import("zod").ZodNumber>;
+                step: import("zod").ZodOptional<import("zod").ZodNumber>;
+                unit: import("zod").ZodOptional<import("zod").ZodString>;
+                options: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>>>;
+            parts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                type: import("zod").ZodOptional<import("zod").ZodString>;
+                bounds: import("zod").ZodOptional<import("zod").ZodObject<{
+                    min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            surfaces: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                part: import("zod").ZodOptional<import("zod").ZodString>;
+                y: import("zod").ZodNumber;
+                polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            }, import("zod/v4/core").$strip>>>;
+            slots: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+                color: import("zod").ZodOptional<import("zod").ZodString>;
+                roughness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                metalness: import("zod").ZodOptional<import("zod").ZodNumber>;
+                transparent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                emissive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>>;
+            anchors: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                normal: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            }, import("zod/v4/core").$strip>>>;
+            lights: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                color: import("zod").ZodString;
+                intensity: import("zod").ZodNumber;
+                distance: import("zod").ZodOptional<import("zod").ZodNumber>;
+                spot: import("zod").ZodOptional<import("zod").ZodObject<{
+                    direction: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                    angle: import("zod").ZodNumber;
+                    softness: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>>;
+                shadows: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                glow: import("zod").ZodOptional<import("zod").ZodObject<{
+                    size: import("zod").ZodNumber;
+                    strength: import("zod").ZodDefault<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            undersides: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                part: import("zod").ZodOptional<import("zod").ZodString>;
+                polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                plane: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>>>;
+            animations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                duration: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+            cutters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                host: import("zod").ZodEnum<{
+                    ceiling: "ceiling";
+                    mounted: "mounted";
+                    slab: "slab";
+                    wall: "wall";
+                }>;
+                polygon: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>;
+                minY: import("zod").ZodNumber;
+                maxY: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>>;
+            cutout: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            collider: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            shape: import("zod").ZodOptional<import("zod").ZodObject<{
+                tolerance: import("zod").ZodNumber;
+                bands: import("zod").ZodArray<import("zod").ZodObject<{
+                    y0: import("zod").ZodNumber;
+                    y1: import("zod").ZodNumber;
+                    polygons: import("zod").ZodArray<import("zod").ZodObject<{
+                        outer: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+                        holes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+            triangles: import("zod").ZodNumber;
+            coverage: import("zod").ZodOptional<import("zod").ZodNumber>;
+            uncovered: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                min: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+                max: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+            }, import("zod/v4/core").$strip>>>;
+        }, import("zod/v4/core").$strip>;
+        images: import("zod").ZodOptional<import("zod").ZodObject<{
+            artifact: import("zod").ZodString;
+            thumbnail: import("zod").ZodString;
+            floorPlan: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        cluster: "cluster";
+        "dravidian-carved": "dravidian-carved";
+        faceted: "faceted";
+        fluted: "fluted";
+        "lathe-turned": "lathe-turned";
+        plain: "plain";
+    }>>;
+    crossSection: import("zod").ZodDefault<import("zod").ZodEnum<{
+        octagonal: "octagonal";
+        rectangular: "rectangular";
+        round: "round";
+        "sixteen-sided": "sixteen-sided";
+        square: "square";
+    }>>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    radius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    edgeSoftness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftProfile: import("zod").ZodDefault<import("zod").ZodEnum<{
+        baluster: "baluster";
+        bulged: "bulged";
+        hourglass: "hourglass";
+        straight: "straight";
+        tapered: "tapered";
+    }>>;
+    shaftTaper: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftBulge: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftStartScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftEndScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftSegmentCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftTwistStep: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftCornerRadius: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftDetail: import("zod").ZodDefault<import("zod").ZodEnum<{
+        fluted: "fluted";
+        "lathe-turned": "lathe-turned";
+        none: "none";
+        panelled: "panelled";
+        spiral: "spiral";
+    }>>;
+    baseStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        lotus: "lotus";
+        none: "none";
+        "panelled-pedestal": "panelled-pedestal";
+        "ribbed-lotus": "ribbed-lotus";
+        "round-rings": "round-rings";
+        "simple-square": "simple-square";
+        "square-plinth": "square-plinth";
+        "stepped-square": "stepped-square";
+    }>>;
+    baseWidthScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseDepthScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseTierCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseStepSpread: import("zod").ZodDefault<import("zod").ZodNumber>;
+    basePlinthHeightRatio: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseRoundBandScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseNeckScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseRoundBandCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseRibCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseCarvingLevel: import("zod").ZodDefault<import("zod").ZodNumber>;
+    basePanelInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "corinthian-leaf": "corinthian-leaf";
+        doric: "doric";
+        "ionic-volute": "ionic-volute";
+        "leaf-carved": "leaf-carved";
+        none: "none";
+        rounded: "rounded";
+        simple: "simple";
+        "simple-slab": "simple-slab";
+        "south-indian-bracket": "south-indian-bracket";
+        stepped: "stepped";
+        volute: "volute";
+        "wood-bracket": "wood-bracket";
+    }>>;
+    capitalWidthScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalDepthScale: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalTierCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalStepSpread: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalBandCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    voluteSize: import("zod").ZodDefault<import("zod").ZodNumber>;
+    voluteCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    leafCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    leafRows: import("zod").ZodDefault<import("zod").ZodNumber>;
+    bracketDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    bracketTierCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    pendantCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    capitalCarvingLevel: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ringCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ringPlacement: import("zod").ZodDefault<import("zod").ZodEnum<{
+        bottom: "bottom";
+        ends: "ends";
+        even: "even";
+        top: "top";
+    }>>;
+    ringThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ringSpread: import("zod").ZodDefault<import("zod").ZodNumber>;
+    fluteCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    fluteDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    fluteWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    spiralTwist: import("zod").ZodDefault<import("zod").ZodNumber>;
+    spiralRibCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelInsetDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        arched: "arched";
+        diamond: "diamond";
+        rectangle: "rectangle";
+    }>>;
+    latheRingCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    latheRingSpacing: import("zod").ZodDefault<import("zod").ZodEnum<{
+        bottom: "bottom";
+        ends: "ends";
+        even: "even";
+        top: "top";
+    }>>;
+    carvingLevel: import("zod").ZodDefault<import("zod").ZodNumber>;
+    carvingPlacement: import("zod").ZodDefault<import("zod").ZodEnum<{
+        all: "all";
+        base: "base";
+        capital: "capital";
+        shaft: "shaft";
+    }>>;
+    lowerBandEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    lowerBandHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    lowerBandCarvingLevel: import("zod").ZodDefault<import("zod").ZodNumber>;
+    dentilCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    beadCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "a-frame": "a-frame";
+        "box-frame": "box-frame";
+        "k-brace": "k-brace";
+        "portal-frame": "portal-frame";
+        "single-strut": "single-strut";
+        trestle: "trestle";
+        tripod: "tripod";
+        "v-frame": "v-frame";
+        vertical: "vertical";
+        "x-brace": "x-brace";
+        "y-frame": "y-frame";
+    }>>;
+    braceWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    braceDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    braceBottomSpread: import("zod").ZodDefault<import("zod").ZodNumber>;
+    braceTopSpread: import("zod").ZodDefault<import("zod").ZodNumber>;
+    bracePlateEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    role: import("zod").ZodOptional<import("zod").ZodEnum<{
+        ornament: "ornament";
+        post: "post";
+    }>>;
+    postBase: import("zod").ZodOptional<import("zod").ZodEnum<{
+        none: "none";
+        pier: "pier";
+        "post-base": "post-base";
+    }>>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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,EAOL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAezB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4UrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA0G9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/column/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG5B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/column/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAYvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA4S1C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAsC1E,CAAA"}