@pascal-app/core 0.6.0 → 0.8.0

package/dist/schema/nodes/column.js

@@ -0,0 +1,385 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+export const ColumnStyle = z.enum([
+    'plain',
+    'faceted',
+    'fluted',
+    'lathe-turned',
+    'dravidian-carved',
+    'cluster',
+]);
+export const ColumnCrossSection = z.enum([
+    'round',
+    'square',
+    'rectangular',
+    'octagonal',
+    'sixteen-sided',
+]);
+export const ColumnShaftProfile = z.enum(['straight', 'tapered', 'bulged', 'baluster', 'hourglass']);
+export const ColumnShaftDetail = z.enum(['none', 'fluted', 'spiral', 'panelled', 'lathe-turned']);
+export const ColumnPanelShape = z.enum(['rectangle', 'arched', 'diamond']);
+export const ColumnBaseStyle = z.enum([
+    'none',
+    'simple-square',
+    'round-rings',
+    'square-plinth',
+    'stepped-square',
+    'lotus',
+    'ribbed-lotus',
+    'panelled-pedestal',
+]);
+export const ColumnCapitalStyle = z.enum([
+    'none',
+    'simple',
+    'simple-slab',
+    'rounded',
+    'stepped',
+    'doric',
+    'volute',
+    'ionic-volute',
+    'leaf-carved',
+    'corinthian-leaf',
+    'south-indian-bracket',
+    'wood-bracket',
+]);
+export const ColumnRingPlacement = z.enum(['ends', 'even', 'top', 'bottom']);
+export const ColumnCarvingPlacement = z.enum(['shaft', 'base', 'capital', 'all']);
+export const ColumnNode = BaseNode.extend({
+    id: objectId('column'),
+    type: nodeType('column'),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    style: ColumnStyle.default('plain'),
+    crossSection: ColumnCrossSection.default('round'),
+    height: z.number().positive().default(2.8),
+    radius: z.number().positive().default(0.22),
+    width: z.number().positive().default(0.44),
+    depth: z.number().positive().default(0.44),
+    edgeSoftness: z.number().min(0).max(0.12).default(0.025),
+    baseHeight: z.number().min(0).default(0.18),
+    capitalHeight: z.number().min(0).default(0.18),
+    shaftProfile: ColumnShaftProfile.default('straight'),
+    shaftTaper: z.number().min(0).max(0.85).default(0),
+    shaftBulge: z.number().min(-0.5).max(0.8).default(0),
+    shaftStartScale: z.number().min(0.2).max(2).default(0.72),
+    shaftEndScale: z.number().min(0.2).max(2).default(0.72),
+    shaftSegmentCount: z.number().int().min(1).max(64).default(24),
+    shaftTwistStep: z.number().min(-90).max(90).default(0),
+    shaftCornerRadius: z.number().min(0).max(0.3).default(0.035),
+    shaftDetail: ColumnShaftDetail.default('none'),
+    baseStyle: ColumnBaseStyle.default('round-rings'),
+    baseWidthScale: z.number().min(0.4).max(3).default(1.24),
+    baseDepthScale: z.number().min(0.4).max(3).default(1.24),
+    baseTierCount: z.number().int().min(1).max(8).default(3),
+    baseStepSpread: z.number().min(0).max(1).default(0.42),
+    basePlinthHeightRatio: z.number().min(0.2).max(0.7).default(0.44),
+    baseRoundBandScale: z.number().min(0.5).max(1.2).default(0.92),
+    baseNeckScale: z.number().min(0.35).max(1).default(0.72),
+    baseRoundBandCount: z.number().int().min(0).max(16).default(3),
+    baseRibCount: z.number().int().min(0).max(48).default(0),
+    baseCarvingLevel: z.number().int().min(0).max(4).default(0),
+    basePanelInset: z.number().min(0).max(0.1).default(0.02),
+    capitalStyle: ColumnCapitalStyle.default('simple'),
+    capitalWidthScale: z.number().min(0.4).max(3).default(1.46),
+    capitalDepthScale: z.number().min(0.4).max(3).default(1.46),
+    capitalTierCount: z.number().int().min(1).max(8).default(3),
+    capitalStepSpread: z.number().min(0).max(1).default(0.42),
+    capitalBandCount: z.number().int().min(0).max(16).default(2),
+    voluteSize: z.number().min(0.02).max(0.3).default(0.08),
+    voluteCount: z.number().int().min(0).max(8).default(4),
+    leafCount: z.number().int().min(0).max(48).default(18),
+    leafRows: z.number().int().min(0).max(4).default(2),
+    bracketDepth: z.number().min(0).max(1.5).default(0.35),
+    bracketTierCount: z.number().int().min(0).max(8).default(3),
+    pendantCount: z.number().int().min(0).max(16).default(0),
+    capitalCarvingLevel: z.number().int().min(0).max(4).default(0),
+    ringCount: z.number().int().min(0).max(16).default(0),
+    ringPlacement: ColumnRingPlacement.default('ends'),
+    ringThickness: z.number().min(0.01).max(0.14).default(0.055),
+    ringSpread: z.number().min(0.04).max(0.45).default(0.16),
+    fluteCount: z.number().int().min(0).max(32).default(0),
+    fluteDepth: z.number().min(0.005).max(0.08).default(0.02),
+    fluteWidth: z.number().min(0.005).max(0.1).default(0.02),
+    spiralTwist: z.number().min(-3).max(3).default(0),
+    spiralRibCount: z.number().int().min(0).max(32).default(0),
+    panelCount: z.number().int().min(0).max(24).default(0),
+    panelInsetDepth: z.number().min(0).max(0.1).default(0.02),
+    panelShape: ColumnPanelShape.default('rectangle'),
+    latheRingCount: z.number().int().min(0).max(32).default(0),
+    latheRingSpacing: ColumnRingPlacement.default('ends'),
+    carvingLevel: z.number().int().min(0).max(4).default(0),
+    carvingPlacement: ColumnCarvingPlacement.default('capital'),
+    lowerBandEnabled: z.boolean().default(false),
+    lowerBandHeight: z.number().min(0).max(1).default(0.24),
+    lowerBandCarvingLevel: z.number().int().min(0).max(4).default(0),
+    dentilCount: z.number().int().min(0).max(48).default(0),
+    beadCount: z.number().int().min(0).max(64).default(0),
+    material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
+}).describe(dedent `
+  Column node - used to represent structural or decorative pillars/columns.
+  - style: visual approach such as plain, lathe-turned, carved, or cluster
+  - crossSection: plan shape used by the procedural renderer
+  - height/radius/width/depth: primary dimensions in meters
+  - edgeSoftness: bevel radius for square/plinth/block edges
+  - shaftProfile/shaftDetail: profile and surface treatment of the shaft
+  - shaftTwistStep: per-segment shaft rotation in degrees
+  - shaftCornerRadius: rounded-corner radius for square/rectangular shaft cross-sections
+  - baseStyle/capitalStyle: procedural base and top treatment with tier/detail controls
+  - baseHeight/capitalHeight: bottom and top block proportions
+  - ring/flute/spiral/panel/lathe/carving fields: procedural detail controls
+`);
+export const COLUMN_PRESETS = {
+    basicPillar: {
+        label: 'Straight Round',
+        style: 'plain',
+        crossSection: 'round',
+        height: 2.9,
+        radius: 0.22,
+        width: 0.44,
+        depth: 0.44,
+        edgeSoftness: 0.025,
+        baseHeight: 0.22,
+        capitalHeight: 0.2,
+        shaftProfile: 'straight',
+        shaftTaper: 0,
+        shaftBulge: 0,
+        shaftStartScale: 0.72,
+        shaftEndScale: 0.72,
+        shaftSegmentCount: 1,
+        shaftTwistStep: 0,
+        shaftCornerRadius: 0.035,
+        shaftDetail: 'none',
+        baseStyle: 'square-plinth',
+        baseWidthScale: 1.26,
+        baseDepthScale: 1.26,
+        baseTierCount: 1,
+        baseStepSpread: 0.34,
+        basePlinthHeightRatio: 0.44,
+        baseRoundBandScale: 0.92,
+        baseNeckScale: 0.72,
+        baseRoundBandCount: 0,
+        baseRibCount: 0,
+        baseCarvingLevel: 0,
+        capitalStyle: 'simple-slab',
+        capitalWidthScale: 1.22,
+        capitalDepthScale: 1.22,
+        capitalTierCount: 1,
+        capitalStepSpread: 0.34,
+        capitalBandCount: 0,
+        capitalCarvingLevel: 0,
+        ringCount: 0,
+        ringSpread: 0.16,
+        fluteCount: 0,
+        spiralTwist: 0,
+        spiralRibCount: 0,
+        panelCount: 0,
+        latheRingCount: 0,
+        carvingLevel: 0,
+        lowerBandEnabled: false,
+        dentilCount: 0,
+        beadCount: 0,
+    },
+    squarePillar: {
+        label: 'Square Block',
+        style: 'faceted',
+        crossSection: 'square',
+        height: 2.9,
+        radius: 0.24,
+        width: 0.48,
+        depth: 0.48,
+        edgeSoftness: 0.035,
+        baseHeight: 0.22,
+        capitalHeight: 0.2,
+        shaftProfile: 'straight',
+        shaftTaper: 0,
+        shaftBulge: 0,
+        shaftStartScale: 0.72,
+        shaftEndScale: 0.72,
+        shaftSegmentCount: 1,
+        shaftTwistStep: 0,
+        shaftCornerRadius: 0.045,
+        shaftDetail: 'none',
+        baseStyle: 'simple-square',
+        baseWidthScale: 1.18,
+        baseDepthScale: 1.18,
+        baseTierCount: 1,
+        baseStepSpread: 0.34,
+        basePlinthHeightRatio: 0.44,
+        baseRoundBandScale: 0.92,
+        baseNeckScale: 0.72,
+        baseRoundBandCount: 0,
+        baseRibCount: 0,
+        baseCarvingLevel: 0,
+        capitalStyle: 'simple-slab',
+        capitalWidthScale: 1.18,
+        capitalDepthScale: 1.18,
+        capitalTierCount: 1,
+        capitalStepSpread: 0.34,
+        capitalBandCount: 0,
+        capitalCarvingLevel: 0,
+        ringCount: 0,
+        ringSpread: 0.16,
+        fluteCount: 0,
+        spiralTwist: 0,
+        spiralRibCount: 0,
+        panelCount: 0,
+        latheRingCount: 0,
+        carvingLevel: 0,
+        lowerBandEnabled: false,
+        dentilCount: 0,
+        beadCount: 0,
+    },
+    taperedPillar: {
+        label: 'Tapered Round',
+        style: 'plain',
+        crossSection: 'round',
+        height: 3,
+        radius: 0.23,
+        width: 0.46,
+        depth: 0.46,
+        edgeSoftness: 0.025,
+        baseHeight: 0.23,
+        capitalHeight: 0.2,
+        shaftProfile: 'tapered',
+        shaftTaper: 0.14,
+        shaftBulge: 0,
+        shaftStartScale: 0.82,
+        shaftEndScale: 0.72,
+        shaftSegmentCount: 32,
+        shaftTwistStep: 0,
+        shaftCornerRadius: 0.035,
+        shaftDetail: 'none',
+        baseStyle: 'square-plinth',
+        baseWidthScale: 1.26,
+        baseDepthScale: 1.26,
+        baseTierCount: 1,
+        baseStepSpread: 0.34,
+        basePlinthHeightRatio: 0.44,
+        baseRoundBandScale: 0.92,
+        baseNeckScale: 0.72,
+        baseRoundBandCount: 0,
+        baseRibCount: 0,
+        baseCarvingLevel: 0,
+        capitalStyle: 'simple-slab',
+        capitalWidthScale: 1.22,
+        capitalDepthScale: 1.22,
+        capitalTierCount: 1,
+        capitalStepSpread: 0.34,
+        capitalBandCount: 0,
+        capitalCarvingLevel: 0,
+        ringCount: 0,
+        ringSpread: 0.16,
+        fluteCount: 0,
+        spiralTwist: 0,
+        spiralRibCount: 0,
+        panelCount: 0,
+        latheRingCount: 0,
+        carvingLevel: 0,
+        lowerBandEnabled: false,
+        dentilCount: 0,
+        beadCount: 0,
+    },
+    bulgedPillar: {
+        label: 'Soft Bulged',
+        style: 'plain',
+        crossSection: 'round',
+        height: 2.9,
+        radius: 0.22,
+        width: 0.44,
+        depth: 0.44,
+        edgeSoftness: 0.025,
+        baseHeight: 0.22,
+        capitalHeight: 0.2,
+        shaftProfile: 'bulged',
+        shaftTaper: 0,
+        shaftBulge: 0.12,
+        shaftStartScale: 0.68,
+        shaftEndScale: 0.68,
+        shaftSegmentCount: 32,
+        shaftTwistStep: 0,
+        shaftCornerRadius: 0.035,
+        shaftDetail: 'none',
+        baseStyle: 'square-plinth',
+        baseWidthScale: 1.24,
+        baseDepthScale: 1.24,
+        baseTierCount: 1,
+        baseStepSpread: 0.34,
+        basePlinthHeightRatio: 0.44,
+        baseRoundBandScale: 0.92,
+        baseNeckScale: 0.72,
+        baseRoundBandCount: 0,
+        baseRibCount: 0,
+        baseCarvingLevel: 0,
+        capitalStyle: 'simple-slab',
+        capitalWidthScale: 1.2,
+        capitalDepthScale: 1.2,
+        capitalTierCount: 1,
+        capitalStepSpread: 0.34,
+        capitalBandCount: 0,
+        capitalCarvingLevel: 0,
+        ringCount: 0,
+        ringSpread: 0.16,
+        fluteCount: 0,
+        spiralTwist: 0,
+        spiralRibCount: 0,
+        panelCount: 0,
+        latheRingCount: 0,
+        carvingLevel: 0,
+        lowerBandEnabled: false,
+        dentilCount: 0,
+        beadCount: 0,
+    },
+    hourglassPillar: {
+        label: 'Hourglass',
+        style: 'plain',
+        crossSection: 'round',
+        height: 2.9,
+        radius: 0.22,
+        width: 0.44,
+        depth: 0.44,
+        edgeSoftness: 0.025,
+        baseHeight: 0.22,
+        capitalHeight: 0.2,
+        shaftProfile: 'hourglass',
+        shaftTaper: 0,
+        shaftBulge: 0.12,
+        shaftStartScale: 0.84,
+        shaftEndScale: 0.84,
+        shaftSegmentCount: 32,
+        shaftTwistStep: 0,
+        shaftCornerRadius: 0.035,
+        shaftDetail: 'none',
+        baseStyle: 'square-plinth',
+        baseWidthScale: 1.24,
+        baseDepthScale: 1.24,
+        baseTierCount: 1,
+        baseStepSpread: 0.34,
+        basePlinthHeightRatio: 0.44,
+        baseRoundBandScale: 0.92,
+        baseNeckScale: 0.72,
+        baseRoundBandCount: 0,
+        baseRibCount: 0,
+        baseCarvingLevel: 0,
+        capitalStyle: 'simple-slab',
+        capitalWidthScale: 1.2,
+        capitalDepthScale: 1.2,
+        capitalTierCount: 1,
+        capitalStepSpread: 0.34,
+        capitalBandCount: 0,
+        capitalCarvingLevel: 0,
+        ringCount: 0,
+        ringSpread: 0.16,
+        fluteCount: 0,
+        spiralTwist: 0,
+        spiralRibCount: 0,
+        panelCount: 0,
+        latheRingCount: 0,
+        carvingLevel: 0,
+        lowerBandEnabled: false,
+        dentilCount: 0,
+        beadCount: 0,
+    },
+};

