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

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/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<{
@@ -104,6 +116,23 @@ export declare const DoorNode: z.ZodObject<{
     }>>;
     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";

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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmGnB,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,uBAAuB;;;EAAgC,CAAA;AACpE,eAAO,MAAM,yBAAyB;;;;;EAKpC,CAAA;AACF,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,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAC7E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACjF,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiHnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/door.js

@@ -13,6 +13,13 @@ export const DoorSegment = z.object({
     panelInset: z.number().default(0.04),
 });
 export const DoorCategory = z.enum(['interior', 'garage']);
+export const OpeningConstructionType = z.enum(['framed', 'masonry']);
+export const OpeningDimensionReference = z.enum([
+    'nominal',
+    'rough-opening',
+    'masonry-opening',
+    'finish-opening',
+]);
 export const DoorType = z.enum([
     'hinged',
     'double',
@@ -49,6 +56,19 @@ export const DoorNode = BaseNode.extend({
     // Overall dimensions
     width: z.number().default(0.9),
     height: z.number().default(2.1),
+    // Construction-document identity. `mark` overrides the deterministic
+    // level fallback (101, 102, ...). Rough-opening dimensions stay optional
+    // because they are manufacturer/framing inputs, not safe derivations from
+    // the nominal modeled size.
+    mark: z.string().trim().max(16).optional(),
+    constructionType: OpeningConstructionType.default('framed'),
+    dimensionReference: OpeningDimensionReference.default('nominal'),
+    roughOpeningWidth: z.number().positive().optional(),
+    roughOpeningHeight: z.number().positive().optional(),
+    masonryOpeningWidth: z.number().positive().optional(),
+    masonryOpeningHeight: z.number().positive().optional(),
+    finishOpeningWidth: z.number().positive().optional(),
+    finishOpeningHeight: z.number().positive().optional(),
     // Door family
     doorCategory: DoorCategory.default('interior'),
     doorType: DoorType.default('hinged'),

package/dist/schema/nodes/duct-terminal.d.ts

@@ -31,6 +31,7 @@ export declare const DuctTerminalNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"duct-terminal">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     terminalType: z.ZodDefault<z.ZodEnum<{
         "supply-register": "supply-register";
         diffuser: "diffuser";

package/dist/schema/nodes/duct-terminal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duct-terminal.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/duct-terminal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC5B,CAAA;AACD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"duct-terminal.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/duct-terminal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAA;AACD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/duct-terminal.js

@@ -20,6 +20,8 @@ export const DuctTerminalNode = BaseNode.extend({
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Yaw in radians.
     rotation: z.number().default(0),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
     terminalType: z.enum(['supply-register', 'diffuser', 'return-grille']).default('supply-register'),
     // Which surface the terminal mounts on. Drives face orientation and
     // which way the collar (and its port) points.

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

@@ -72,6 +72,8 @@ export declare const FenceNode: z.ZodObject<{
     tangents: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     height: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
+    supportOffset: z.ZodOptional<z.ZodNumber>;
     curveOffset: z.ZodOptional<z.ZodNumber>;
     baseHeight: z.ZodDefault<z.ZodNumber>;
     postSpacing: z.ZodDefault<z.ZodNumber>;

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

@@ -1 +1 @@
-{"version":3,"file":"fence.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;EAAoD,CAAA;AAC3E,eAAO,MAAM,cAAc;;;EAAmC,CAAA;AAC9D,eAAO,MAAM,YAAY;;;;EAAsC,CAAA;AAE/D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"fence.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;EAAoD,CAAA;AAC3E,eAAO,MAAM,cAAc;;;EAAmC,CAAA;AAC9D,eAAO,MAAM,YAAY;;;;EAAsC,CAAA;AAE/D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/fence.js

@@ -30,6 +30,12 @@ export const FenceNode = BaseNode.extend({
     tangents: z.array(z.tuple([z.number(), z.number()]).nullable()).optional(),
     height: z.number().default(1.8),
     thickness: z.number().default(0.08),
+    // Persisted slab-support host — the fence sits on that slab's walking
+    // surface (see ItemNode.supportSlabId for the host rules).
+    supportSlabId: z.string().optional(),
+    // Manual vertical offset from the elected slab or level support. This moves
+    // the complete fence body without changing its height.
+    supportOffset: z.number().finite().optional(),
     curveOffset: z.number().optional(),
     baseHeight: z.number().default(0.22),
     postSpacing: z.number().default(2),
@@ -51,6 +57,8 @@ export const FenceNode = BaseNode.extend({
   - path: optional list of [x, y] points; when set (>= 2) the centerline is a smooth spline through them
   - tangents: optional per-point handle vectors (parallel to path); null entries fall back to the automatic tangent
   - height/thickness: overall fence dimensions in meters
+  - supportSlabId: optional slab host; the fence stands on that slab's walking surface (elevation)
+  - supportOffset: manual vertical offset from the elected support surface
   - curveOffset: midpoint sagitta offset used to bend the fence into an arc (ignored when path is set)
   - baseHeight/postSpacing/postSize/topRailHeight: exact geometric controls from the plan3D fence model
   - groundClearance/edgeInset/baseStyle: fence support and inset configuration

package/dist/schema/nodes/hvac-equipment.d.ts

@@ -33,6 +33,7 @@ export declare const HvacEquipmentNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"hvac-equipment">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     equipmentType: z.ZodDefault<z.ZodEnum<{
         furnace: "furnace";
         "air-handler": "air-handler";

package/dist/schema/nodes/hvac-equipment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hvac-equipment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hvac-equipment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC7B,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"hvac-equipment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hvac-equipment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7B,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/hvac-equipment.js

@@ -22,6 +22,8 @@ export const HvacEquipmentNode = BaseNode.extend({
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Yaw in radians.
     rotation: z.number().default(0),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
     equipmentType: z.enum(['furnace', 'air-handler', 'condenser']).default('furnace'),
     // Cabinet dimensions in meters. Defaults match a typical upflow
     // furnace cabinet (~22" × 28" footprint, ~43" tall).

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

@@ -248,6 +248,7 @@ export declare const ItemNode: z.ZodObject<{
         right: "right";
         left: "left";
     }>>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     asset: z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}

package/dist/schema/nodes/item.js

@@ -115,6 +115,19 @@ export const ItemNode = BaseNode.extend({
     // mounts the node inside the face frame (`getRoofWallFaceFrame`).
     roofSegmentId: z.string().optional(),
     roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
+    // Persisted floor-support host (canonical doc — the same field on other
+    // floor-placed kinds and walls follows these rules). Written at
+    // placement/commit ONLY when overlapping slabs disagree on elevation
+    // (ambiguity); absent/null means "elect the support fresh on every
+    // read", which is the historical behavior. Read paths PREFER this slab
+    // while it still exists and still overlaps the node's footprint, and
+    // silently fall back to election otherwise. Deleting the host slab
+    // strips the field (deleteNodesAction); a host merely reshaped away is
+    // deliberately kept so hosting resumes if the slab's polygon returns.
+    // The sentinel value 'ground' (GROUND_SUPPORT_ID) pins the node to the
+    // level base — written when a pointer-capped commit elected the ground
+    // while a slab (e.g. an elevated deck) still overlapped the footprint.
+    supportSlabId: z.string().optional(),
     // Denormalized references to collections this node belongs to
     collectionIds: z.array(z.custom()).optional(),
     // Per-slot material overrides. Key = slot id (see deriveSlotId), value = a

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

@@ -17,8 +17,9 @@ export declare const LevelNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`measurement_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`shelf_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`item_${string}` | `ceiling_${string}` | `column_${string}` | `wall_${string}` | `fence_${string}` | `construction-dimension_${string}` | `structural-grid_${string}` | `zone_${string}` | `slab_${string}` | `roof_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`, string>>>>;
     level: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type LevelNode = z.infer<typeof LevelNode>;
 //# sourceMappingURL=level.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBA+BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAyDvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;iBAqBrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}