@pascal-app/core 0.9.1 → 1.0.0-beta.1

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

@@ -20,7 +20,7 @@ export declare const CeilingNode: z.ZodObject<{
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -31,7 +31,7 @@ export declare const CeilingNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -51,6 +51,7 @@ export declare const CeilingNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     holeMetadata: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -62,7 +63,7 @@ export declare const CeilingNode: z.ZodObject<{
         stairId: z.ZodOptional<z.ZodString>;
         elevatorId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
-    height: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type CeilingNode = z.infer<typeof CeilingNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"ceiling.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/ceiling.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}
+{"version":3,"file":"ceiling.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/ceiling.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/schema/nodes/ceiling.js

@@ -10,15 +10,25 @@ export const CeilingNode = BaseNode.extend({
     children: z.array(ItemNode.shape.id).default([]),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
+    // Per-slot material overrides on the unified slot model, mirroring
+    // `ShelfNode.slots`. Key = slot id (`surface`), value = a `MaterialRef`
+    // (`library:<id>` / `scene:<id>`). Absent = the declared slot default.
+    slots: z.record(z.string(), z.string()).optional(),
     polygon: z.array(z.tuple([z.number(), z.number()])),
     holes: z.array(z.array(z.tuple([z.number(), z.number()]))).default([]),
     holeMetadata: z.array(SurfaceHoleMetadata).default([]),
-    height: z.number().default(2.5), // Height in meters
+    // Height in meters. Absent = the ceiling follows the level top: its
+    // effective height is the same bound its write-clamp uses —
+    // min(storey plane, lowest covering-slab underside over the polygon)
+    // − CEILING_CLAMP_MARGIN (see `resolveCeilingHeight`). Present = an
+    // explicit custom height, still write-clamped under that bound.
+    height: z.number().optional(),
     autoFromWalls: z.boolean().default(false),
 }).describe(dedent `
   Ceiling node - used to represent a ceiling in the building
   - polygon: array of [x, z] points defining the ceiling boundary
   - holes: array of polygons representing holes in the ceiling
   - holeMetadata: metadata parallel to holes, used to preserve manual and auto-managed cutouts
+  - height: explicit height in meters; absent = follows the level top automatically
   - autoFromWalls: whether the ceiling is automatically generated from a closed wall loop
   `);

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

@@ -24,7 +24,7 @@ export declare const ChimneyNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"chimney">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -35,7 +35,7 @@ export declare const ChimneyNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -57,7 +57,7 @@ export declare const ChimneyNode: z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     topMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -68,7 +68,7 @@ export declare const ChimneyNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;

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

@@ -112,6 +112,7 @@ export declare const ColumnNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"column">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     style: z.ZodDefault<z.ZodEnum<{
         plain: "plain";
         faceted: "faceted";
@@ -263,7 +264,7 @@ export declare const ColumnNode: z.ZodObject<{
     bracePlateEnabled: z.ZodDefault<z.ZodBoolean>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -274,7 +275,7 @@ export declare const ColumnNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -294,6 +295,7 @@ export declare const ColumnNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export declare const COLUMN_PRESETS: {
     readonly basicPillar: {

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

@@ -1 +1 @@
-{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/column.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;EAOtB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;EAM7B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;EAAqE,CAAA;AAEpG,eAAO,MAAM,iBAAiB;;;;;;EAAmE,CAAA;AAEjG,eAAO,MAAM,gBAAgB;;;;EAA6C,CAAA;AAE1E,eAAO,MAAM,eAAe;;;;;;;;;EAS1B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;EAa7B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;EAA4C,CAAA;AAE5E,eAAO,MAAM,sBAAsB;;;;;EAA8C,CAAA;AAEjF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACrD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AACrE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2FrB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2yBiE,CAAA;AAE5F,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,cAAc,CAAA;AAExD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"column.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/column.ts"],"names":[],"mappings":"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"}

package/dist/schema/nodes/column.js

@@ -64,6 +64,8 @@ export const ColumnNode = BaseNode.extend({
     type: nodeType('column'),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.number().default(0),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
     style: ColumnStyle.default('plain'),
     crossSection: ColumnCrossSection.default('round'),
     height: z.number().positive().default(2.5),
@@ -137,6 +139,9 @@ export const ColumnNode = BaseNode.extend({
     bracePlateEnabled: z.boolean().default(true),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
+    // Unified paint-slot refs (`scene:`/`library:` MaterialRef per slot id),
+    // matching the slot model items/slab/shelf use. Absent = declared default.
+    slots: z.record(z.string(), 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

package/dist/schema/nodes/construction-dimension.d.ts

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+export declare const ConstructionDimensionBaseline: z.ZodObject<{
+    origin: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    direction: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>;
+export declare const ConstructionDimensionChainMode: z.ZodEnum<{
+    "point-to-point": "point-to-point";
+    continuous: "continuous";
+}>;
+export declare const ConstructionDimensionMode: z.ZodEnum<{
+    radius: "radius";
+    linear: "linear";
+    diameter: "diameter";
+    "center-mark": "center-mark";
+    chord: "chord";
+    "arc-length": "arc-length";
+    angular: "angular";
+    coordinate: "coordinate";
+}>;
+export declare const ConstructionDrawingType: z.ZodEnum<{
+    "floor-plan": "floor-plan";
+    "foundation-plan": "foundation-plan";
+    "reflected-ceiling-plan": "reflected-ceiling-plan";
+    "roof-plan": "roof-plan";
+    "site-plan": "site-plan";
+}>;
+export declare const ConstructionDimensionDrawingPresentation: z.ZodEnum<{
+    shown: "shown";
+    omit: "omit";
+    controlled: "controlled";
+}>;
+export declare const ConstructionDimensionDrawingOverride: z.ZodObject<{
+    drawingType: z.ZodEnum<{
+        "floor-plan": "floor-plan";
+        "foundation-plan": "foundation-plan";
+        "reflected-ceiling-plan": "reflected-ceiling-plan";
+        "roof-plan": "roof-plan";
+        "site-plan": "site-plan";
+    }>;
+    presentation: z.ZodEnum<{
+        shown: "shown";
+        omit: "omit";
+        controlled: "controlled";
+    }>;
+    suppressedSegmentIndexes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const ConstructionDimensionDatumPolicy: z.ZodEnum<{
+    centerline: "centerline";
+    "wall-face": "wall-face";
+    "structural-face": "structural-face";
+    "finish-face": "finish-face";
+}>;
+export declare const ConstructionDimensionTerminator: z.ZodEnum<{
+    "architectural-tick": "architectural-tick";
+    "filled-arrow": "filled-arrow";
+    "open-arrow": "open-arrow";
+    dot: "dot";
+}>;
+export declare const ConstructionDimensionTextPosition: z.ZodEnum<{
+    above: "above";
+    centered: "centered";
+}>;
+export declare const ConstructionDimensionImperialPrecision: z.ZodEnum<{
+    1: "1";
+    "1/2": "1/2";
+    "1/4": "1/4";
+    "1/8": "1/8";
+    "1/16": "1/16";
+}>;
+export declare const ConstructionDimensionMetricNotation: z.ZodEnum<{
+    meters: "meters";
+    millimeters: "millimeters";
+}>;
+export declare const ConstructionDimensionNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`construction-dimension_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"construction-dimension">>;
+    anchors: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
+        kind: z.ZodLiteral<"feature">;
+        reference: z.ZodObject<{
+            nodeId: z.ZodString;
+            featureId: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+        }, z.core.$strip>;
+        fallback: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>]>>>;
+    baseline: z.ZodDefault<z.ZodObject<{
+        origin: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        direction: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>;
+    chainMode: z.ZodDefault<z.ZodEnum<{
+        "point-to-point": "point-to-point";
+        continuous: "continuous";
+    }>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        radius: "radius";
+        linear: "linear";
+        diameter: "diameter";
+        "center-mark": "center-mark";
+        chord: "chord";
+        "arc-length": "arc-length";
+        angular: "angular";
+        coordinate: "coordinate";
+    }>>;
+    featureCount: z.ZodDefault<z.ZodNumber>;
+    showCenterMark: z.ZodDefault<z.ZodBoolean>;
+    prefix: z.ZodDefault<z.ZodString>;
+    suffix: z.ZodDefault<z.ZodString>;
+    textOverride: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    datumPolicy: z.ZodDefault<z.ZodEnum<{
+        centerline: "centerline";
+        "wall-face": "wall-face";
+        "structural-face": "structural-face";
+        "finish-face": "finish-face";
+    }>>;
+    terminator: z.ZodDefault<z.ZodEnum<{
+        "architectural-tick": "architectural-tick";
+        "filled-arrow": "filled-arrow";
+        "open-arrow": "open-arrow";
+        dot: "dot";
+    }>>;
+    textPosition: z.ZodDefault<z.ZodEnum<{
+        above: "above";
+        centered: "centered";
+    }>>;
+    imperialPrecision: z.ZodDefault<z.ZodEnum<{
+        1: "1";
+        "1/2": "1/2";
+        "1/4": "1/4";
+        "1/8": "1/8";
+        "1/16": "1/16";
+    }>>;
+    metricNotation: z.ZodDefault<z.ZodEnum<{
+        meters: "meters";
+        millimeters: "millimeters";
+    }>>;
+    extensionStartGap: z.ZodDefault<z.ZodNumber>;
+    extensionOvershoot: z.ZodDefault<z.ZodNumber>;
+    drawingType: z.ZodDefault<z.ZodEnum<{
+        "floor-plan": "floor-plan";
+        "foundation-plan": "foundation-plan";
+        "reflected-ceiling-plan": "reflected-ceiling-plan";
+        "roof-plan": "roof-plan";
+        "site-plan": "site-plan";
+    }>>;
+    drawingOverrides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        drawingType: z.ZodEnum<{
+            "floor-plan": "floor-plan";
+            "foundation-plan": "foundation-plan";
+            "reflected-ceiling-plan": "reflected-ceiling-plan";
+            "roof-plan": "roof-plan";
+            "site-plan": "site-plan";
+        }>;
+        presentation: z.ZodEnum<{
+            shown: "shown";
+            omit: "omit";
+            controlled: "controlled";
+        }>;
+        suppressedSegmentIndexes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    controllingDimensionId: z.ZodDefault<z.ZodNullable<z.ZodDefault<z.ZodTemplateLiteral<`construction-dimension_${string}`>>>>;
+}, z.core.$strip>;
+export type ConstructionDimensionBaseline = z.infer<typeof ConstructionDimensionBaseline>;
+export type ConstructionDimensionChainMode = z.infer<typeof ConstructionDimensionChainMode>;
+export type ConstructionDimensionMode = z.infer<typeof ConstructionDimensionMode>;
+export type ConstructionDrawingType = z.infer<typeof ConstructionDrawingType>;
+export type ConstructionDimensionDrawingPresentation = z.infer<typeof ConstructionDimensionDrawingPresentation>;
+export type ConstructionDimensionDrawingOverride = z.infer<typeof ConstructionDimensionDrawingOverride>;
+export type ConstructionDimensionDatumPolicy = z.infer<typeof ConstructionDimensionDatumPolicy>;
+export type ConstructionDimensionTerminator = z.infer<typeof ConstructionDimensionTerminator>;
+export type ConstructionDimensionTextPosition = z.infer<typeof ConstructionDimensionTextPosition>;
+export type ConstructionDimensionImperialPrecision = z.infer<typeof ConstructionDimensionImperialPrecision>;
+export type ConstructionDimensionMetricNotation = z.infer<typeof ConstructionDimensionMetricNotation>;
+export type ConstructionDimensionNode = z.infer<typeof ConstructionDimensionNode>;
+export declare const CONSTRUCTION_DRAWING_TYPES: ("floor-plan" | "foundation-plan" | "reflected-ceiling-plan" | "roof-plan" | "site-plan")[];
+export declare function resolveConstructionDimensionDrawingPresentation(node: Pick<ConstructionDimensionNode, 'drawingType' | 'drawingOverrides'>, drawingType: ConstructionDrawingType): ConstructionDimensionDrawingPresentation;
+export declare function resolveConstructionDimensionDrawingOverride(node: Pick<ConstructionDimensionNode, 'drawingOverrides'>, drawingType: ConstructionDrawingType): ConstructionDimensionDrawingOverride | null;
+export declare function setConstructionDimensionDrawingPresentation(node: Pick<ConstructionDimensionNode, 'drawingType' | 'drawingOverrides'>, drawingType: ConstructionDrawingType, presentation: ConstructionDimensionDrawingPresentation): ConstructionDimensionDrawingOverride[];
+export declare function setConstructionDimensionDrawingSuppressedSegments(node: Pick<ConstructionDimensionNode, 'drawingType' | 'drawingOverrides'>, drawingType: ConstructionDrawingType, suppressedSegmentIndexes: readonly number[]): ConstructionDimensionDrawingOverride[];
+export declare function constructionDimensionRequiredAnchorCount(mode: ConstructionDimensionMode): number;
+//# sourceMappingURL=construction-dimension.d.ts.map

package/dist/schema/nodes/construction-dimension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construction-dimension.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/construction-dimension.ts"],"names":[],"mappings":"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"}

package/dist/schema/nodes/construction-dimension.js

@@ -0,0 +1,151 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MeasurementAnchor } from './measurement';
+const FiniteCoordinate = z.number().finite();
+export const ConstructionDimensionBaseline = z
+    .object({
+    origin: z.tuple([FiniteCoordinate, FiniteCoordinate]).default([0, 0.6]),
+    direction: z.tuple([FiniteCoordinate, FiniteCoordinate]).default([1, 0]),
+})
+    .superRefine((baseline, ctx) => {
+    if (Math.hypot(baseline.direction[0], baseline.direction[1]) <= 1e-9) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['direction'],
+            message: 'Construction dimension baseline direction must be non-zero',
+        });
+    }
+});
+export const ConstructionDimensionChainMode = z.enum(['point-to-point', 'continuous']);
+export const ConstructionDimensionMode = z.enum([
+    'linear',
+    'radius',
+    'diameter',
+    'center-mark',
+    'chord',
+    'arc-length',
+    'angular',
+    'coordinate',
+]);
+export const ConstructionDrawingType = z.enum([
+    'floor-plan',
+    'foundation-plan',
+    'reflected-ceiling-plan',
+    'roof-plan',
+    'site-plan',
+]);
+export const ConstructionDimensionDrawingPresentation = z.enum(['shown', 'omit', 'controlled']);
+export const ConstructionDimensionDrawingOverride = z.object({
+    drawingType: ConstructionDrawingType,
+    presentation: ConstructionDimensionDrawingPresentation,
+    suppressedSegmentIndexes: z.array(z.number().int().min(0).max(999)).max(200).default([]),
+});
+export const ConstructionDimensionDatumPolicy = z.enum([
+    'centerline',
+    'wall-face',
+    'structural-face',
+    'finish-face',
+]);
+export const ConstructionDimensionTerminator = z.enum([
+    'architectural-tick',
+    'filled-arrow',
+    'open-arrow',
+    'dot',
+]);
+export const ConstructionDimensionTextPosition = z.enum(['above', 'centered']);
+export const ConstructionDimensionImperialPrecision = z.enum(['1', '1/2', '1/4', '1/8', '1/16']);
+export const ConstructionDimensionMetricNotation = z.enum(['meters', 'millimeters']);
+export const ConstructionDimensionNode = BaseNode.extend({
+    id: objectId('construction-dimension'),
+    type: nodeType('construction-dimension'),
+    anchors: z
+        .array(MeasurementAnchor)
+        .min(2)
+        .default([
+        [0, 0, 0],
+        [1, 0, 0],
+    ]),
+    baseline: ConstructionDimensionBaseline.default({ origin: [0, 0.6], direction: [1, 0] }),
+    chainMode: ConstructionDimensionChainMode.default('point-to-point'),
+    mode: ConstructionDimensionMode.default('linear'),
+    featureCount: z.number().int().min(1).max(999).default(1),
+    showCenterMark: z.boolean().default(true),
+    prefix: z.string().max(40).default(''),
+    suffix: z.string().max(40).default(''),
+    textOverride: z.string().trim().min(1).max(120).nullable().default(null),
+    datumPolicy: ConstructionDimensionDatumPolicy.default('centerline'),
+    terminator: ConstructionDimensionTerminator.default('architectural-tick'),
+    textPosition: ConstructionDimensionTextPosition.default('above'),
+    imperialPrecision: ConstructionDimensionImperialPrecision.default('1/16'),
+    metricNotation: ConstructionDimensionMetricNotation.default('meters'),
+    extensionStartGap: z.number().finite().min(0).max(1).default(0.075),
+    extensionOvershoot: z.number().finite().min(0).max(1).default(0.12),
+    drawingType: ConstructionDrawingType.default('floor-plan'),
+    drawingOverrides: z.array(ConstructionDimensionDrawingOverride).max(5).default([]),
+    controllingDimensionId: objectId('construction-dimension').nullable().default(null),
+}).describe(dedent `
+  Construction dimension node - an associative floor-plan construction dimension
+  - anchors: two or more free or semantic feature anchors that supply the witness origins
+  - baseline.origin: a point on the independently placed dimension line
+  - baseline.direction: the fixed plan direction used to project the witness origins
+  - chainMode: point-to-point for one segment or continuous for adjacent dimension strings
+  - mode: linear, radius, diameter, center mark, chord, arc length, angular, or coordinate
+  - featureCount: repeated-feature multiplier used by diameter/radius and other notation
+  - showCenterMark: displays the resolved circle/angle center where applicable
+  - prefix/suffix/textOverride: document notation overrides without changing geometry
+  - datumPolicy/terminator/textPosition/imperialPrecision/metricNotation/extensionStartGap/extensionOvershoot: dimension-standard overrides
+  - drawingType: the primary persistent drawing that owns the dimension
+  - drawingOverrides: omit, show, or foundation-control presentation per drawing type
+  - controllingDimensionId: foundation dimension whose associative geometry controls this dimension
+  `);
+export const CONSTRUCTION_DRAWING_TYPES = ConstructionDrawingType.options;
+export function resolveConstructionDimensionDrawingPresentation(node, drawingType) {
+    let override;
+    for (const entry of node.drawingOverrides) {
+        if (entry.drawingType === drawingType)
+            override = entry;
+    }
+    return override?.presentation ?? (node.drawingType === drawingType ? 'shown' : 'omit');
+}
+export function resolveConstructionDimensionDrawingOverride(node, drawingType) {
+    let override;
+    for (const entry of node.drawingOverrides) {
+        if (entry.drawingType === drawingType)
+            override = entry;
+    }
+    return override ?? null;
+}
+export function setConstructionDimensionDrawingPresentation(node, drawingType, presentation) {
+    const defaultPresentation = node.drawingType === drawingType ? 'shown' : 'omit';
+    const existing = resolveConstructionDimensionDrawingOverride(node, drawingType);
+    const withoutDrawing = node.drawingOverrides.filter((entry) => entry.drawingType !== drawingType);
+    const next = {
+        drawingType,
+        presentation,
+        suppressedSegmentIndexes: existing?.suppressedSegmentIndexes ?? [],
+    };
+    return isDefaultConstructionDimensionDrawingOverride(next, defaultPresentation)
+        ? withoutDrawing
+        : [...withoutDrawing, next];
+}
+export function setConstructionDimensionDrawingSuppressedSegments(node, drawingType, suppressedSegmentIndexes) {
+    const defaultPresentation = node.drawingType === drawingType ? 'shown' : 'omit';
+    const existing = resolveConstructionDimensionDrawingOverride(node, drawingType);
+    const presentation = existing?.presentation ?? defaultPresentation;
+    const suppressed = normalizeSuppressedSegmentIndexes(suppressedSegmentIndexes);
+    const withoutDrawing = node.drawingOverrides.filter((entry) => entry.drawingType !== drawingType);
+    const next = { drawingType, presentation, suppressedSegmentIndexes: suppressed };
+    return isDefaultConstructionDimensionDrawingOverride(next, defaultPresentation)
+        ? withoutDrawing
+        : [...withoutDrawing, next];
+}
+export function constructionDimensionRequiredAnchorCount(mode) {
+    return mode === 'arc-length' || mode === 'angular' ? 3 : 2;
+}
+function isDefaultConstructionDimensionDrawingOverride(override, defaultPresentation) {
+    return (override.presentation === defaultPresentation && override.suppressedSegmentIndexes.length === 0);
+}
+function normalizeSuppressedSegmentIndexes(indexes) {
+    return [...new Set(indexes.filter((index) => Number.isInteger(index) && index >= 0))].sort((left, right) => left - right);
+}

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

@@ -19,7 +19,7 @@ export declare const CupolaNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"cupola">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -30,7 +30,7 @@ export declare const CupolaNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;

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

@@ -16,6 +16,16 @@ export declare const DoorCategory: z.ZodEnum<{
     interior: "interior";
     garage: "garage";
 }>;
+export declare const OpeningConstructionType: z.ZodEnum<{
+    framed: "framed";
+    masonry: "masonry";
+}>;
+export declare const OpeningDimensionReference: z.ZodEnum<{
+    nominal: "nominal";
+    "rough-opening": "rough-opening";
+    "masonry-opening": "masonry-opening";
+    "finish-opening": "finish-opening";
+}>;
 export declare const DoorType: z.ZodEnum<{
     double: "double";
     hinged: "hinged";
@@ -35,6 +45,8 @@ export declare const DoorTrackStyle: z.ZodEnum<{
     overhead: "overhead";
 }>;
 export type DoorCategory = z.infer<typeof DoorCategory>;
+export type OpeningConstructionType = z.infer<typeof OpeningConstructionType>;
+export type OpeningDimensionReference = z.infer<typeof OpeningDimensionReference>;
 export type DoorType = z.infer<typeof DoorType>;
 export type DoorTrackStyle = z.infer<typeof DoorTrackStyle>;
 export declare const DoorNode: z.ZodObject<{
@@ -57,7 +69,7 @@ export declare const DoorNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"door">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -68,7 +80,7 @@ export declare const DoorNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -87,6 +99,7 @@ export declare const DoorNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
@@ -94,8 +107,32 @@ export declare const DoorNode: z.ZodObject<{
         back: "back";
     }>>;
     wallId: z.ZodOptional<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    roofFace: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+        right: "right";
+        left: "left";
+    }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
+    mark: z.ZodOptional<z.ZodString>;
+    constructionType: z.ZodDefault<z.ZodEnum<{
+        framed: "framed";
+        masonry: "masonry";
+    }>>;
+    dimensionReference: z.ZodDefault<z.ZodEnum<{
+        nominal: "nominal";
+        "rough-opening": "rough-opening";
+        "masonry-opening": "masonry-opening";
+        "finish-opening": "finish-opening";
+    }>>;
+    roughOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    roughOpeningHeight: z.ZodOptional<z.ZodNumber>;
+    masonryOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    masonryOpeningHeight: z.ZodOptional<z.ZodNumber>;
+    finishOpeningWidth: z.ZodOptional<z.ZodNumber>;
+    finishOpeningHeight: z.ZodOptional<z.ZodNumber>;
     doorCategory: z.ZodDefault<z.ZodEnum<{
         interior: "interior";
         garage: "garage";
@@ -115,8 +152,8 @@ export declare const DoorNode: z.ZodObject<{
     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";
+        left: "left";
     }>>;
     trackStyle: z.ZodDefault<z.ZodEnum<{
         visible: "visible";
@@ -147,8 +184,8 @@ export declare const DoorNode: z.ZodObject<{
     threshold: z.ZodDefault<z.ZodBoolean>;
     thresholdHeight: z.ZodDefault<z.ZodNumber>;
     hingesSide: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     swingDirection: z.ZodDefault<z.ZodEnum<{
         inward: "inward";
@@ -170,8 +207,8 @@ export declare const DoorNode: z.ZodObject<{
     handle: z.ZodDefault<z.ZodBoolean>;
     handleHeight: z.ZodDefault<z.ZodNumber>;
     handleSide: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     contentPadding: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     doorCloser: z.ZodDefault<z.ZodBoolean>;