@pascal-app/core 1.0.5 → 1.0.7

package/dist/schema/build-up.d.ts

@@ -0,0 +1,247 @@
+import { z } from 'zod';
+/** Nominal dimensional lumber, by its actual depth (`LUMBER_DEPTH`). */
+export declare const NominalLumber: z.ZodEnum<{
+    "2x10": "2x10";
+    "2x12": "2x12";
+    "2x4": "2x4";
+    "2x6": "2x6";
+    "2x8": "2x8";
+}>;
+export type NominalLumber = z.infer<typeof NominalLumber>;
+export declare const RoofingKind: z.ZodEnum<{
+    "architectural-shingle": "architectural-shingle";
+    "asphalt-3-tab": "asphalt-3-tab";
+    "clay-tile": "clay-tile";
+    "concrete-tile": "concrete-tile";
+    slate: "slate";
+    "standing-seam-metal": "standing-seam-metal";
+    "wood-shake": "wood-shake";
+}>;
+export type RoofingKind = z.infer<typeof RoofingKind>;
+export declare const UnderlaymentKind: z.ZodEnum<{
+    "felt-15": "felt-15";
+    "felt-30": "felt-30";
+    "ice-and-water": "ice-and-water";
+    synthetic: "synthetic";
+}>;
+export type UnderlaymentKind = z.infer<typeof UnderlaymentKind>;
+/** Structural panels: roof sheathing and attic decking. */
+export declare const PanelKind: z.ZodEnum<{
+    osb: "osb";
+    plywood: "plywood";
+}>;
+export type PanelKind = z.infer<typeof PanelKind>;
+/** Batt and blown fill the framing cavity; rigid board runs continuous over the framing. */
+export declare const InsulationKind: z.ZodEnum<{
+    batt: "batt";
+    blown: "blown";
+    rigid: "rigid";
+}>;
+export type InsulationKind = z.infer<typeof InsulationKind>;
+export declare const InteriorFinishKind: z.ZodEnum<{
+    drywall: "drywall";
+    plaster: "plaster";
+    "wood-plank": "wood-plank";
+}>;
+export type InteriorFinishKind = z.infer<typeof InteriorFinishKind>;
+export declare const RoofingLayer: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "architectural-shingle": "architectural-shingle";
+        "asphalt-3-tab": "asphalt-3-tab";
+        "clay-tile": "clay-tile";
+        "concrete-tile": "concrete-tile";
+        slate: "slate";
+        "standing-seam-metal": "standing-seam-metal";
+        "wood-shake": "wood-shake";
+    }>;
+    thickness: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UnderlaymentLayer: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "felt-15": "felt-15";
+        "felt-30": "felt-30";
+        "ice-and-water": "ice-and-water";
+        synthetic: "synthetic";
+    }>;
+    thickness: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PanelLayer: z.ZodObject<{
+    kind: z.ZodEnum<{
+        osb: "osb";
+        plywood: "plywood";
+    }>;
+    thickness: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const InsulationLayer: z.ZodObject<{
+    kind: z.ZodEnum<{
+        batt: "batt";
+        blown: "blown";
+        rigid: "rigid";
+    }>;
+    thickness: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const InteriorFinishLayer: z.ZodObject<{
+    kind: z.ZodEnum<{
+        drywall: "drywall";
+        plaster: "plaster";
+        "wood-plank": "wood-plank";
+    }>;
+    thickness: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** For trusses, `size` is the top chord: the depth the roof plane's deck carries. */
+export declare const RoofStructure: z.ZodObject<{
+    system: z.ZodEnum<{
+        rafters: "rafters";
+        trusses: "trusses";
+    }>;
+    size: z.ZodEnum<{
+        "2x10": "2x10";
+        "2x12": "2x12";
+        "2x4": "2x4";
+        "2x6": "2x6";
+        "2x8": "2x8";
+    }>;
+    spacing: z.ZodNumber;
+}, z.core.$strip>;
+export type RoofStructure = z.infer<typeof RoofStructure>;
+/** `truss-chords`: the ceiling hangs from the roof trusses' bottom chords, `size` deep. */
+export declare const CeilingFraming: z.ZodObject<{
+    system: z.ZodEnum<{
+        joists: "joists";
+        "truss-chords": "truss-chords";
+    }>;
+    size: z.ZodEnum<{
+        "2x10": "2x10";
+        "2x12": "2x12";
+        "2x4": "2x4";
+        "2x6": "2x6";
+        "2x8": "2x8";
+    }>;
+    spacing: z.ZodNumber;
+}, z.core.$strip>;
+export type CeilingFraming = z.infer<typeof CeilingFraming>;
+/**
+ * A roof plane, outside in. Absent optional layers are none. The plane's
+ * `deckThickness` and `shingleThickness` derive from it (`roofBuildUpPatch`).
+ */
+export declare const RoofBuildUp: z.ZodObject<{
+    presetId: z.ZodOptional<z.ZodString>;
+    roofing: z.ZodObject<{
+        kind: z.ZodEnum<{
+            "architectural-shingle": "architectural-shingle";
+            "asphalt-3-tab": "asphalt-3-tab";
+            "clay-tile": "clay-tile";
+            "concrete-tile": "concrete-tile";
+            slate: "slate";
+            "standing-seam-metal": "standing-seam-metal";
+            "wood-shake": "wood-shake";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    underlayment: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "felt-15": "felt-15";
+            "felt-30": "felt-30";
+            "ice-and-water": "ice-and-water";
+            synthetic: "synthetic";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sheathing: z.ZodObject<{
+        kind: z.ZodEnum<{
+            osb: "osb";
+            plywood: "plywood";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    structure: z.ZodObject<{
+        system: z.ZodEnum<{
+            rafters: "rafters";
+            trusses: "trusses";
+        }>;
+        size: z.ZodEnum<{
+            "2x10": "2x10";
+            "2x12": "2x12";
+            "2x4": "2x4";
+            "2x6": "2x6";
+            "2x8": "2x8";
+        }>;
+        spacing: z.ZodNumber;
+    }, z.core.$strip>;
+    insulation: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            batt: "batt";
+            blown: "blown";
+            rigid: "rigid";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    finish: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            drywall: "drywall";
+            plaster: "plaster";
+            "wood-plank": "wood-plank";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RoofBuildUp = z.infer<typeof RoofBuildUp>;
+/**
+ * A ceiling, bottom up from its stored height (the finished underside).
+ * Absent layers are none.
+ */
+export declare const CeilingBuildUp: z.ZodObject<{
+    presetId: z.ZodOptional<z.ZodString>;
+    finish: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            drywall: "drywall";
+            plaster: "plaster";
+            "wood-plank": "wood-plank";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    framing: z.ZodOptional<z.ZodObject<{
+        system: z.ZodEnum<{
+            joists: "joists";
+            "truss-chords": "truss-chords";
+        }>;
+        size: z.ZodEnum<{
+            "2x10": "2x10";
+            "2x12": "2x12";
+            "2x4": "2x4";
+            "2x6": "2x6";
+            "2x8": "2x8";
+        }>;
+        spacing: z.ZodNumber;
+    }, z.core.$strip>>;
+    decking: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            osb: "osb";
+            plywood: "plywood";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    insulation: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            batt: "batt";
+            blown: "blown";
+            rigid: "rigid";
+        }>;
+        thickness: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CeilingBuildUp = z.infer<typeof CeilingBuildUp>;
+//# sourceMappingURL=build-up.d.ts.map

package/dist/schema/build-up.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-up.d.ts","sourceRoot":"","sources":["../../src/schema/build-up.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAcvB,wEAAwE;AACxE,eAAO,MAAM,aAAa;;;;;;EAAgD,CAAA;AAC1E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEzD,eAAO,MAAM,WAAW;;;;;;;;EAQtB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,gBAAgB;;;;;EAA+D,CAAA;AAC5F,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,2DAA2D;AAC3D,eAAO,MAAM,SAAS;;;EAA6B,CAAA;AACnD,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD,4FAA4F;AAC5F,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,kBAAkB;;;;EAA+C,CAAA;AAC9E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;;iBAAyE,CAAA;AAClG,eAAO,MAAM,iBAAiB;;;;;;;;;iBAI5B,CAAA;AACF,eAAO,MAAM,UAAU;;;;;;;iBAAuE,CAAA;AAC9F,eAAO,MAAM,eAAe;;;;;;;;iBAI1B,CAAA;AACF,eAAO,MAAM,mBAAmB;;;;;;;;iBAI9B,CAAA;AAEF,qFAAqF;AACrF,eAAO,MAAM,aAAa;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEzD,2FAA2F;AAC3F,eAAO,MAAM,cAAc;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAStB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOzB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA"}

package/dist/schema/build-up.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+/**
+ * Typed layer build-ups for roof planes and ceilings: each layer is a product
+ * choice (a roofing, a sheathing, a framing size at a spacing) rather than an
+ * F2 layer list, so framing tools read the structure they frame and the
+ * inspector edits choices, not strings. Thicknesses are metres; spacings are
+ * metres on centre.
+ */
+const Thickness = z.number().finite().nonnegative();
+/** What the person calls a layer's material where the kind's own name won't do ("Brazilian cherry"). */
+const LayerName = z.string().trim().min(1).max(60).optional();
+/** Nominal dimensional lumber, by its actual depth (`LUMBER_DEPTH`). */
+export const NominalLumber = z.enum(['2x4', '2x6', '2x8', '2x10', '2x12']);
+export const RoofingKind = z.enum([
+    'asphalt-3-tab',
+    'architectural-shingle',
+    'standing-seam-metal',
+    'concrete-tile',
+    'clay-tile',
+    'wood-shake',
+    'slate',
+]);
+export const UnderlaymentKind = z.enum(['felt-15', 'felt-30', 'synthetic', 'ice-and-water']);
+/** Structural panels: roof sheathing and attic decking. */
+export const PanelKind = z.enum(['osb', 'plywood']);
+/** Batt and blown fill the framing cavity; rigid board runs continuous over the framing. */
+export const InsulationKind = z.enum(['batt', 'blown', 'rigid']);
+export const InteriorFinishKind = z.enum(['drywall', 'plaster', 'wood-plank']);
+export const RoofingLayer = z.object({ kind: RoofingKind, thickness: Thickness, name: LayerName });
+export const UnderlaymentLayer = z.object({
+    kind: UnderlaymentKind,
+    thickness: Thickness,
+    name: LayerName,
+});
+export const PanelLayer = z.object({ kind: PanelKind, thickness: Thickness, name: LayerName });
+export const InsulationLayer = z.object({
+    kind: InsulationKind,
+    thickness: Thickness,
+    name: LayerName,
+});
+export const InteriorFinishLayer = z.object({
+    kind: InteriorFinishKind,
+    thickness: Thickness,
+    name: LayerName,
+});
+/** For trusses, `size` is the top chord: the depth the roof plane's deck carries. */
+export const RoofStructure = z.object({
+    system: z.enum(['rafters', 'trusses']),
+    size: NominalLumber,
+    spacing: z.number().finite().positive(),
+});
+/** `truss-chords`: the ceiling hangs from the roof trusses' bottom chords, `size` deep. */
+export const CeilingFraming = z.object({
+    system: z.enum(['joists', 'truss-chords']),
+    size: NominalLumber,
+    spacing: z.number().finite().positive(),
+});
+/**
+ * A roof plane, outside in. Absent optional layers are none. The plane's
+ * `deckThickness` and `shingleThickness` derive from it (`roofBuildUpPatch`).
+ */
+export const RoofBuildUp = z.object({
+    presetId: z.string().optional(),
+    roofing: RoofingLayer,
+    underlayment: UnderlaymentLayer.optional(),
+    sheathing: PanelLayer,
+    structure: RoofStructure,
+    insulation: InsulationLayer.optional(),
+    /** Under the structure, the room-facing face of a cathedral ceiling. */
+    finish: InteriorFinishLayer.optional(),
+});
+/**
+ * A ceiling, bottom up from its stored height (the finished underside).
+ * Absent layers are none.
+ */
+export const CeilingBuildUp = z.object({
+    presetId: z.string().optional(),
+    finish: InteriorFinishLayer.optional(),
+    framing: CeilingFraming.optional(),
+    /** Over the framing, for attic storage. */
+    decking: PanelLayer.optional(),
+    insulation: InsulationLayer.optional(),
+});

package/dist/schema/geometry-source.d.ts

@@ -15,6 +15,25 @@ export declare const GEOMETRY_SCRIPT_MIME_TYPES: {
     readonly bpy: 'text/x-python';
 };
 export declare const isGeometryScriptMimeType: (mimeType: string) => boolean;
+/**
+ * A spotlight's beam: where it points (in the object's frame), its full cone in degrees and how
+ * soft its edge is (0 a hard edge, 1 fully feathered).
+ */
+export declare const LightSpot: z.ZodObject<{
+    direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    angle: z.ZodNumber;
+    softness: z.ZodNumber;
+}, z.core.$strip>;
+export type LightSpot = z.infer<typeof LightSpot>;
+/**
+ * The soft halo drawn around a lamp itself, in the light's colour: its size across in metres and
+ * its strength. It shows more the darker the scene is.
+ */
+export declare const LightGlow: z.ZodObject<{
+    size: z.ZodNumber;
+    strength: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type LightGlow = z.infer<typeof LightGlow>;
 export declare const GeometryScriptParamValue: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
 export type GeometryScriptParamValue = z.infer<typeof GeometryScriptParamValue>;
 /** A control the script declares in `export const params`. */
@@ -34,6 +53,25 @@ export declare const GeometryScriptParamSpec: z.ZodObject<{
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type GeometryScriptParamSpec = z.infer<typeof GeometryScriptParamSpec>;
+/**
+ * What a build occupies in plan, height band by height band, for the usage checks (passages,
+ * pockets, clashes): `y0`..`y1` in the artifact's frame and the plan outlines (x, z) of
+ * everything it has in that band, traced from a conservative raster of its meshes, so an outline
+ * is never inside the build and at most `tolerance` metres outside it. Written by the compiler
+ * only when usage checks are on, so it is absent from older artifacts.
+ */
+export declare const GeometryShape: z.ZodObject<{
+    tolerance: z.ZodNumber;
+    bands: z.ZodArray<z.ZodObject<{
+        y0: z.ZodNumber;
+        y1: z.ZodNumber;
+        polygons: z.ZodArray<z.ZodObject<{
+            outer: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            holes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GeometryShape = z.infer<typeof GeometryShape>;
 /**
  * What the compiler read from the script's output, by naming convention:
  * `part:<id>` objects, `slot_<id>` materials, `anchor:<id>` empties, lights
@@ -94,6 +132,16 @@ export declare const GeometryArtifactManifest: z.ZodObject<{
         color: z.ZodString;
         intensity: z.ZodNumber;
         distance: z.ZodOptional<z.ZodNumber>;
+        spot: z.ZodOptional<z.ZodObject<{
+            direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            angle: z.ZodNumber;
+            softness: z.ZodNumber;
+        }, z.core.$strip>>;
+        shadows: z.ZodOptional<z.ZodBoolean>;
+        glow: z.ZodOptional<z.ZodObject<{
+            size: z.ZodNumber;
+            strength: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
         part: z.ZodOptional<z.ZodString>;
@@ -117,6 +165,17 @@ export declare const GeometryArtifactManifest: z.ZodObject<{
     }, z.core.$strip>>>;
     cutout: z.ZodDefault<z.ZodBoolean>;
     collider: z.ZodDefault<z.ZodBoolean>;
+    shape: z.ZodOptional<z.ZodObject<{
+        tolerance: z.ZodNumber;
+        bands: z.ZodArray<z.ZodObject<{
+            y0: z.ZodNumber;
+            y1: z.ZodNumber;
+            polygons: z.ZodArray<z.ZodObject<{
+                outer: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                holes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     triangles: z.ZodNumber;
     coverage: z.ZodOptional<z.ZodNumber>;
     uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -220,6 +279,16 @@ export declare const GeometryScriptSource: z.ZodObject<{
             color: z.ZodString;
             intensity: z.ZodNumber;
             distance: z.ZodOptional<z.ZodNumber>;
+            spot: z.ZodOptional<z.ZodObject<{
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                angle: z.ZodNumber;
+                softness: z.ZodNumber;
+            }, z.core.$strip>>;
+            shadows: z.ZodOptional<z.ZodBoolean>;
+            glow: z.ZodOptional<z.ZodObject<{
+                size: z.ZodNumber;
+                strength: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>;
         undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
             part: z.ZodOptional<z.ZodString>;
@@ -243,6 +312,17 @@ export declare const GeometryScriptSource: z.ZodObject<{
         }, z.core.$strip>>>;
         cutout: z.ZodDefault<z.ZodBoolean>;
         collider: z.ZodDefault<z.ZodBoolean>;
+        shape: z.ZodOptional<z.ZodObject<{
+            tolerance: z.ZodNumber;
+            bands: z.ZodArray<z.ZodObject<{
+                y0: z.ZodNumber;
+                y1: z.ZodNumber;
+                polygons: z.ZodArray<z.ZodObject<{
+                    outer: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                    holes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
         triangles: z.ZodNumber;
         coverage: z.ZodOptional<z.ZodNumber>;
         uncovered: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/schema/geometry-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry-source.d.ts","sourceRoot":"","sources":["../../src/schema/geometry-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB,QAAY,CAAA;AAClD,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,QAAY,CAAA;AAEpD,2GAA2G;AAC3G,eAAO,MAAM,sBAAsB;;;EAA2B,CAAA;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,kEAAkE;AAClE,eAAO,MAAM,0BAA0B;oBAC9B,iBAAiB;kBACnB,eAAe;CACqC,CAAA;AAE3D,eAAO,MAAM,wBAAwB,aAAc,MAAM,YACoB,CAAA;AAK7E,eAAO,MAAM,wBAAwB,+DAA6C,CAAA;AAClF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAUlC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+FnC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;EAAoD,CAAA;AACpF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,gHAAgH;AAChH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yBAAyB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,sBAAsB,CAAA;IAChC,KAAK,EAAE,mBAAmB,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;IAChD,QAAQ,EAAE,wBAAwB,CAAA;CACnC,CAAA;AAID;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"geometry-source.d.ts","sourceRoot":"","sources":["../../src/schema/geometry-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,8EAA8E;AAC9E,eAAO,MAAM,yBAAyB,QAAY,CAAA;AAClD,+EAA+E;AAC/E,eAAO,MAAM,2BAA2B,QAAY,CAAA;AAEpD,2GAA2G;AAC3G,eAAO,MAAM,sBAAsB;;;EAA2B,CAAA;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,kEAAkE;AAClE,eAAO,MAAM,0BAA0B;oBAC9B,iBAAiB;kBACnB,eAAe;CACqC,CAAA;AAE3D,eAAO,MAAM,wBAAwB,aAAc,MAAM,YACoB,CAAA;AAK7E;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;iBAIpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD;;;GAGG;AACH,eAAO,MAAM,SAAS;;;iBAGpB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEjD,eAAO,MAAM,wBAAwB,+DAA6C,CAAA;AAClF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAUlC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAK7E;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;iBASxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmGnC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,mBAAmB;;;;;EAAoD,CAAA;AACpF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,gHAAgH;AAChH,MAAM,MAAM,sBAAsB,GAAG;IACnC,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,yBAAyB;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,sBAAsB,CAAA;IAChC,KAAK,EAAE,mBAAmB,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;IAChD,QAAQ,EAAE,wBAAwB,CAAA;CACnC,CAAA;AAID;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/schema/geometry-source.js

@@ -14,6 +14,23 @@ export const GEOMETRY_SCRIPT_MIME_TYPES = {
 export const isGeometryScriptMimeType = (mimeType) => Object.values(GEOMETRY_SCRIPT_MIME_TYPES).some((type) => type === mimeType);
 const finite = z.number().finite();
 const vec3 = z.tuple([finite, finite, finite]);
+/**
+ * A spotlight's beam: where it points (in the object's frame), its full cone in degrees and how
+ * soft its edge is (0 a hard edge, 1 fully feathered).
+ */
+export const LightSpot = z.object({
+    direction: vec3.refine((v) => Math.hypot(...v) > 1e-6, 'A spot needs a direction'),
+    angle: z.number().min(1).max(179),
+    softness: z.number().min(0).max(1),
+});
+/**
+ * The soft halo drawn around a lamp itself, in the light's colour: its size across in metres and
+ * its strength. It shows more the darker the scene is.
+ */
+export const LightGlow = z.object({
+    size: z.number().positive().max(5),
+    strength: z.number().nonnegative().max(10).default(1),
+});
 export const GeometryScriptParamValue = z.union([finite, z.boolean(), z.string()]);
 /** A control the script declares in `export const params`. */
 export const GeometryScriptParamSpec = z.object({
@@ -27,6 +44,23 @@ export const GeometryScriptParamSpec = z.object({
     unit: z.string().optional(),
     options: z.array(z.string()).optional(),
 });
+const planPoint = z.tuple([finite, finite]);
+const planRing = z.array(planPoint).min(3);
+/**
+ * What a build occupies in plan, height band by height band, for the usage checks (passages,
+ * pockets, clashes): `y0`..`y1` in the artifact's frame and the plan outlines (x, z) of
+ * everything it has in that band, traced from a conservative raster of its meshes, so an outline
+ * is never inside the build and at most `tolerance` metres outside it. Written by the compiler
+ * only when usage checks are on, so it is absent from older artifacts.
+ */
+export const GeometryShape = z.object({
+    tolerance: finite,
+    bands: z.array(z.object({
+        y0: finite,
+        y1: finite,
+        polygons: z.array(z.object({ outer: planRing, holes: z.array(planRing).optional() })),
+    })),
+});
 /**
  * What the compiler read from the script's output, by naming convention:
  * `part:<id>` objects, `slot_<id>` materials, `anchor:<id>` empties, lights
@@ -74,6 +108,9 @@ export const GeometryArtifactManifest = z.object({
         color: z.string(),
         intensity: finite,
         distance: finite.optional(),
+        spot: LightSpot.optional(),
+        shadows: z.boolean().optional(),
+        glow: LightGlow.optional(),
     }))
         .default([]),
     /**
@@ -101,6 +138,7 @@ export const GeometryArtifactManifest = z.object({
         .optional(),
     cutout: z.boolean().default(false),
     collider: z.boolean().default(false),
+    shape: GeometryShape.optional(),
     triangles: z.number().int().nonnegative(),
     /**
      * Built for a room's floor or a wall face: the share of it (less its holes) the build covers,

package/dist/schema/index.d.ts

@@ -1,29 +1,31 @@
 export { ProceduralItemNode } from '../procedural-items/node.js';
 export { SOLAR_PANEL_PRESET_LABELS, SOLAR_PANEL_PRESETS, type SolarPanelPresetDims, SolarPanelPresetKey, } from '../solar-panel-presets.js';
 export { Assembly, AssemblyLayer, AssemblyLayerId, LayerRole } from './assembly.js';
-export { ALLOWED_ORIGINS_ENV, ALLOWED_SCHEMES, AssetUrl } from './asset-url.js';
+export { __resetAllowedOriginsCacheForTests, ALLOWED_ORIGINS_ENV, ALLOWED_SCHEMES, type AllowedOriginIssue, AssetUrl, allowedOriginsFrom, parseAllowedOrigins, } from './asset-url.js';
 export { BaseNode, generateId, Material, nodeType, objectId } from './base.js';
+export { CeilingBuildUp, CeilingFraming, InsulationKind, InsulationLayer, InteriorFinishKind, InteriorFinishLayer, NominalLumber, PanelKind, PanelLayer, RoofBuildUp, RoofingKind, RoofingLayer, RoofStructure, UnderlaymentKind, UnderlaymentLayer, } from './build-up.js';
 export { CameraSchema } from './camera.js';
 export { COLLECTION_TEMPLATE_IDS, COLLECTION_TEMPLATES, type CollectionTemplateId, } from './collection-templates.js';
 export { type Collection, type CollectionId, generateCollectionId } from './collections.js';
 export { compiledNodeParsersEnabled, enableCompiledNodeParsers, parseNode, } from './compiled-node-parsers.js';
 export { CutIntent, CutShape } from './cut.js';
 export { GeometryArtifactMetadata, GeometryReuseFields, GeometrySourceMeta, } from './geometry-metadata.js';
-export { type CompiledGeometryScript, GEOMETRY_MANIFEST_MAX_BYTES, GEOMETRY_SCRIPT_MAX_BYTES, GEOMETRY_SCRIPT_MIME_TYPES, GeometryArtifactManifest, GeometryScriptLanguage, GeometryScriptMount, GeometryScriptParamSpec, GeometryScriptParamValue, GeometryScriptSource, isGeometryScriptMimeType, } from './geometry-source.js';
+export { type CompiledGeometryScript, GEOMETRY_MANIFEST_MAX_BYTES, GEOMETRY_SCRIPT_MAX_BYTES, GEOMETRY_SCRIPT_MIME_TYPES, GeometryArtifactManifest, GeometryScriptLanguage, GeometryScriptMount, GeometryScriptParamSpec, GeometryScriptParamValue, GeometryScriptSource, GeometryShape, isGeometryScriptMimeType, LightGlow, LightSpot, } from './geometry-source.js';
 export type { MaterialMapProperties, MaterialMaps, MaterialPresetPayload, MaterialTarget as MaterialTargetValue, TextureWrapMode as TextureWrapModeValue, } from './material.js';
 export { DEFAULT_MATERIALS, MaterialMapPropertiesSchema, MaterialMapsSchema, MaterialPreset, MaterialPresetPayloadSchema, MaterialProperties, MaterialSchema, MaterialTarget, resolveMaterial, TextureWrapMode, } from './material.js';
 export { type AutoDownspoutPlacement, type AutomaticDownspoutInput, planAutomaticDownspouts, resolveAutomaticDownspoutLength, } from './nodes/automatic-downspout.js';
+export { BEAM_SIZE_PRESETS, BeamMaterial, BeamNode, BeamPlacement, type BeamSizePreset, type BeamSizePresetId, DEFAULT_BEAM_SIZE_PRESET_ID, } from './nodes/beam.js';
 export { BlockEdge, BlockFace, type BlockFaceFrame, BlockNode, BlockTopology, type BlockTopologyIssue, BlockVertex, blockUndirectedEdgeKey, createBoxBlockTopology, getBlockFaceCentroid, getBlockFaceFrame, getBlockFaceNormal, inspectBlockTopology, } from './nodes/block.js';
 export { BoxVentMaterialRole, BoxVentNode } from './nodes/box-vent.js';
 export { BuildingNode } from './nodes/building.js';
 export { CABINET_METRIC_DEFAULTS, CabinetFrontStyleSchema, CabinetModuleNode, CabinetNode, CabinetTopFinishSchema, } from './nodes/cabinet.js';
 export { CeilingNode } from './nodes/ceiling.js';
 export { ChimneyMaterialRole, ChimneyNode } from './nodes/chimney.js';
-export { COLUMN_PRESETS, ColumnBaseStyle, ColumnCapitalStyle, ColumnCarvingPlacement, ColumnCrossSection, ColumnNode, ColumnPanelShape, type ColumnPresetId, ColumnRingPlacement, ColumnShaftDetail, ColumnShaftProfile, ColumnStyle, ColumnSupportStyle, } from './nodes/column.js';
+export { COLUMN_PRESETS, ColumnBaseStyle, ColumnCapitalStyle, ColumnCarvingPlacement, ColumnCrossSection, ColumnNode, ColumnPanelShape, ColumnPostBase, type ColumnPresetId, ColumnRingPlacement, ColumnShaftDetail, ColumnShaftProfile, ColumnStyle, ColumnSupportStyle, } from './nodes/column.js';
 export { CONSTRUCTION_DRAWING_TYPES, ConstructionDimensionBaseline, ConstructionDimensionChainMode, ConstructionDimensionDatumPolicy, ConstructionDimensionDrawingOverride, ConstructionDimensionDrawingPresentation, ConstructionDimensionImperialPrecision, ConstructionDimensionMetricNotation, ConstructionDimensionMode, ConstructionDimensionNode, ConstructionDimensionTerminator, ConstructionDimensionTextPosition, ConstructionDrawingType, constructionDimensionRequiredAnchorCount, resolveConstructionDimensionDrawingOverride, resolveConstructionDimensionDrawingPresentation, setConstructionDimensionDrawingPresentation, setConstructionDimensionDrawingSuppressedSegments, } from './nodes/construction-dimension.js';
 export { CupolaMaterialRole, CupolaNode } from './nodes/cupola.js';
 export { CurtainGrid, CurtainPanelType, CurtainWallConfig, curtainGridPositions, DEFAULT_CURTAIN_WALL, getCurtainWallConfig, } from './nodes/curtain-wall.js';
-export { DoorNode, DoorSegment, FRENCH_DOOR_SEGMENTS, OpeningConstructionType, OpeningDimensionReference, } from './nodes/door.js';
+export { DoorHandleStyle, DoorNode, DoorSegment, doorHandleStyle, FRENCH_DOOR_SEGMENTS, OpeningConstructionType, OpeningDimensionReference, } from './nodes/door.js';
 export { createDormerDefaultWindow, DormerNode, type DormerSurfaceMaterialRole, type DormerSurfaceMaterialSpec, DormerWallFace, dormerPointToWallFace, dormerWallFacePointToDormer, getDormerDefaultWindowFace, getDormerExposedFaces, getDormerWallFaceFrame, getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, getDormerWallVerticalBounds, getEffectiveDormerSurfaceMaterial, } from './nodes/dormer.js';
 export { DownspoutNode, defaultDownspoutMetadata, isDefaultDownspoutNode, usesAutomaticDownspoutLength, } from './nodes/downspout.js';
 export { DuctFittingNode } from './nodes/duct-fitting.js';
@@ -48,12 +50,13 @@ export { AngleMeasurement, AreaMeasurement, DistanceMeasurement, MeasurementAnch
 export { PipeFittingNode } from './nodes/pipe-fitting.js';
 export { PipeSegmentNode } from './nodes/pipe-segment.js';
 export { PipeTrapNode } from './nodes/pipe-trap.js';
+export { DEFAULT_RAILING_WALL, getRailingWallConfig, getRailingWallHeight, isRailingWall, RAILING_GUARD_HEIGHT, RAILING_GUARD_HEIGHT_TALL, RAILING_MAX_POST_SPACING, RAILING_SPHERE_LIMIT, RAILING_STYLE_DEFAULTS, RailingWallConfig, type RailingWallPatch, type RailingWallSlotId, RailingWallStyle, railingOpeningFields, railingWallDefaults, railingWallSlotDefault, } from './nodes/railing-wall.js';
 export { createDefaultRidgeVentsForSegment, getRidgeVentLinesForSegment, hasAutoRidgeVentMetadata, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, type RidgeVentLine, RidgeVentNode, } from './nodes/ridge-vent.js';
 export type { RoofSupport, RoofSurfaceMaterialRole, RoofSurfaceMaterialSpec } from './nodes/roof.js';
 export { getEffectiveRoofSurfaceMaterial, RoofNode } from './nodes/roof.js';
 export { clipGlazedRoofPolygon, DEFAULT_ROOF_GLAZING, type GlazedRoofFace, type GlazedRoofLayout, type GlazedRoofPiece, type GlazedRoofPoint, getBarrelRoofFaces, getBarrelRoofSolidPieces, getGlazedRoofFaces, getGlazedRoofLayout, getGlazedRoofPanelType, getGlazedRoofPieceFaces, getGlazedRoofPieces, getGlazedRoofPlanLines, getRoofGlazing, glazedRoofFacePoint, glazedRoofSupportsPoint, insetGlazedRoofPolygon, isGlazedRoofSegment, isIndependentRoofSegment, RoofGlazing, RoofSystemType, supportsRoofGlazing, } from './nodes/roof-glazing.js';
-export type { DutchRoofMetrics, RoofSegmentSurfaceMaterialRole, RoofSegmentSurfaceMaterialSpec, RoofSegmentVisibleTopBounds, SegmentSlopeFrame, } from './nodes/roof-segment.js';
-export { getActiveRoofHeight, getConicalRoofCoverage, getDutchRoofMetrics, getEffectiveSegmentSurfaceMaterial, getPitchFromActiveRoofHeight, getRoofSegmentDeckReach, getRoofSegmentEndReach, getRoofSegmentSurfaceY, getRoofSegmentVisibleTopBounds, getSegmentFasciaMaterial, getSegmentSlopeFrame, hasSegmentMaterialOverride, isBandedShedSegment, MIN_ROOF_SEGMENT_TRIM_SPAN, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, RoofSegmentNode, RoofSegmentTrim, RoofType, roofTypeHasRakes, } from './nodes/roof-segment.js';
+export type { DutchRoofMetrics, RoofSegmentSurfaceMaterialRole, RoofSegmentSurfaceMaterialSpec, RoofSegmentVisibleTopBounds, RoofWallBand, SegmentSlopeFrame, } from './nodes/roof-segment.js';
+export { getActiveRoofHeight, getConicalRoofCoverage, getDutchRoofMetrics, getEffectiveSegmentSurfaceMaterial, getPitchFromActiveRoofHeight, getRoofSegmentDeckReach, getRoofSegmentEndReach, getRoofSegmentSurfaceY, getRoofSegmentVisibleTopBounds, getRoofWallBandMaterial, getSegmentFasciaMaterial, getSegmentSlopeFrame, hasSegmentMaterialOverride, isBandedShedSegment, MIN_ROOF_SEGMENT_TRIM_SPAN, normalizeRoofSegmentTrim, ROOF_SHAPE_DEFAULTS, ROOF_WALL_BANDS, RoofEaveCut, RoofSegmentNode, RoofSegmentTrim, RoofType, roofTypeHasRakes, roofWallBandFields, } from './nodes/roof-segment.js';
 export { getRoofSegmentResizePatch } from './nodes/roof-segment-resize.js';
 export type { DutchRoofShapeMetrics, RoofShapeEaveSide, RoofShapeFaceVertex, RoofShapeInsets, RoofShapeRatios, } from './nodes/roof-segment-shape.js';
 export { getDutchEndSlopeFaces, getDutchRoofShapeMetrics, getRoofModuleFaces, getRoofShapeEaveOverhang, getRoofShapeEaveSides, getRoofShapeInsets, getRoofShapeRatios, } from './nodes/roof-segment-shape.js';
@@ -72,13 +75,14 @@ export type { StairSurfaceMaterialRole, StairSurfaceMaterialSpec } from './nodes
 export { getEffectiveStairSurfaceMaterial, StairDesignTargets, StairNode, StairRailingMode, StairRailingStyle, StairSlabOpeningMode, StairTopLandingMode, StairType, } from './nodes/stair.js';
 export { StairConstruction } from './nodes/stair-construction.js';
 export { AttachmentSide, StairSegmentNode, StairSegmentType } from './nodes/stair-segment.js';
+export { STAIR_STRINGER_SPACINGS_IN, StairStringerStock, StairStringerType, StairStructure, StairStructureType, StairTreadStock, } from './nodes/stair-structure.js';
 export { StructuralGridNode } from './nodes/structural-grid.js';
 export { SurfaceHoleMetadata } from './nodes/surface-hole-metadata.js';
 export { SurfacePaintRegion } from './nodes/surface-paint-region.js';
 export { TurbineVentMaterialRole, TurbineVentNode } from './nodes/turbine-vent.js';
 export { DEFAULT_UNIT_COLOR, UNIT_KINDS, type UnitKind, UnitNode } from './nodes/unit.js';
 export type { WallFace, WallSurfaceMaterialSpec, WallSurfaceSide, WallSurfaceSlotId, WallTrimConfig, WallTrimKind, WallTrimSlotId, } from './nodes/wall.js';
-export { getEffectiveWallFaceMaterial, getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, getWallTrimFaces, getWallTrimSlotId, WALL_CHAIR_RAIL_DEFAULT, WALL_CHAIR_RAIL_SLOT_DEFAULT, WALL_CROWN_DEFAULT, WALL_CROWN_SLOT_DEFAULT, WALL_FACE_REGION_LIMIT, WALL_SKIRTING_DEFAULT, WALL_SKIRTING_SLOT_DEFAULT, WALL_SLOT_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, WALL_TRIM_DEFAULTS, WallAssembly, WallAssemblyExteriorFinish, WallAssemblyFramingKind, WallAssemblyInteriorFinish, WallAssemblySheathingMaterial, WallFaceRegion, WallFaceScript, WallNode, WallTreatmentSide, WallTrimProfile, } from './nodes/wall.js';
+export { DEFAULT_EXTERIOR_WALL_FINISH, DEFAULT_INTERIOR_WALL_PAINT, getEffectiveWallFaceMaterial, getEffectiveWallSurfaceMaterial, getWallFaceDefault, getWallSurfaceMaterialSignature, getWallTrimFaces, getWallTrimSlotId, WALL_CHAIR_RAIL_DEFAULT, WALL_CHAIR_RAIL_SLOT_DEFAULT, WALL_CROWN_DEFAULT, WALL_CROWN_SLOT_DEFAULT, WALL_FACE_REGION_LIMIT, WALL_SKIRTING_DEFAULT, WALL_SKIRTING_SLOT_DEFAULT, WALL_SLOT_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, WALL_TRIM_DEFAULTS, WallAssembly, WallAssemblyExteriorFinish, WallAssemblyFramingKind, WallAssemblyInteriorFinish, WallAssemblySheathingMaterial, WallFaceRegion, WallFaceScript, WallNode, WallTreatmentSide, WallTrimProfile, } from './nodes/wall.js';
 export { WindowConstructionType, WindowDimensionReference, WindowNode, WindowType, } from './nodes/window.js';
 export { ZoneFloorScript, ZoneNode } from './nodes/zone.js';
 export { PROVENANCE_MAX_ID_BYTES, PROVENANCE_MAX_LINEAGE_IDS, PROVENANCE_MAX_NAMESPACE_BYTES, PROVENANCE_MAX_NODE_ID_BYTES, PROVENANCE_MAX_REFS, Provenance, ProvenanceLineage, ProvenanceLineageOp, ProvenanceRef, ProvenanceRole, } from './provenance.js';
@@ -87,4 +91,5 @@ export { type ParsedSourceRef, parseSourceRef, SourceRefString } from './source-
 export { MAX_TERRAIN_SIDE, TerrainData } from './terrain.js';
 export type { Anchor, AnchorPolicy, AnyNodeId, AnyNodeOption, AnyNodeType, DefinitionPin, Discipline, DisplayFamily, DisplayMode, EndCut, FidelityV2, FidelityV3, FitTarget, MaterialPattern, MaterialPatternType, Mount, MountAlign, MountHost, PartKey, ResolvedSectionProfile, SectionFamily, SectionLibraryEntry, SectionProfile, SitePresentation, SurfaceAnchor, SurfacePatchId, SweepEndSpec, WallMountDatum, } from './types.js';
 export { AnyNode, nodeKindOf } from './types.js';
+export { CUSTOM_WALL_TYPE_PREFIX, newWallTypeId, WallTypeDefinition, WallTypeDefinitionId, } from './wall-type.js';
 //# sourceMappingURL=index.d.ts.map