package/dist/schema/nodes/door.d.ts

@@ -12,6 +12,31 @@ export declare const DoorSegment: z.ZodObject<{
     panelInset: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type DoorSegment = z.infer<typeof DoorSegment>;
+export declare const DoorCategory: z.ZodEnum<{
+    interior: "interior";
+    garage: "garage";
+}>;
+export declare const DoorType: z.ZodEnum<{
+    double: "double";
+    hinged: "hinged";
+    french: "french";
+    folding: "folding";
+    pocket: "pocket";
+    barn: "barn";
+    sliding: "sliding";
+    "garage-sectional": "garage-sectional";
+    "garage-rollup": "garage-rollup";
+    "garage-tiltup": "garage-tiltup";
+}>;
+export declare const DoorTrackStyle: z.ZodEnum<{
+    visible: "visible";
+    none: "none";
+    pocket: "pocket";
+    overhead: "overhead";
+}>;
+export type DoorCategory = z.infer<typeof DoorCategory>;
+export type DoorType = z.infer<typeof DoorType>;
+export type DoorTrackStyle = z.infer<typeof DoorTrackStyle>;
 export declare const DoorNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -71,6 +96,52 @@ export declare const DoorNode: z.ZodObject<{
     wallId: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    doorCategory: z.ZodDefault<z.ZodEnum<{
+        interior: "interior";
+        garage: "garage";
+    }>>;
+    doorType: z.ZodDefault<z.ZodEnum<{
+        double: "double";
+        hinged: "hinged";
+        french: "french";
+        folding: "folding";
+        pocket: "pocket";
+        barn: "barn";
+        sliding: "sliding";
+        "garage-sectional": "garage-sectional";
+        "garage-rollup": "garage-rollup";
+        "garage-tiltup": "garage-tiltup";
+    }>>;
+    leafCount: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    operationState: z.ZodDefault<z.ZodNumber>;
+    slideDirection: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    trackStyle: z.ZodDefault<z.ZodEnum<{
+        visible: "visible";
+        none: "none";
+        pocket: "pocket";
+        overhead: "overhead";
+    }>>;
+    garagePanelCount: z.ZodDefault<z.ZodNumber>;
+    openingKind: z.ZodDefault<z.ZodEnum<{
+        door: "door";
+        opening: "opening";
+    }>>;
+    openingShape: z.ZodDefault<z.ZodEnum<{
+        rectangle: "rectangle";
+        rounded: "rounded";
+        arch: "arch";
+    }>>;
+    openingRadiusMode: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        individual: "individual";
+    }>>;
+    openingTopRadii: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    cornerRadius: z.ZodDefault<z.ZodNumber>;
+    archHeight: z.ZodDefault<z.ZodNumber>;
+    openingRevealRadius: z.ZodDefault<z.ZodNumber>;
     frameThickness: z.ZodDefault<z.ZodNumber>;
     frameDepth: z.ZodDefault<z.ZodNumber>;
     threshold: z.ZodDefault<z.ZodBoolean>;
@@ -83,6 +154,7 @@ export declare const DoorNode: z.ZodObject<{
         inward: "inward";
         outward: "outward";
     }>>;
+    swingAngle: z.ZodDefault<z.ZodNumber>;
     segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
         type: z.ZodEnum<{
             glass: "glass";

package/dist/schema/nodes/door.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/door.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;iBAWtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8DnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/door.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;iBAWtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,YAAY;;;EAAiC,CAAA;AAC1D,eAAO,MAAM,QAAQ;;;;;;;;;;;EAWnB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;EAAoD,CAAA;AAE/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAC/C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuFnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/door.js

@@ -12,6 +12,20 @@ export const DoorSegment = z.object({
     panelDepth: z.number().default(0.01), // + raised, - recessed
     panelInset: z.number().default(0.04),
 });
+export const DoorCategory = z.enum(['interior', 'garage']);
+export const DoorType = z.enum([
+    'hinged',
+    'double',
+    'french',
+    'folding',
+    'pocket',
+    'barn',
+    'sliding',
+    'garage-sectional',
+    'garage-rollup',
+    'garage-tiltup',
+]);
+export const DoorTrackStyle = z.enum(['none', 'visible', 'pocket', 'overhead']);
 export const DoorNode = BaseNode.extend({
     id: objectId('door'),
     type: nodeType('door'),
@@ -23,6 +37,22 @@ export const DoorNode = BaseNode.extend({
     // Overall dimensions
     width: z.number().default(0.9),
     height: z.number().default(2.1),
+    // Door family
+    doorCategory: DoorCategory.default('interior'),
+    doorType: DoorType.default('hinged'),
+    leafCount: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]).default(1),
+    operationState: z.number().min(0).max(1).default(0),
+    slideDirection: z.enum(['left', 'right']).default('left'),
+    trackStyle: DoorTrackStyle.default('none'),
+    garagePanelCount: z.number().int().min(1).max(12).default(4),
+    // Opening mode
+    openingKind: z.enum(['door', 'opening']).default('door'),
+    openingShape: z.enum(['rectangle', 'rounded', 'arch']).default('rectangle'),
+    openingRadiusMode: z.enum(['all', 'individual']).default('all'),
+    openingTopRadii: z.tuple([z.number(), z.number()]).default([0.15, 0.15]),
+    cornerRadius: z.number().min(0).default(0.15),
+    archHeight: z.number().min(0).default(0.45),
+    openingRevealRadius: z.number().min(0).default(0.025),
     // Frame
     frameThickness: z.number().default(0.05),
     frameDepth: z.number().default(0.07),
@@ -31,6 +61,11 @@ export const DoorNode = BaseNode.extend({
     // Swing
     hingesSide: z.enum(['left', 'right']).default('left'),
     swingDirection: z.enum(['inward', 'outward']).default('inward'),
+    swingAngle: z
+        .number()
+        .min(0)
+        .max(Math.PI / 2)
+        .default(0),
     // Leaf segments — stacked top to bottom, each with its own column split
     segments: z.array(DoorSegment).default([
         {
@@ -62,8 +97,10 @@ export const DoorNode = BaseNode.extend({
     panicBarHeight: z.number().default(1.0),
 }).describe(dedent `Door node - a parametric door placed on a wall
   - position: center of the door in wall-local coordinate system (Y = height/2, always at floor)
+  - doorCategory/doorType: explicit operation family, defaulting old doors to interior hinged
+  - openingKind/openingShape: hinged door or frameless wall opening shape
   - segments: rows stacked top to bottom, each defining its own columnRatios
-  - type 'empty' = flush flat fill, 'panel' = raised/recessed panel, 'glass' = glazed
-  - hingesSide/swingDirection: which way the door opens
+  - type 'empty' = no leaf fill for that segment, 'panel' = raised/recessed panel, 'glass' = glazed
+  - hingesSide/swingDirection/swingAngle: which way the door opens and how far it is currently open
   - doorCloser/panicBar: commercial and emergency hardware options
 `);

package/dist/schema/nodes/fence.d.ts

@@ -61,9 +61,9 @@ export declare const FenceNode: z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
-    curveOffset: z.ZodOptional<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
+    curveOffset: z.ZodOptional<z.ZodNumber>;
     baseHeight: z.ZodDefault<z.ZodNumber>;
     postSpacing: z.ZodDefault<z.ZodNumber>;
     postSize: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/fence.js

@@ -11,9 +11,9 @@ export const FenceNode = BaseNode.extend({
     materialPreset: z.string().optional(),
     start: z.tuple([z.number(), z.number()]),
     end: z.tuple([z.number(), z.number()]),
-    curveOffset: z.number().optional(),
     height: z.number().default(1.8),
     thickness: z.number().default(0.08),
+    curveOffset: z.number().optional(),
     baseHeight: z.number().default(0.22),
     postSpacing: z.number().default(2),
     postSize: z.number().default(0.1),
@@ -26,8 +26,8 @@ export const FenceNode = BaseNode.extend({
 }).describe(dedent `
   Fence node - used to represent a fence segment in the building/site level coordinate system
   - start/end: fence endpoints in level coordinate system
-  - curveOffset: midpoint sagitta offset used to bend the fence into an arc
   - height/thickness: overall fence dimensions in meters
+  - curveOffset: midpoint sagitta offset used to bend the fence into an arc
   - baseHeight/postSpacing/postSize/topRailHeight: exact geometric controls from the plan3D fence model
   - groundClearance/edgeInset/baseStyle: fence support and inset configuration
   - color/style: visual appearance options

package/dist/schema/nodes/guide.d.ts

@@ -1,4 +1,12 @@
 import { z } from 'zod';
+export declare const GuideScaleReference: z.ZodObject<{
+    start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    realLengthMeters: z.ZodNumber;
+    measuredLengthUnits: z.ZodNumber;
+    metersPerUnit: z.ZodNumber;
+    label: z.ZodString;
+}, z.core.$strip>;
 export declare const GuideNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -22,6 +30,15 @@ export declare const GuideNode: z.ZodObject<{
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     scale: z.ZodDefault<z.ZodNumber>;
     opacity: z.ZodDefault<z.ZodNumber>;
+    scaleReference: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        realLengthMeters: z.ZodNumber;
+        measuredLengthUnits: z.ZodNumber;
+        metersPerUnit: z.ZodNumber;
+        label: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
+export type GuideScaleReference = z.infer<typeof GuideScaleReference>;
 export type GuideNode = z.infer<typeof GuideNode>;
 //# sourceMappingURL=guide.d.ts.map

package/dist/schema/nodes/guide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guide.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/guide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;iBAQpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"guide.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/guide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASpB,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/guide.js

@@ -1,11 +1,21 @@
 import { z } from 'zod';
+import { AssetUrl } from '../asset-url';
 import { BaseNode, nodeType, objectId } from '../base';
+export const GuideScaleReference = z.object({
+    start: z.tuple([z.number(), z.number()]),
+    end: z.tuple([z.number(), z.number()]),
+    realLengthMeters: z.number().positive(),
+    measuredLengthUnits: z.number().positive(),
+    metersPerUnit: z.number().positive(),
+    label: z.string(),
+});
 export const GuideNode = BaseNode.extend({
     id: objectId('guide'),
     type: nodeType('guide'),
-    url: z.string(),
+    url: AssetUrl,
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     scale: z.number().default(1),
     opacity: z.number().min(0).max(100).default(50),
+    scaleReference: GuideScaleReference.nullable().default(null),
 });

package/dist/schema/nodes/item.d.ts

@@ -143,6 +143,13 @@ declare const assetSchema: z.ZodObject<{
     category: z.ZodString;
     name: z.ZodString;
     thumbnail: z.ZodString;
+    floorPlanUrl: z.ZodOptional<z.ZodString>;
+    source: z.ZodDefault<z.ZodEnum<{
+        library: "library";
+        community: "community";
+        mine: "mine";
+    }>>;
+    isDraft: z.ZodOptional<z.ZodBoolean>;
     src: z.ZodString;
     dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     attachTo: z.ZodOptional<z.ZodEnum<{
@@ -238,6 +245,13 @@ export declare const ItemNode: z.ZodObject<{
         category: z.ZodString;
         name: z.ZodString;
         thumbnail: z.ZodString;
+        floorPlanUrl: z.ZodOptional<z.ZodString>;
+        source: z.ZodDefault<z.ZodEnum<{
+            library: "library";
+            community: "community";
+            mine: "mine";
+        }>>;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
         src: z.ZodString;
         dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         attachTo: z.ZodOptional<z.ZodEnum<{
@@ -299,6 +313,12 @@ export declare const ItemNode: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ItemNode = z.infer<typeof ItemNode>;
+export declare const LOW_PROFILE_ITEM_SURFACE_MAX_HEIGHT = 0.1;
+/**
+ * Low, floor-resting items like rugs and parking mats can receive items visually,
+ * but should not become item parents or block normal floor placement.
+ */
+export declare function isLowProfileItemSurface(item: ItemNode): boolean;
 /**
  * Returns the effective world-space dimensions of an item after applying its scale.
  * Use this everywhere item.asset.dimensions is used for spatial calculations.