@pascal-app/core 0.9.1 → 0.9.2

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

@@ -1 +1 @@
-{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/wall.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAK5C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,UAAU,CAAA;AAErD,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACzC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACzC,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,gBAAgB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACjD,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,gBAAgB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACjD,sBAAsB,CAAC,EAAE,MAAM,CAAA;CAChC,CAAA;AAuBD,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,eAAe,GACpB,uBAAuB,CAUzB;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAKrF"}
+{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/wall.ts"],"names":[],"mappings":"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"}

package/dist/schema/nodes/wall.js

@@ -5,6 +5,109 @@ import { MaterialSchema } from '../material';
 import { DoorNode } from './door';
 import { ItemNode } from './item';
 import { WindowNode } from './window';
+export const WallTreatmentSide = z.enum(['interior', 'exterior', 'both']);
+export const WallTrimProfile = z.enum([
+    'flat',
+    'bevel',
+    'triangle',
+    'cove',
+    'bullnose',
+    'base-modern',
+    'base-colonial',
+    'base-shoe',
+    'base-ogee',
+    'crown-cove',
+    'crown-ogee',
+    'crown-craftsman',
+    'crown-layered',
+    'rail-rounded',
+    'rail-ogee',
+    'rail-picture',
+    'rail-stepped',
+]);
+export const WallTrimConfig = z.object({
+    enabled: z.boolean().default(false),
+    sides: WallTreatmentSide.default('both'),
+    height: z.number().default(0.1),
+    proud: z.number().default(0.015),
+    profile: WallTrimProfile.default('flat'),
+    offsetY: z.number().optional(),
+});
+export const WALL_SKIRTING_DEFAULT = {
+    enabled: false,
+    sides: 'both',
+    height: 0.12,
+    proud: 0.02,
+    profile: 'flat',
+};
+export const WALL_CROWN_DEFAULT = {
+    enabled: false,
+    sides: 'both',
+    height: 0.12,
+    proud: 0.055,
+    profile: 'flat',
+};
+export const WALL_CHAIR_RAIL_DEFAULT = {
+    enabled: false,
+    sides: 'both',
+    height: 0.055,
+    proud: 0.026,
+    profile: 'flat',
+    offsetY: 0.9,
+};
+export const WALL_TRIM_DEFAULTS = {
+    skirting: WALL_SKIRTING_DEFAULT,
+    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,
+};
 export const WallNode = BaseNode.extend({
     id: objectId('wall'),
     type: nodeType('wall'),
@@ -19,9 +122,20 @@ export const WallNode = BaseNode.extend({
     interiorMaterialPreset: z.string().optional(),
     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.
+    slots: z.record(z.string(), z.string()).optional(),
     thickness: z.number().optional(),
     height: z.number().optional(),
     curveOffset: z.number().optional(),
+    faceBands: WallFaceBandConfig.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()]),
@@ -39,6 +153,149 @@ export const WallNode = BaseNode.extend({
   - frontSide: whether the front side faces interior, exterior, or unknown
   - backSide: whether the back side faces interior, exterior, or unknown
   `);
+// Declared default appearance for an unpainted wall face in colored mode —
+// visual parity with the retired DEFAULT_WALL_MATERIAL. Lives in core so the
+// slot declaration (nodes) and the material resolver (viewer) share one value.
+// 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) {
+    const wallHeight = wall.height ?? 2.5;
+    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) {
+    const bands = getWallFaceBandConfig(wall);
+    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'],
+};
+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'];
+}
+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;
+}
 function getConfiguredWallSurfaceMaterial(wall, side) {
     if (side === 'interior') {
         return {

package/dist/schema/nodes/wall.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall.test.d.ts.map

package/dist/schema/nodes/wall.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/wall.test.ts"],"names":[],"mappings":""}

package/dist/schema/nodes/wall.test.js

@@ -0,0 +1,208 @@
+import { describe, expect, test } from 'bun:test';
+import { buildEnabledWallFaceBandPatch, buildWallFaceBandCountPatch, getWallFaceBandConfig, WALL_CHAIR_RAIL_DEFAULT, WALL_CHAIR_RAIL_SLOT_DEFAULT, WALL_CROWN_DEFAULT, WALL_CROWN_SLOT_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_FACE_BAND_SOLID_SLOT_DEFAULTS, WALL_SKIRTING_DEFAULT, WALL_SKIRTING_SLOT_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, WallFaceBandConfig, WallTrimConfig, } from './wall';
+describe('wall face bands', () => {
+    test('defaults to one band while preserving legacy enabled scenes as three bands', () => {
+        expect(WALL_FACE_BAND_DEFAULT.count).toBe(1);
+        expect(WALL_FACE_BAND_DEFAULT.lowerHeight).toBe(0.84);
+        expect(WALL_FACE_BAND_DEFAULT.middleHeight).toBe(0.61);
+        expect(WALL_FACE_BAND_DEFAULT.upperHeight).toBe(0.61);
+        expect(WallFaceBandConfig.parse({})).toEqual({
+            enabled: false,
+            count: 1,
+            lowerHeight: 0.84,
+            middleHeight: 0.61,
+            upperHeight: 0.61,
+        });
+        expect(WallFaceBandConfig.parse({ enabled: true })).toEqual({
+            enabled: true,
+            count: 3,
+            lowerHeight: 0.84,
+            middleHeight: 0.61,
+            upperHeight: 0.61,
+        });
+        expect(getWallFaceBandConfig({
+            height: 2.5,
+            faceBands: {
+                enabled: true,
+                count: 3,
+                lowerHeight: 0.84,
+                middleHeight: 0.61,
+                upperHeight: 0.61,
+            },
+        })).toMatchObject({
+            count: 3,
+            lowerTop: 0.84,
+            middleTop: 1.45,
+        });
+    });
+    test('four bands adds an upper split below the final top band', () => {
+        expect(getWallFaceBandConfig({
+            height: 2.5,
+            faceBands: {
+                enabled: true,
+                count: 4,
+                lowerHeight: 0.5,
+                middleHeight: 0.6,
+                upperHeight: 0.7,
+            },
+        })).toMatchObject({
+            count: 4,
+            lowerTop: 0.5,
+            middleTop: 1.1,
+            upperTop: 1.8,
+        });
+    });
+    test('enabling bands seeds visible solid-color band slots', () => {
+        const patch = buildEnabledWallFaceBandPatch({
+            faceBands: {
+                enabled: false,
+                count: 1,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                interior: 'library:interior-finish',
+                exterior: 'scene:exterior-finish',
+                lowerInterior: 'library:stale-lower',
+                middleExterior: 'library:stale-middle',
+            },
+        });
+        expect(patch.faceBands).toEqual({
+            enabled: true,
+            count: 2,
+            lowerHeight: 0.2,
+            middleHeight: 0.3,
+            upperHeight: 0.61,
+        });
+        expect(patch.slots).toMatchObject({
+            interior: 'library:interior-finish',
+            exterior: 'scene:exterior-finish',
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperInterior: 'library:interior-finish',
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperExterior: 'scene:exterior-finish',
+        });
+        expect(patch.slots?.middleInterior).toBeUndefined();
+        expect(patch.slots?.middleExterior).toBeUndefined();
+    });
+    test('band count patch enables only the active slots', () => {
+        const patch = buildWallFaceBandCountPatch({
+            faceBands: {
+                enabled: true,
+                count: 4,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                interior: 'library:interior-finish',
+                exterior: 'scene:exterior-finish',
+                topInterior: 'library:stale-top',
+            },
+        }, 3);
+        expect(patch.faceBands).toMatchObject({ enabled: true, count: 3 });
+        expect(patch.slots).toMatchObject({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperInterior: 'library:stale-top',
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperExterior: 'scene:exterior-finish',
+        });
+        expect(patch.slots?.topInterior).toBeUndefined();
+        expect(patch.slots?.topExterior).toBeUndefined();
+    });
+    test('enabling bands replaces stale inactive band slots with solid-color defaults', () => {
+        const patch = buildEnabledWallFaceBandPatch({
+            slots: {
+                lowerInterior: 'library:stale-lower',
+                middleInterior: 'library:stale-middle',
+                upperExterior: 'library:stale-upper',
+            },
+        });
+        expect(patch.slots).toEqual({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperInterior: WALL_SURFACE_SLOT_DEFAULTS.interior,
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            upperExterior: WALL_SURFACE_SLOT_DEFAULTS.exterior,
+        });
+        expect(patch.slots?.middleInterior).toBeUndefined();
+        expect(patch.slots?.middleExterior).toBeUndefined();
+    });
+    test('increasing band count paints newly active bands with the solid palette', () => {
+        const patch = buildWallFaceBandCountPatch({
+            faceBands: {
+                enabled: true,
+                count: 2,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                upperInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+                lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                upperExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            },
+        }, 3);
+        expect(patch.slots).toMatchObject({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+        });
+    });
+    test('increasing to four bands keeps the previous top material on the new top band', () => {
+        const patch = buildWallFaceBandCountPatch({
+            faceBands: {
+                enabled: true,
+                count: 3,
+                lowerHeight: 0.2,
+                middleHeight: 0.3,
+                upperHeight: 0.61,
+            },
+            slots: {
+                lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+                upperInterior: 'scene:painted-top-interior',
+                lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+                middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+                upperExterior: 'library:painted-top-exterior',
+            },
+        }, 4);
+        expect(patch.slots).toMatchObject({
+            lowerInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperInterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            topInterior: 'scene:painted-top-interior',
+            lowerExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.lower,
+            middleExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.middle,
+            upperExterior: WALL_FACE_BAND_SOLID_SLOT_DEFAULTS.upper,
+            topExterior: 'library:painted-top-exterior',
+        });
+    });
+});
+describe('wall trim profiles', () => {
+    test('uses curated defaults while preserving legacy profile values', () => {
+        expect(WALL_SKIRTING_DEFAULT.profile).toBe('flat');
+        expect(WALL_CROWN_DEFAULT.profile).toBe('flat');
+        expect(WALL_CHAIR_RAIL_DEFAULT.profile).toBe('flat');
+        expect(WallTrimConfig.parse({ profile: 'flat' }).profile).toBe('flat');
+        expect(WallTrimConfig.parse({ profile: 'crown-layered' }).profile).toBe('crown-layered');
+        expect(WallTrimConfig.parse({ profile: 'triangle' }).profile).toBe('triangle');
+    });
+    test('declares separate default materials for each trim family', () => {
+        expect(WALL_SKIRTING_SLOT_DEFAULT).toBe('library:preset-softwhite');
+        expect(WALL_CROWN_SLOT_DEFAULT).toBe('library:preset-white');
+        expect(WALL_CHAIR_RAIL_SLOT_DEFAULT).toBe('library:preset-cream');
+        expect(WALL_SURFACE_SLOT_DEFAULTS.skirtingInterior).toBe(WALL_SKIRTING_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.skirtingExterior).toBe(WALL_SKIRTING_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.crownInterior).toBe(WALL_CROWN_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.crownExterior).toBe(WALL_CROWN_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.chairRailInterior).toBe(WALL_CHAIR_RAIL_SLOT_DEFAULT);
+        expect(WALL_SURFACE_SLOT_DEFAULTS.chairRailExterior).toBe(WALL_CHAIR_RAIL_SLOT_DEFAULT);
+    });
+});

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

@@ -32,7 +32,7 @@ export declare const WindowNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"window">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -43,7 +43,7 @@ export declare const WindowNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -62,6 +62,7 @@ export declare const WindowNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
@@ -69,6 +70,13 @@ export declare const WindowNode: z.ZodObject<{
         back: "back";
     }>>;
     wallId: z.ZodOptional<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    roofFace: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+        right: "right";
+        left: "left";
+    }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     openingKind: z.ZodDefault<z.ZodEnum<{
@@ -97,8 +105,8 @@ export declare const WindowNode: z.ZodObject<{
         single: "single";
     }>>;
     hingesSide: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     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,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DrB,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;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;EAWrB,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuErB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/window.js

@@ -18,11 +18,23 @@ export const WindowNode = BaseNode.extend({
     id: objectId('window'),
     type: nodeType('window'),
     material: MaterialSchema.optional(),
+    // Per-slot material overrides on the unified slot model. Keys: `frame`,
+    // `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`). Absent =
+    // the frame/glass default. Mirrors `ShelfNode.slots`.
+    slots: z.record(z.string(), z.string()).optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     side: z.enum(['front', 'back']).optional(),
     // Wall reference
     wallId: z.string().optional(),
+    // Alternative host: a roof-segment's generated wall face (base wall
+    // under the roof or a coplanar gable end). When set, `position` is
+    // FACE-LOCAL — [u along the face, v height, z from the wall mid-plane]
+    // — exactly the wall-child convention; the renderer mounts the node
+    // inside the face frame (`getRoofWallFaceFrame`), which is what makes
+    // hosted children track segment resizes live.
+    roofSegmentId: z.string().optional(),
+    roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
     // Overall dimensions
     width: z.number().default(1.5),
     height: z.number().default(1.5),

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

@@ -17,6 +17,8 @@ export declare const ZoneNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"zone">>;
     name: z.ZodString;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    autoFromWalls: z.ZodDefault<z.ZodBoolean>;
+    boundaryWallIds: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>>>;
     color: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
 }, z.core.$strip>;

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

@@ -1 +1 @@
-{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;iBAoBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"zone.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;iBA0BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/zone.js

@@ -7,6 +7,10 @@ export const ZoneNode = BaseNode.extend({
     name: z.string(),
     // Polygon boundary - array of [x, z] coordinates defining the zone
     polygon: z.array(z.tuple([z.number(), z.number()])),
+    // Procedural room zones retain the walls that prove their enclosure. The
+    // stored polygon remains a fallback for missing or temporarily open walls.
+    autoFromWalls: z.boolean().default(false),
+    boundaryWallIds: z.array(objectId('wall')).default([]),
     // Visual styling
     color: z.string().default('#3b82f6'), // Default blue
     metadata: z.json().optional().default({}),
@@ -17,6 +21,8 @@ export const ZoneNode = BaseNode.extend({
   - levelId: level this zone is attached to
   - name: zone name
   - polygon: array of [x, z] points defining the zone boundary
+  - autoFromWalls: whether the boundary follows an enclosed wall loop
+  - boundaryWallIds: wall ids that prove the procedural enclosure
   - color: hex color for visual styling
   - metadata: zone metadata (optional)
   `);

package/dist/schema/scene-material.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export type SceneMaterialId = `mat_${string}`;
+export declare const generateSceneMaterialId: () => SceneMaterialId;
+export declare const SceneMaterial: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    material: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SceneMaterial = z.infer<typeof SceneMaterial>;
+//# sourceMappingURL=scene-material.d.ts.map

package/dist/schema/scene-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-material.d.ts","sourceRoot":"","sources":["../../src/schema/scene-material.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,MAAM,MAAM,eAAe,GAAG,OAAO,MAAM,EAAE,CAAA;AAC7C,eAAO,MAAM,uBAAuB,QAAO,eAAoC,CAAA;AAE/E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}