@pascal-app/core 1.0.1 → 1.0.4

package/dist/schema/nodes/wall.js

@@ -1,12 +1,18 @@
 import dedent from 'dedent';
 import { z } from 'zod';
+import { Assembly } from '../assembly.js';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
+import { CurtainWallConfig } from './curtain-wall.js';
 import { DoorNode } from './door.js';
 import { ItemNode } from './item.js';
 import { LeanToExtensionNode } from './lean-to-extension.js';
 import { WindowNode } from './window.js';
-export const WallTreatmentSide = z.enum(['interior', 'exterior', 'both']);
+// Geometric faces: `a` is left of start → end, `b` is right (wall-frame convention).
+// `interior` / `exterior` are legacy semantic values the M1 load migration maps
+// onto a face; a runtime writer that still sends one renders on its canonical
+// face (interior → a, exterior → b).
+export const WallTreatmentSide = z.enum(['a', 'b', 'both', 'interior', 'exterior']);
 export const WallTrimProfile = z.enum([
     'flat',
     'bevel',
@@ -61,57 +67,133 @@ export const WALL_TRIM_DEFAULTS = {
     crown: WALL_CROWN_DEFAULT,
     chairRail: WALL_CHAIR_RAIL_DEFAULT,
 };
-const WallFaceBandConfigShape = z.object({
-    enabled: z.boolean().default(false),
-    count: z.number().int().min(1).max(4).default(1),
-    lowerHeight: z.number().default(0.84),
-    middleHeight: z.number().default(0.61),
-    upperHeight: z.number().default(0.61),
-});
-export const WallFaceBandConfig = z.preprocess((value) => {
-    if (value && typeof value === 'object' && !Array.isArray(value) && !('count' in value)) {
-        const enabled = value.enabled === true;
-        return { ...value, count: enabled ? 3 : 1 };
-    }
-    return value;
-}, WallFaceBandConfigShape);
-export const WALL_FACE_BAND_DEFAULT = {
-    enabled: false,
-    count: 1,
-    lowerHeight: 0.84,
-    middleHeight: 0.61,
-    upperHeight: 0.61,
-};
 export const WALL_SKIRTING_SLOT_DEFAULT = 'library:preset-softwhite';
 export const WALL_CROWN_SLOT_DEFAULT = 'library:preset-white';
 export const WALL_CHAIR_RAIL_SLOT_DEFAULT = 'library:preset-cream';
-export const WALL_FACE_BAND_SOLID_SLOT_DEFAULTS = {
-    lower: 'library:preset-white',
-    middle: 'library:preset-lightgrey',
-    upper: 'library:preset-greige',
-    top: 'library:preset-softwhite',
-};
 export const WALL_SURFACE_SLOT_DEFAULTS = {
-    interior: 'library:concrete-drywall',
-    exterior: 'library:concrete-drywall',
-    lowerInterior: 'library:concrete-drywall',
-    middleInterior: 'library:concrete-drywall',
-    upperInterior: 'library:concrete-drywall',
-    topInterior: 'library:concrete-drywall',
-    lowerExterior: 'library:concrete-drywall',
-    middleExterior: 'library:concrete-drywall',
-    upperExterior: 'library:concrete-drywall',
-    topExterior: 'library:concrete-drywall',
-    skirtingInterior: WALL_SKIRTING_SLOT_DEFAULT,
-    skirtingExterior: WALL_SKIRTING_SLOT_DEFAULT,
-    crownInterior: WALL_CROWN_SLOT_DEFAULT,
-    crownExterior: WALL_CROWN_SLOT_DEFAULT,
-    chairRailInterior: WALL_CHAIR_RAIL_SLOT_DEFAULT,
-    chairRailExterior: WALL_CHAIR_RAIL_SLOT_DEFAULT,
+    a: 'library:concrete-drywall',
+    b: 'library:concrete-drywall',
+    aSkirting: WALL_SKIRTING_SLOT_DEFAULT,
+    bSkirting: WALL_SKIRTING_SLOT_DEFAULT,
+    aCrown: WALL_CROWN_SLOT_DEFAULT,
+    bCrown: WALL_CROWN_SLOT_DEFAULT,
+    aChairRail: WALL_CHAIR_RAIL_SLOT_DEFAULT,
+    bChairRail: WALL_CHAIR_RAIL_SLOT_DEFAULT,
+    // The foundation under a wall's underpinning (see WallNode.underpinning):
+    // the concrete stemwall between the finish carried down over the floor
+    // platform and the ground.
+    foundation: 'library:concrete-raw',
 };
+export const WALL_FACE_REGION_LIMIT = 8;
+// A paint region overrides one face's finish inside a rectangle without cutting
+// the wall. `u` is metres from the wall start along the reference line (along
+// the chord for curved walls); `v` is metres above the face's own base. An
+// absent bound runs to that edge, so a wainscot stretches with the wall.
+export const WallFaceRegion = z.object({
+    id: z.string(),
+    face: z.enum(['a', 'b']),
+    u0: z.number().finite().optional(),
+    u1: z.number().finite().optional(),
+    v0: z.number().finite().optional(),
+    v1: z.number().finite().optional(),
+    finish: z.string(),
+});
+const WallSurfaceMaterialSpecSchema = z.object({
+    material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
+});
+/**
+ * What a wall carries BELOW its base on a house standing above the ground:
+ * `rim` metres of its exterior finish continued down over the floor
+ * platform's edge (subfloor, rim joist, mudsill), then the foundation —
+ * the concrete stemwall, painted through the `foundation` slot — `stem`
+ * metres more to the ground (with `fillToTerrain`, to the terrain wherever
+ * that is lower). The wall body, its top and its openings are unchanged,
+ * and the framers ignore it (a framing plugin pours its own stemwall
+ * from the building's foundation record). `openings` are the holes through the
+ * stem — a crawl space's vents and its access (IRC R408) — `u` metres
+ * along the wall from its start (the opening's centre), `top` and `bottom`
+ * in metres below the wall base.
+ */
+export const WallUnderpinningOpening = z.object({
+    u: z.number(),
+    width: z.number().positive(),
+    top: z.number().min(0),
+    bottom: z.number().min(0),
+});
+export const WallUnderpinning = z.object({
+    rim: z.number().min(0),
+    stem: z.number().min(0),
+    openings: z.array(WallUnderpinningOpening).optional(),
+});
+// ---------------------------------------------------------------------------
+// Wall assembly (WS5), legacy shape
+// ---------------------------------------------------------------------------
+// The four-slot stack #937 stored in `wall.assembly`. Walls now store F2
+// layers (`Assembly`, schema/assembly.ts); scenes saved with this shape are
+// converted on load (`migrateWallAssemblies`, `wallAssemblyFromLegacy`), and
+// the inspector edits F2 stacks through this view (`wallAssemblyToLegacy`).
+export const WallAssemblyExteriorFinish = z.enum([
+    'siding',
+    'stucco',
+    'brick',
+    'stone',
+    'fiber-cement',
+    'none',
+]);
+export const WallAssemblySheathingMaterial = z.enum(['osb', 'plywood', 'gypsum', 'none']);
+export const WallAssemblyFramingKind = z.enum(['wood', 'lgs', 'cmu', 'icf']);
+export const WallAssemblyInteriorFinish = z.enum(['drywall', 'plaster', 'none']);
+/** @deprecated The WS5 shape, kept for the load migration and the inspector view. */
+export const WallAssembly = z
+    .object({
+    /** Id of a `WALL_ASSEMBLY_PRESETS` entry this stack was seeded from. */
+    preset: z.string().optional(),
+    /** Outermost cladding. For `brick` the thickness INCLUDES the air space. */
+    exterior: z
+        .object({
+        finish: WallAssemblyExteriorFinish,
+        thickness: z.number().nonnegative(),
+    })
+        .optional(),
+    sheathing: z
+        .object({
+        material: WallAssemblySheathingMaterial,
+        thickness: z.number().nonnegative(),
+    })
+        .optional(),
+    /** The structural core. Always present — it is what makes a wall a wall. */
+    framing: z.object({
+        kind: WallAssemblyFramingKind,
+        depth: z.number().nonnegative(),
+    }),
+    interior: z
+        .object({
+        finish: WallAssemblyInteriorFinish,
+        thickness: z.number().nonnegative(),
+    })
+        .optional(),
+    /** Free-text cavity insulation note (e.g. 'R-21 batt'). No geometry. */
+    cavityInsulation: z.string().optional(),
+})
+    .describe(dedent `
+    Layered wall assembly, all thicknesses in metres, ordered outside -> inside:
+    exterior finish, sheathing, framing, interior finish.
+    - When present, this is the SINGLE SOURCE OF TRUTH for wall thickness:
+      wall.thickness MUST equal assemblyThickness(assembly) and is rewritten on
+      every assembly edit. Consumers keep reading wall.thickness as the total.
+    - A stack with neither exterior nor sheathing is a PARTITION: the interior
+      finish is applied to BOTH faces (total = 2 x interior + framing).
+    - Which face is exterior comes from wall.frontSide / wall.backSide;
+      frontSide is the +normal side, normal = perp(end - start).
+    - The weather-resistive barrier (IRC R703.2) is intentionally not modelled:
+      it is a film with no drawable thickness.
+    `);
 export const WallNode = BaseNode.extend({
     id: objectId('wall'),
     type: nodeType('wall'),
+    wallType: z.enum(['standard', 'curtain']).optional(),
+    curtainWall: CurtainWallConfig.optional(),
     children: z
         .array(z.union([
         ItemNode.shape.id,
@@ -130,13 +212,42 @@ export const WallNode = BaseNode.extend({
     exteriorMaterial: MaterialSchema.optional(),
     exteriorMaterialPreset: z.string().optional(),
     // Per-slot material overrides on the unified slot model, mirroring
-    // `SlabNode.slots`. Key = slot id (`interior` / `exterior`), value = a
-    // `MaterialRef` (`library:<id>` / `scene:<id>`). Absent = the declared slot
-    // default (`WALL_SLOT_DEFAULT`). The legacy `*Material*` fields above are
-    // read only by the load migration that moves them into `slots`; delete them
-    // in a follow-up once migrated scenes are the norm.
+    // `SlabNode.slots`. Key = geometric slot id (`a` / `b` faces, `aSkirting` …
+    // trims), value = a `MaterialRef` (`library:<id>` / `scene:<id>`). Absent =
+    // the declared slot default (`WALL_SLOT_DEFAULT`). Legacy `interior` /
+    // `exterior` keys are rewritten by the M1 load migration.
     slots: z.record(z.string(), z.string()).optional(),
+    // Legacy per-face inline finish, written only by the M1 load migration from
+    // `interiorMaterial*` / `exteriorMaterial*` so a face keeps the fallback it
+    // rendered with. Read after `slots[face]`, before `material` / `materialPreset`.
+    legacyFaceMaterials: z
+        .object({
+        a: WallSurfaceMaterialSpecSchema.optional(),
+        b: WallSurfaceMaterialSpecSchema.optional(),
+    })
+        .optional(),
+    // Later entries win; at most WALL_FACE_REGION_LIMIT per face.
+    faceRegions: z
+        .array(WallFaceRegion)
+        .superRefine((regions, ctx) => {
+        for (const face of ['a', 'b']) {
+            if (regions.filter((region) => region.face === face).length > WALL_FACE_REGION_LIMIT)
+                ctx.addIssue({
+                    code: 'custom',
+                    message: `At most ${WALL_FACE_REGION_LIMIT} paint regions per wall face`,
+                });
+        }
+    })
+        .optional(),
+    // TOTAL wall thickness in metres — the one number every consumer reads.
+    // The sum of `assembly`'s layers whenever an assembly is present.
     thickness: z.number().optional(),
+    // Layered construction stack (F2). Optional: absent = a single unspecified
+    // slab of `thickness`. Present = the stack sets `thickness`: edit the layers
+    // and write their sum (`wallAssemblyPatch`), never `thickness` alone.
+    assembly: Assembly.optional(),
+    // Absent centers the body; a/b place it left/right of the stored start → end line.
+    justification: z.enum(['a', 'b']).optional(),
     height: z.number().optional(),
     curveOffset: z.number().optional(),
     // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
@@ -147,21 +258,27 @@ export const WallNode = BaseNode.extend({
     // Extend downward from the authored wall base to the terrain while keeping
     // the wall body height and top unchanged.
     fillToTerrain: z.boolean().optional(),
-    faceBands: WallFaceBandConfig.optional(),
+    // The finish and the foundation carried below the base — see WallUnderpinning.
+    underpinning: WallUnderpinning.optional(),
     skirting: WallTrimConfig.optional(),
     crown: WallTrimConfig.optional(),
     chairRail: WallTrimConfig.optional(),
     // e.g., start/end points for path
     start: z.tuple([z.number(), z.number()]),
     end: z.tuple([z.number(), z.number()]),
-    // Space detection for cutaway mode
+    // Derived room classification per face, still written by the structure
+    // kernel for cutaway and dimension readers. Wall finishes never read it.
     frontSide: z.enum(['interior', 'exterior', 'unknown']).default('unknown'),
     backSide: z.enum(['interior', 'exterior', 'unknown']).default('unknown'),
 }).describe(dedent `
   Wall node - used to represent a wall in the building
-  - thickness: thickness in meters
+  - thickness: TOTAL thickness in meters (all assembly layers together)
+  - assembly: optional layered construction stack; when present it is the single
+    source of truth and thickness is re-derived from it on every edit
   - height: height in meters
   - fillToTerrain: extends the wall downward to the terrain without changing its authored height
+  - underpinning: { rim, stem } — the finish carried rim metres below the base over the floor
+    platform's edge, then stem metres of concrete stemwall to the ground (the foundation slot)
   - curveOffset: midpoint sagitta offset used to bend the wall into an arc
   - start: start point of the wall in level coordinate system
   - end: end point of the wall in level coordinate system
@@ -175,142 +292,19 @@ export const WallNode = BaseNode.extend({
 // May be a `#rrggbb` colour or a `library:<id>` ref. Textures-off still
 // collapses to the themed wall role (the escape hatch).
 export const WALL_SLOT_DEFAULT = {
-    interior: WALL_SURFACE_SLOT_DEFAULTS.interior,
-    exterior: WALL_SURFACE_SLOT_DEFAULTS.exterior,
-};
-export function getWallFaceBandConfig(wall, effectiveWallHeight) {
-    const wallHeight = Math.max(0, effectiveWallHeight);
-    const raw = { ...WALL_FACE_BAND_DEFAULT, ...(wall.faceBands ?? {}) };
-    const count = raw.enabled ? Math.max(1, Math.min(4, Math.round(raw.count ?? 3))) : 1;
-    const lowerHeight = count >= 2 ? Math.max(0, Math.min(wallHeight, raw.lowerHeight)) : 0;
-    const middleHeight = count >= 3 ? Math.max(0, Math.min(wallHeight - lowerHeight, raw.middleHeight)) : 0;
-    const upperHeight = count >= 4 ? Math.max(0, Math.min(wallHeight - lowerHeight - middleHeight, raw.upperHeight)) : 0;
-    return {
-        enabled: raw.enabled && count > 1,
-        count,
-        lowerHeight,
-        middleHeight,
-        upperHeight,
-        lowerTop: lowerHeight,
-        middleTop: lowerHeight + middleHeight,
-        upperTop: lowerHeight + middleHeight + upperHeight,
-    };
-}
-export function getWallFaceBandForHeight(wall, y, effectiveWallHeight) {
-    const bands = getWallFaceBandConfig(wall, effectiveWallHeight);
-    if (!bands.enabled)
-        return 'upper';
-    if (y < bands.lowerTop)
-        return 'lower';
-    if (y < bands.middleTop)
-        return 'middle';
-    if (bands.count >= 4 && y < bands.upperTop)
-        return 'upper';
-    if (bands.count >= 4)
-        return 'top';
-    return 'upper';
-}
-export function getWallBandSlotId(side, band) {
-    const suffix = side === 'interior' ? 'Interior' : 'Exterior';
-    return `${band}${suffix}`;
-}
-const WALL_FACE_BAND_SLOTS_BY_SIDE = {
-    interior: ['lowerInterior', 'middleInterior', 'upperInterior', 'topInterior'],
-    exterior: ['lowerExterior', 'middleExterior', 'upperExterior', 'topExterior'],
+    a: WALL_SURFACE_SLOT_DEFAULTS.a,
+    b: WALL_SURFACE_SLOT_DEFAULTS.b,
 };
-function getWallFaceBandSlotsForCount(side, count) {
-    if (count <= 1)
-        return [];
-    if (side === 'interior') {
-        if (count === 2)
-            return ['lowerInterior', 'upperInterior'];
-        if (count === 3)
-            return ['lowerInterior', 'middleInterior', 'upperInterior'];
-        return ['lowerInterior', 'middleInterior', 'upperInterior', 'topInterior'];
-    }
-    if (count === 2)
-        return ['lowerExterior', 'upperExterior'];
-    if (count === 3)
-        return ['lowerExterior', 'middleExterior', 'upperExterior'];
-    return ['lowerExterior', 'middleExterior', 'upperExterior', 'topExterior'];
+export function getWallTrimSlotId(face, kind) {
+    return `${face}${kind === 'skirting' ? 'Skirting' : kind === 'crown' ? 'Crown' : 'ChairRail'}`;
 }
-function getWallFaceBandDefaultSlot(slotId) {
-    if (slotId.startsWith('lower'))
-        return WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower;
-    if (slotId.startsWith('middle'))
-        return WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle;
-    if (slotId.startsWith('top'))
-        return WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.top;
-    return WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper;
-}
-function getWallFaceTopBandSlot(side, count) {
-    const slots = getWallFaceBandSlotsForCount(side, count);
-    return slots[slots.length - 1] ?? null;
-}
-export function buildWallFaceBandCountPatch(wall, count) {
-    const slots = { ...(wall.slots ?? {}) };
-    const nextCount = Math.max(1, Math.min(4, Math.round(count)));
-    const previousCount = wall.faceBands?.enabled
-        ? Math.max(1, Math.min(4, Math.round(wall.faceBands.count ?? 3)))
-        : 1;
-    for (const side of ['interior', 'exterior']) {
-        const nextSlots = getWallFaceBandSlotsForCount(side, nextCount);
-        const activeSlots = new Set(nextSlots);
-        const previouslyActiveSlots = new Set(getWallFaceBandSlotsForCount(side, previousCount));
-        const previousTopSlot = getWallFaceTopBandSlot(side, previousCount);
-        const nextTopSlot = getWallFaceTopBandSlot(side, nextCount);
-        const topMaterial = (previousTopSlot ? slots[previousTopSlot] : undefined) ??
-            slots[side] ??
-            WALL_SURFACE_SLOT_DEFAULTS[side];
-        for (const slotId of WALL_FACE_BAND_SLOTS_BY_SIDE[side]) {
-            if (activeSlots.has(slotId)) {
-                if (slotId === nextTopSlot) {
-                    slots[slotId] = topMaterial;
-                    continue;
-                }
-                const wasActive = previouslyActiveSlots.has(slotId);
-                const wasPreviousTop = slotId === previousTopSlot;
-                if (!wasActive || wasPreviousTop || !slots[slotId]) {
-                    slots[slotId] = getWallFaceBandDefaultSlot(slotId);
-                }
-            }
-            else {
-                delete slots[slotId];
-            }
-        }
-    }
-    return {
-        faceBands: {
-            ...WALL_FACE_BAND_DEFAULT,
-            ...(wall.faceBands ?? {}),
-            enabled: nextCount > 1,
-            count: nextCount,
-            lowerHeight: wall.faceBands?.lowerHeight ?? WALL_FACE_BAND_DEFAULT.lowerHeight,
-            middleHeight: wall.faceBands?.middleHeight ?? WALL_FACE_BAND_DEFAULT.middleHeight,
-            upperHeight: wall.faceBands?.upperHeight ?? WALL_FACE_BAND_DEFAULT.upperHeight,
-        },
-        slots,
-    };
-}
-export function buildEnabledWallFaceBandPatch(wall) {
-    return buildWallFaceBandCountPatch(wall, 2);
-}
-export function getWallSurfaceSideFromBandSlot(slotId) {
-    if (slotId === 'interior' || slotId === 'exterior')
-        return slotId;
-    if (slotId === 'lowerInterior' ||
-        slotId === 'middleInterior' ||
-        slotId === 'upperInterior' ||
-        slotId === 'topInterior') {
-        return 'interior';
-    }
-    if (slotId === 'lowerExterior' ||
-        slotId === 'middleExterior' ||
-        slotId === 'upperExterior' ||
-        slotId === 'topExterior') {
-        return 'exterior';
-    }
-    return null;
+/** Faces a trim config draws on. Legacy semantic values use their canonical face. */
+export function getWallTrimFaces(sides) {
+    if (sides === 'a' || sides === 'interior')
+        return ['a'];
+    if (sides === 'b' || sides === 'exterior')
+        return ['b'];
+    return ['a', 'b'];
 }
 function getConfiguredWallSurfaceMaterial(wall, side) {
     if (side === 'interior') {
@@ -337,6 +331,14 @@ export function getEffectiveWallSurfaceMaterial(wall, side) {
         materialPreset: wall.materialPreset,
     };
 }
+/** A face's legacy inline finish: its migrated per-face spec, else the wall-wide legacy fields. */
+export function getEffectiveWallFaceMaterial(wall, face) {
+    const configured = wall.legacyFaceMaterials?.[face];
+    if (configured && hasSurfaceMaterial(configured)) {
+        return { material: configured.material, materialPreset: configured.materialPreset };
+    }
+    return { material: wall.material, materialPreset: wall.materialPreset };
+}
 export function getWallSurfaceMaterialSignature(spec) {
     return JSON.stringify({
         material: spec.material ?? null,

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

@@ -1,20 +1,8 @@
 import { z } from 'zod';
-export declare const WindowType: z.ZodEnum<{
-    fixed: "fixed";
-    sliding: "sliding";
-    casement: "casement";
-    awning: "awning";
-    hopper: "hopper";
-    "single-hung": "single-hung";
-    "double-hung": "double-hung";
-    bay: "bay";
-    bow: "bow";
-    louvered: "louvered";
-}>;
-export type WindowType = z.infer<typeof WindowType>;
+export { WindowType } from './opening-types.js';
 export declare const WindowConstructionType: z.ZodEnum<{
-    framed: "framed";
     masonry: "masonry";
+    framed: "framed";
 }>;
 export declare const WindowDimensionReference: z.ZodEnum<{
     nominal: "nominal";
@@ -40,6 +28,32 @@ export declare const WindowNode: z.ZodObject<{
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`window_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"window">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -75,33 +89,138 @@ export declare const WindowNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"script">;
+        meta: z.ZodOptional<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            category: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            parent: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        language: z.ZodDefault<z.ZodEnum<{
+            three: "three";
+            bpy: "bpy";
+        }>>;
+        script: z.ZodString;
+        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+        artifact: z.ZodString;
+        manifest: z.ZodObject<{
+            bounds: z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>;
+            params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                kind: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                }>;
+                default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                step: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                bounds: z.ZodOptional<z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                part: z.ZodOptional<z.ZodString>;
+                y: z.ZodNumber;
+                polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>>>;
+            slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                roughness: z.ZodOptional<z.ZodNumber>;
+                metalness: z.ZodOptional<z.ZodNumber>;
+                transparent: z.ZodOptional<z.ZodBoolean>;
+                emissive: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>>>;
+            lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                color: z.ZodString;
+                intensity: z.ZodNumber;
+                distance: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                part: z.ZodOptional<z.ZodString>;
+                polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>>;
+            animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                duration: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                host: z.ZodEnum<{
+                    wall: "wall";
+                    slab: "slab";
+                    ceiling: "ceiling";
+                    mounted: "mounted";
+                }>;
+                polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+                minY: z.ZodNumber;
+                maxY: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cutout: z.ZodDefault<z.ZodBoolean>;
+            collider: z.ZodDefault<z.ZodBoolean>;
+            triangles: z.ZodNumber;
+        }, z.core.$strip>;
+        images: z.ZodOptional<z.ZodObject<{
+            artifact: z.ZodString;
+            thumbnail: z.ZodString;
+            floorPlan: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     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<{
         front: "front";
         back: "back";
     }>>;
+    verticalAnchor: z.ZodOptional<z.ZodEnum<{
+        wall: "wall";
+        floor: "floor";
+    }>>;
+    floorThresholdVersion: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
     wallId: z.ZodOptional<z.ZodString>;
     dormerId: z.ZodOptional<z.ZodString>;
     dormerFace: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
         front: "front";
         back: "back";
-        right: "right";
-        left: "left";
     }>>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
     roofFace: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
         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";
+        framed: "framed";
     }>>;
     dimensionReference: z.ZodDefault<z.ZodEnum<{
         nominal: "nominal";
@@ -141,8 +260,8 @@ export declare const WindowNode: z.ZodObject<{
         single: "single";
     }>>;
     hingesSide: z.ZodDefault<z.ZodEnum<{
-        right: "right";
         left: "left";
+        right: "right";
     }>>;
     openingShape: z.ZodDefault<z.ZodEnum<{
         rectangle: "rectangle";

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

@@ -1 +1 @@
-{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/window.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,sBAAsB;;;EAAgC,CAAA;AACnE,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuFrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/window.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,eAAO,MAAM,sBAAsB;;;EAAgC,CAAA;AACnE,eAAO,MAAM,wBAAwB;;;;;EAKnC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8FrB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}