@pascal-app/core 1.0.1 → 1.0.4

package/dist/building/level-duplication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-duplication.d.ts","sourceRoot":"","sources":["../../src/building/level-duplication.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAGd,KAAK,SAAS,EAEf,MAAM,WAAW,CAAA;AAKlB,MAAM,MAAM,oBAAoB,GAC5B,YAAY,GACZ,WAAW,GACX,qBAAqB,GACrB,qBAAqB,CAAA;AAqGzB,6FAA6F;AAC7F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,SAAS,yvCAElF;AAED,wBAAgB,4BAA4B,CAAC,EAC3C,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,QAAkB,GACnB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,KAAK,EAAE,SAAS,CAAA;IAChB,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,MAAM,EAAE,oBAAoB,CAAA;IAC5B,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAO4B,SAAS,CAAC,IAAI,CAAC;eAAS,MAAM;eAAS,SAAS;;;;cAuNZ,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAehF"}

package/dist/building/level-duplication.js

@@ -0,0 +1,314 @@
+import { floorPlateAtGroundContact, supportDerivedFloorHeight } from '../lib/floor-foundation-datum.js';
+import { expandFloorIntentChanges } from '../lib/floor-intent-changes.js';
+import { footprintIoU } from '../lib/floor-plates.js';
+import { getDefaultLevelName } from '../lib/level-name.js';
+import { reconcileSceneStructure } from '../lib/structure-reconcile.js';
+import { generateId, UnitNode, } from '../schema/index.js';
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { isDerivedNode } from '../store/derived-node-guard.js';
+import { cloneLevelSubtree, remapNodeReferences } from '../utils/clone-scene-graph.js';
+const NON_DUPLICABLE_NODE_TYPES = new Set(['scan', 'guide', 'spawn']);
+const STRUCTURAL_NODE_TYPES = new Set([
+    'level',
+    'wall',
+    'fence',
+    'zone',
+    'slab',
+    'ceiling',
+    'roof',
+    'roof-segment',
+    'stair',
+    'stair-segment',
+    'window',
+    'door',
+]);
+function shouldKeepNode(node, preset) {
+    if (NON_DUPLICABLE_NODE_TYPES.has(node.type))
+        return false;
+    if (preset === 'everything')
+        return true;
+    if (preset === 'structure-furniture')
+        return true;
+    if (preset === 'structure' || preset === 'structure-materials') {
+        return STRUCTURAL_NODE_TYPES.has(node.type);
+    }
+    return true;
+}
+/**
+ * Material field keys per kind, used by the `structure` duplicate preset
+ * to strip materials from the cloned subtree. Lookup table replaces the
+ * legacy per-kind switch — the Phase 6 grep gate flagged `case '<kind>':`
+ * in this file as the remaining per-kind dispatch outside the registry.
+ *
+ * Future: move this to a `capabilities.materialFields` declaration on
+ * each kind's `NodeDefinition` so adding a new kind with materials is a
+ * registry-only edit. Today the registry doesn't surface material fields
+ * in a uniform way (each kind's panel reads / writes them directly), so
+ * this map mirrors the legacy behavior 1:1.
+ */
+const MATERIAL_FIELDS_BY_KIND = {
+    wall: [
+        'material',
+        'materialPreset',
+        'interiorMaterial',
+        'interiorMaterialPreset',
+        'exteriorMaterial',
+        'exteriorMaterialPreset',
+    ],
+    slab: ['material', 'materialPreset'],
+    ceiling: ['material', 'materialPreset'],
+    fence: ['material', 'materialPreset'],
+    shelf: ['material', 'materialPreset'],
+    'roof-segment': ['material', 'materialPreset'],
+    'stair-segment': ['material', 'materialPreset'],
+    window: ['material', 'materialPreset'],
+    door: ['material', 'materialPreset'],
+    roof: [
+        'material',
+        'materialPreset',
+        'topMaterial',
+        'topMaterialPreset',
+        'edgeMaterial',
+        'edgeMaterialPreset',
+        'wallMaterial',
+        'wallMaterialPreset',
+    ],
+    stair: [
+        'material',
+        'materialPreset',
+        'railingMaterial',
+        'railingMaterialPreset',
+        'treadMaterial',
+        'treadMaterialPreset',
+        'sideMaterial',
+        'sideMaterialPreset',
+    ],
+};
+function stripMaterials(node) {
+    const fields = MATERIAL_FIELDS_BY_KIND[node.type];
+    if (!fields)
+        return node;
+    const next = { ...node };
+    for (const field of fields)
+        delete next[field];
+    return next;
+}
+function findLevelBuildingId(nodes, levelId) {
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'building' || !('children' in node) || !Array.isArray(node.children)) {
+            continue;
+        }
+        if (node.children.includes(levelId)) {
+            return node.id;
+        }
+    }
+    return undefined;
+}
+/** The building a level belongs to; a bootstrap level may only be listed in its children. */
+export function levelBuildingId(nodes, level) {
+    return level.parentId ?? findLevelBuildingId(nodes, level.id);
+}
+export function buildLevelDuplicateCreateOps({ nodes, level, levels, preset, position = 'above', }) {
+    const { clonedNodes, newLevelId, idMap } = cloneLevelSubtree(nodes, level.id);
+    const parentBuildingId = levelBuildingId(nodes, level);
+    const nextLevelNumber = position === 'above' ? level.level + 1 : level.level;
+    // Only the floors in the way move up: a free floor index above the copy (floors deleted before
+    // copying, as the agents' build guide does) is filled, not carried up. Pushing every floor above
+    // sent a tall build's floor 8 from index 7 to 10.
+    const shiftedLevels = [];
+    let free = nextLevelNumber;
+    for (const entry of levels
+        .filter((candidate) => (position === 'below' || candidate.id !== level.id) && candidate.level >= nextLevelNumber)
+        .sort((a, b) => a.level - b.level)) {
+        if (entry.level > free)
+            break;
+        shiftedLevels.push({
+            id: entry.id,
+            level: entry.level + 1,
+            // A stored placeholder would pin the old floor's name; cleared, it reads by its new place.
+            ...(entry.name === getDefaultLevelName(entry.level) || entry.name === `Level ${entry.level}`
+                ? { name: undefined }
+                : {}),
+        });
+        free = entry.level + 1;
+    }
+    const filteredNodes = clonedNodes
+        .filter((node) => shouldKeepNode(node, preset))
+        .map((node) => (preset === 'structure' ? stripMaterials(node) : node));
+    const keptIds = new Set(filteredNodes.map((node) => node.id));
+    const cleanedNodes = filteredNodes.map((node) => {
+        if (!('children' in node && Array.isArray(node.children))) {
+            return node;
+        }
+        return {
+            ...node,
+            children: node.children.filter((childId) => keptIds.has(childId)),
+        };
+    });
+    if (parentBuildingId && nodes[parentBuildingId]?.type === 'building') {
+        for (const unit of Object.values(nodes)) {
+            if (unit.type !== 'unit' ||
+                unit.parentId !== parentBuildingId ||
+                unit.members.length === 0 ||
+                !unit.members.every((id) => {
+                    const zone = nodes[id];
+                    const remapped = idMap.get(id);
+                    return (zone?.type === 'zone' &&
+                        zone.parentId === level.id &&
+                        remapped !== undefined &&
+                        keptIds.has(remapped));
+                }))
+                continue;
+            cleanedNodes.push(UnitNode.parse({
+                ...unit,
+                id: undefined,
+                parentId: parentBuildingId,
+                name: `${unit.name} copy`,
+                members: unit.members.map((id) => idMap.get(id)),
+            }));
+        }
+    }
+    const copy = cleanedNodes.find((node) => node.id === newLevelId);
+    copy.level = nextLevelNumber;
+    // Unnamed like a level from the add buttons, so it reads by its place in the building.
+    delete copy.name;
+    copy.baseElevation = 0;
+    copy.parentId = parentBuildingId ?? null;
+    const draft = {
+        ...nodes,
+        ...Object.fromEntries(shiftedLevels.map(({ id, ...data }) => [id, { ...nodes[id], ...data }])),
+        ...Object.fromEntries(cleanedNodes.map((node) => [node.id, node])),
+    };
+    // A ground footprint carries its lift into the storey stack. Repeating
+    // that lift on its upper copy would add the foundation height a second time.
+    const sourceByCopy = new Map([...idMap].map(([source, target]) => [target, source]));
+    const constructionChanges = Object.values(draft).flatMap((node) => {
+        const source = nodes[(sourceByCopy.get(node.id) ?? node.id)];
+        if (node.type !== 'slab' ||
+            node.plateRole !== 'base' ||
+            source?.type !== 'slab' ||
+            !(floorPlateAtGroundContact(nodes, source) ||
+                (sourceByCopy.has(node.id) && source.foundation?.type === 'solid')) ||
+            floorPlateAtGroundContact(draft, node))
+            return [];
+        const reference = supportDerivedFloorHeight(draft, node);
+        return [
+            {
+                id: node.id,
+                data: {
+                    floorHeight: undefined,
+                    referenceFloorElevation: reference,
+                    elevation: reference - DEFAULT_SLAB_ELEVATION + node.thickness,
+                    foundation: { type: 'none' },
+                },
+            },
+        ];
+    });
+    for (const { id, data } of expandFloorIntentChanges(draft, constructionChanges)) {
+        draft[id] = { ...draft[id], ...data };
+        for (const [key, value] of Object.entries(data))
+            if (value === undefined)
+                delete draft[id][key];
+    }
+    const surfaces = cleanedNodes.filter(isDerivedNode).map((node) => draft[node.id]);
+    for (const surface of surfaces)
+        delete draft[surface.id];
+    draft[newLevelId] = { ...copy, children: copy.children.filter((id) => !!draft[id]) };
+    let generated = reconcileSceneStructure({
+        nodes: draft,
+        levelIds: [newLevelId],
+        mintId: generateId,
+    }).nodes;
+    const surfaceIds = new Map();
+    for (const surface of surfaces) {
+        const linked = surface.type === 'slab' ? surface.zoneIds : surface.type === 'ceiling' ? [surface.zoneId] : [];
+        const target = Object.values(generated)
+            .filter((node) => node.parentId === newLevelId &&
+            node.type === surface.type &&
+            (node.type === 'slab' && surface.type === 'slab'
+                ? node.plateRole === surface.plateRole &&
+                    node.zoneIds?.some((id) => linked?.includes(id))
+                : node.type === 'ceiling' && linked?.includes(node.zoneId)))
+            .sort((a, b) => {
+            if (a.id === surface.id)
+                return -1;
+            if (b.id === surface.id)
+                return 1;
+            if (!isDerivedNode(a) || !isDerivedNode(b))
+                return 0;
+            const footprint = { outer: surface.polygon, holes: surface.holes ?? [] };
+            return (footprintIoU(footprint, { outer: b.polygon, holes: b.holes ?? [] }) -
+                footprintIoU(footprint, { outer: a.polygon, holes: a.holes ?? [] }));
+        })[0];
+        if (!target)
+            continue;
+        surfaceIds.set(surface.id, target.id);
+        if (target.type === 'slab' && surface.type === 'slab' && target.plateRole === 'base') {
+            const { thickness, elevation, floorHeight, referenceFloorElevation, foundation, material, materialPreset, slots, name, } = surface;
+            generated[target.id] = {
+                ...target,
+                thickness,
+                elevation,
+                floorHeight,
+                referenceFloorElevation,
+                foundation,
+                material,
+                materialPreset,
+                slots,
+                name,
+            };
+        }
+        if (target.type === 'ceiling' && surface.type === 'ceiling')
+            generated[target.id] = {
+                ...target,
+                height: surface.height,
+                material: surface.material,
+                materialPreset: surface.materialPreset,
+                slots: surface.slots,
+            };
+    }
+    // Everything hosted on a copied surface (ceiling lights, supports, decks,
+    // lean-tos, hangers) follows it to its regenerated id.
+    for (const node of Object.values(generated))
+        if (sourceByCopy.has(node.id))
+            generated[node.id] = remapNodeReferences(node, surfaceIds);
+    for (const id of surfaceIds.values()) {
+        const surface = generated[id];
+        if (surface?.type === 'ceiling')
+            generated[id] = {
+                ...surface,
+                children: Object.values(generated)
+                    .filter((node) => node.parentId === id)
+                    .map((node) => node.id),
+            };
+    }
+    generated = reconcileSceneStructure({
+        nodes: generated,
+        levelIds: [newLevelId],
+        mintId: generateId,
+    }).nodes;
+    const created = Object.values(generated).filter((node) => !nodes[node.id]);
+    const updateOps = Object.values(generated).flatMap((node) => {
+        const old = nodes[node.id];
+        if (!old || JSON.stringify(old) === JSON.stringify(node))
+            return [];
+        const data = Object.fromEntries([...new Set([...Object.keys(old), ...Object.keys(node)])]
+            .filter((key) => JSON.stringify(old[key]) !==
+            JSON.stringify(node[key]))
+            .map((key) => [key, node[key]]));
+        const rebase = constructionChanges.find((change) => change.id === node.id);
+        return [{ id: node.id, data: { ...data, ...rebase?.data } }];
+    });
+    return {
+        createOps: created.map((node) => ({
+            node,
+            parentId: node.id === newLevelId
+                ? parentBuildingId
+                : (node.parentId ?? undefined),
+        })),
+        newLevelId,
+        shiftedLevels,
+        updateOps,
+        skippedNodes: clonedNodes.filter((node) => !keptIds.has(node.id)),
+    };
+}

package/dist/building/opening-style-presets.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Style presets for doors and windows: what a door's leaf or a window's panes look like, never how
+ * it opens (doorType, windowType) or its size. `add_door`, `add_window` and `create_room`'s
+ * doors[] / windows[] apply them by name; the door and window panels show them as their Style row
+ * and read a node's style back from its fields.
+ */
+import type { DoorSegment } from '../schema/index.js';
+export declare const DOOR_STYLES: readonly ["panel", "glass", "modern", "paneled-glass", "french", "shaker", "six-panel", "craftsman", "half-louvered", "barn"];
+export type DoorStyle = (typeof DOOR_STYLES)[number];
+export declare const DOOR_STYLE_DESCRIPTIONS: Record<DoorStyle, string>;
+/** The Style row's labels; the stored and agent value is the style itself. */
+export declare const DOOR_STYLE_LABELS: Record<DoorStyle, string>;
+/** Every field a door style owns. */
+export type DoorStyleLook = {
+    segments: DoorSegment[];
+    contentPadding: [number, number];
+};
+/**
+ * A door style's whole look: applied, it replaces the last style's (a panel door after a modern one
+ * gets its margin back), and the panel reads a style back by these fields alone.
+ */
+export declare function doorStyleLook(style: DoorStyle): DoorStyleLook;
+/** The styles a door's leaf is, in list order: none for a leaf made by hand (the panel's Custom). */
+export declare function doorStylesOf(door: DoorStyleLook): DoorStyle[];
+export declare const WINDOW_STYLES: readonly ["single", "double-hung", "triple-hung", "casement", "sliding", "grid", "tall-grid", "wide-grid", "horizontal-bands", "transom", "picture"];
+export type WindowStyle = (typeof WINDOW_STYLES)[number];
+/**
+ * The styles the panel's Style row and the window tool's L chip offer: one per look. 'picture'
+ * draws what 'single' draws, so it is not offered; agents may still ask for it (an alias).
+ */
+export declare const WINDOW_STYLE_CHOICES: readonly WindowStyle[];
+export declare const WINDOW_STYLE_DESCRIPTIONS: Record<WindowStyle, string>;
+/** The Style row's labels; the stored and agent value is the style itself. */
+export declare const WINDOW_STYLE_LABELS: Record<WindowStyle, string>;
+interface WindowStyleOverrides {
+    columnRatios?: number[];
+    rowRatios?: number[];
+}
+export declare function getWindowStyleOverrides(style: WindowStyle | undefined): WindowStyleOverrides;
+/** The style a window's panes are, as the panel offers it: one per look, none for panes set by hand. */
+export declare function windowStylesOf(window: {
+    columnRatios: number[];
+    rowRatios: number[];
+}): WindowStyle[];
+export {};
+//# sourceMappingURL=opening-style-presets.d.ts.map

package/dist/building/opening-style-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-style-presets.d.ts","sourceRoot":"","sources":["../../src/building/opening-style-presets.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAK5C,eAAO,MAAM,WAAW,+HAWd,CAAA;AACV,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpD,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAW7D,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAWvD,CAAA;AAED,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAA;AA4BzF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CAiC7D;AAaD,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,CAG7D;AAID,eAAO,MAAM,aAAa,sJAYhB,CAAA;AACV,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAExD;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,WAAW,EAEtD,CAAA;AAED,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAYjE,CAAA;AAED,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAY3D,CAAA;AAED,UAAU,oBAAoB;IAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,oBAAoB,CAiC5F;AAED,wGAAwG;AACxG,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,GAAG,WAAW,EAAE,CAKhB"}

package/dist/building/opening-style-presets.js

@@ -0,0 +1,195 @@
+/**
+ * Style presets for doors and windows: what a door's leaf or a window's panes look like, never how
+ * it opens (doorType, windowType) or its size. `add_door`, `add_window` and `create_room`'s
+ * doors[] / windows[] apply them by name; the door and window panels show them as their Style row
+ * and read a node's style back from its fields.
+ */
+import { DEFAULT_DOOR_CONTENT_PADDING, defaultDoorSegments } from '../schema/nodes/opening-types.js';
+// ── Doors ────────────────────────────────────────────────────────────────────
+export const DOOR_STYLES = [
+    'panel',
+    'glass',
+    'modern',
+    'paneled-glass',
+    'french',
+    'shaker',
+    'six-panel',
+    'craftsman',
+    'half-louvered',
+    'barn',
+];
+export const DOOR_STYLE_DESCRIPTIONS = {
+    panel: 'Classic raised-panel door (default).',
+    glass: 'Mostly glass; modern interior or patio door.',
+    modern: 'Flat slab, no panels, no glass — minimalist look.',
+    'paneled-glass': 'Glass top, panel bottom — common entry door.',
+    french: 'Two narrow vertical glass leaves — French door look.',
+    shaker: 'Single flat panel with a clean inset — minimalist.',
+    'six-panel': 'Classic 6-panel (3 rows × 2 columns) — traditional interior.',
+    craftsman: '4 narrow vertical raised panels stacked — craftsman style.',
+    'half-louvered': 'Top half horizontal slats, bottom half panel — closet / laundry.',
+    barn: 'Wide single recessed panel — sliding-barn look.',
+};
+/** The Style row's labels; the stored and agent value is the style itself. */
+export const DOOR_STYLE_LABELS = {
+    panel: 'Panel',
+    glass: 'Glass',
+    modern: 'Modern',
+    'paneled-glass': 'Paneled glass',
+    french: 'French',
+    shaker: 'Shaker',
+    'six-panel': 'Six-panel',
+    craftsman: 'Craftsman',
+    'half-louvered': 'Half-louvered',
+    barn: 'Barn',
+};
+const PANEL_DIVIDER = 0.03;
+const PANEL_DEPTH = 0.01;
+const PANEL_INSET = 0.04;
+function panelSegment(type, heightRatio, columnRatios = [1], overrides = {}) {
+    return {
+        type,
+        heightRatio,
+        columnRatios,
+        dividerThickness: PANEL_DIVIDER,
+        panelDepth: PANEL_DEPTH,
+        panelInset: PANEL_INSET,
+        ...overrides,
+    };
+}
+const look = (segments, contentPadding = DEFAULT_DOOR_CONTENT_PADDING) => ({ segments, contentPadding: [...contentPadding] });
+/**
+ * A door style's whole look: applied, it replaces the last style's (a panel door after a modern one
+ * gets its margin back), and the panel reads a style back by these fields alone.
+ */
+export function doorStyleLook(style) {
+    switch (style) {
+        case 'panel':
+            return look(defaultDoorSegments());
+        case 'glass':
+            return look([panelSegment('glass', 1)]);
+        case 'modern':
+            // A flush slab: one panel over the whole leaf. An 'empty' segment is no leaf at all (a front
+            // door once rendered as an open frame).
+            return look([panelSegment('panel', 1, [1], { panelDepth: 0, panelInset: 0 })], [0, 0]);
+        case 'paneled-glass':
+            return look([panelSegment('glass', 0.55), panelSegment('panel', 0.45)]);
+        case 'french':
+            return look([panelSegment('glass', 1, [0.5, 0.5])]);
+        case 'shaker':
+            return look([panelSegment('panel', 1, [1], { panelDepth: -0.005, panelInset: 0.06 })]);
+        case 'six-panel':
+            return look([0.34, 0.33, 0.33].map((ratio) => panelSegment('panel', ratio, [0.5, 0.5])));
+        case 'craftsman':
+            return look([0.25, 0.25, 0.25, 0.25].map((ratio) => panelSegment('panel', ratio)));
+        case 'half-louvered':
+            // Slats as narrow raised bars on the top half: an 'empty' row would be a hole in the leaf.
+            // The door system always raises a panel by |panelDepth|, so a slat reads only when it is
+            // deep and narrow against its gap: ten bars about 7 cm tall, 2.2 cm proud, 2.8 cm apart.
+            return look([
+                ...Array.from({ length: 10 }, () => panelSegment('panel', 0.5 / 10, [1], { panelDepth: 0.022, panelInset: 0.014 })),
+                panelSegment('panel', 0.5),
+            ]);
+        case 'barn':
+            return look([panelSegment('panel', 1, [1], { panelDepth: -0.02, panelInset: 0.08 })]);
+    }
+}
+const same = (a, b) => {
+    if (typeof a === 'number' && typeof b === 'number')
+        return Math.abs(a - b) < 1e-6;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((value, i) => same(value, b[i]));
+    if (a && b && typeof a === 'object' && typeof b === 'object')
+        return Object.keys({ ...a, ...b }).every((key) => same(a[key], b[key]));
+    return a === b;
+};
+/** The styles a door's leaf is, in list order: none for a leaf made by hand (the panel's Custom). */
+export function doorStylesOf(door) {
+    const { segments, contentPadding } = door;
+    return DOOR_STYLES.filter((style) => same(doorStyleLook(style), { segments, contentPadding }));
+}
+// ── Windows ──────────────────────────────────────────────────────────────────
+export const WINDOW_STYLES = [
+    'single',
+    'double-hung',
+    'triple-hung',
+    'casement',
+    'sliding',
+    'grid',
+    'tall-grid',
+    'wide-grid',
+    'horizontal-bands',
+    'transom',
+    'picture',
+];
+/**
+ * The styles the panel's Style row and the window tool's L chip offer: one per look. 'picture'
+ * draws what 'single' draws, so it is not offered; agents may still ask for it (an alias).
+ */
+export const WINDOW_STYLE_CHOICES = WINDOW_STYLES.filter((style) => style !== 'picture');
+export const WINDOW_STYLE_DESCRIPTIONS = {
+    single: 'Single pane with a frame — simplest look (default).',
+    'double-hung': 'Two stacked sashes — classic American style.',
+    'triple-hung': 'Three stacked sashes — taller and slimmer.',
+    casement: 'Two side-by-side panes — vertical mullion.',
+    sliding: 'Three side-by-side panes — wide / sliding-door look.',
+    grid: '2×2 grid of panes — colonial / cottage style.',
+    'tall-grid': '2 columns × 3 rows — taller proportions.',
+    'wide-grid': '3 columns × 2 rows — wider proportions.',
+    'horizontal-bands': '4 stacked horizontal bands — modernist strip window.',
+    transom: 'Short row on top + larger pane below — transom over a base.',
+    picture: "Alias of 'single': one pane, no internal divisions.",
+};
+/** The Style row's labels; the stored and agent value is the style itself. */
+export const WINDOW_STYLE_LABELS = {
+    single: 'Single',
+    'double-hung': 'Double-hung',
+    'triple-hung': 'Triple-hung',
+    casement: 'Casement',
+    sliding: 'Sliding',
+    grid: 'Grid',
+    'tall-grid': 'Tall grid',
+    'wide-grid': 'Wide grid',
+    'horizontal-bands': 'Horizontal bands',
+    transom: 'Transom',
+    picture: 'Picture',
+};
+export function getWindowStyleOverrides(style) {
+    if (!style || style === 'single' || style === 'picture') {
+        return { columnRatios: [1], rowRatios: [1] };
+    }
+    if (style === 'double-hung') {
+        return { columnRatios: [1], rowRatios: [0.5, 0.5] };
+    }
+    if (style === 'triple-hung') {
+        return { columnRatios: [1], rowRatios: [1 / 3, 1 / 3, 1 / 3] };
+    }
+    if (style === 'casement') {
+        return { columnRatios: [0.5, 0.5], rowRatios: [1] };
+    }
+    if (style === 'sliding') {
+        return { columnRatios: [1 / 3, 1 / 3, 1 / 3], rowRatios: [1] };
+    }
+    if (style === 'grid') {
+        return { columnRatios: [0.5, 0.5], rowRatios: [0.5, 0.5] };
+    }
+    if (style === 'tall-grid') {
+        return { columnRatios: [0.5, 0.5], rowRatios: [1 / 3, 1 / 3, 1 / 3] };
+    }
+    if (style === 'wide-grid') {
+        return { columnRatios: [1 / 3, 1 / 3, 1 / 3], rowRatios: [0.5, 0.5] };
+    }
+    if (style === 'horizontal-bands') {
+        return { columnRatios: [1], rowRatios: [0.25, 0.25, 0.25, 0.25] };
+    }
+    if (style === 'transom') {
+        // Smaller transom row on top, larger main pane below.
+        return { columnRatios: [1], rowRatios: [0.3, 0.7] };
+    }
+    return {};
+}
+/** The style a window's panes are, as the panel offers it: one per look, none for panes set by hand. */
+export function windowStylesOf(window) {
+    const { columnRatios, rowRatios } = window;
+    return WINDOW_STYLE_CHOICES.filter((style) => same(getWindowStyleOverrides(style), { columnRatios, rowRatios }));
+}