@pascal-app/core 1.0.4 → 1.0.5

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

@@ -1 +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"}
+{"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;AAOlB,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;;;;cAiOZ,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBhF"}

package/dist/building/level-duplication.js

@@ -5,6 +5,8 @@ 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 { isRoofLevel, isStoreyContent } from '../services/roof-level.js';
+import { seatRoofs } from '../services/roof-move.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']);
@@ -170,6 +172,12 @@ export function buildLevelDuplicateCreateOps({ nodes, level, levels, preset, pos
     }
     const copy = cleanedNodes.find((node) => node.id === newLevelId);
     copy.level = nextLevelNumber;
+    // A walled level someone declared the roof level is a storey once copied: the copy is one.
+    if (isRoofLevel(copy) &&
+        cleanedNodes.some((node) => node.parentId === newLevelId && isStoreyContent(node.type, node.metadata))) {
+        const { role: _role, ...metadata } = copy.metadata;
+        copy.metadata = metadata;
+    }
     // Unnamed like a level from the add buttons, so it reads by its place in the building.
     delete copy.name;
     copy.baseElevation = 0;
@@ -299,16 +307,22 @@ export function buildLevelDuplicateCreateOps({ nodes, level, levels, preset, pos
         const rebase = constructionChanges.find((change) => change.id === node.id);
         return [{ id: node.id, data: { ...data, ...rebase?.data } }];
     });
-    return {
-        createOps: created.map((node) => ({
+    // The copy's roofs on its walls go to the level above it, as every roof writer seats them.
+    const seated = seatRoofs(nodes, {
+        create: created.map((node) => ({
             node,
             parentId: node.id === newLevelId
-                ? parentBuildingId
+                ? (parentBuildingId ?? undefined)
                 : (node.parentId ?? undefined),
         })),
+        update: updateOps,
+    });
+    return {
+        createOps: seated.changes.create,
         newLevelId,
         shiftedLevels,
-        updateOps,
+        updateOps: seated.changes.update,
         skippedNodes: clonedNodes.filter((node) => !keptIds.has(node.id)),
+        notes: seated.notes,
     };
 }

package/dist/building/level-insertion.d.ts

@@ -0,0 +1,55 @@
+import { type AnyNode, type AnyNodeId } from '../schema/index.js';
+/**
+ * A new floor under the building's lowest, as the editor's "+" below makes it, without lifting the
+ * building. Levels stack from the lowest one's own `baseElevation`, so a new lowest floor left at 0
+ * would push every floor above it up by its height: a basement added to a house stood the house on
+ * the ground a storey too high (and a second basement, two storeys). The new floor takes the offset
+ * that puts it one storey under where the lowest floor stood, and the old lowest floor gives its own
+ * offset up, so every existing floor keeps its place. One change set, one undo step.
+ */
+export declare function buildLevelBelowChanges({ nodes, buildingId, height, }: {
+    nodes: Readonly<Record<string, AnyNode>>;
+    buildingId: string;
+    height: number;
+}): {
+    newLevel: {
+        object: "node";
+        name?: string | undefined;
+        parentId: string | null;
+        visible: boolean;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "orthographic" | "perspective";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        metadata: Record<string, unknown>;
+        provenance?: {
+            refs: {
+                ns?: string | undefined;
+                id: string;
+                role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+            }[];
+            lineage?: {
+                op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        id: `level_${string}`;
+        type: "level";
+        children: (`block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`)[];
+        level: number;
+        baseElevation: number;
+        height?: number | undefined;
+    };
+    create: {
+        node: AnyNode;
+        parentId: AnyNodeId;
+    }[];
+    update: {
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }[];
+};
+//# sourceMappingURL=level-insertion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"level-insertion.d.ts","sourceRoot":"","sources":["../../src/building/level-insertion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,WAAW,CAAA;AAGnE;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,UAAU,EACV,MAAM,GACP,EAAE;IACD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;CACf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsBgC,OAAO;kBAA0B,SAAS;;;YAG7C,SAAS;cAAgC,OAAO,CAAC,OAAO,CAAC;;EAGtF"}

package/dist/building/level-insertion.js

@@ -0,0 +1,35 @@
+import { LevelNode } from '../schema/index.js';
+import { getAuthoredLevelElevations } from '../services/storey.js';
+/**
+ * A new floor under the building's lowest, as the editor's "+" below makes it, without lifting the
+ * building. Levels stack from the lowest one's own `baseElevation`, so a new lowest floor left at 0
+ * would push every floor above it up by its height: a basement added to a house stood the house on
+ * the ground a storey too high (and a second basement, two storeys). The new floor takes the offset
+ * that puts it one storey under where the lowest floor stood, and the old lowest floor gives its own
+ * offset up, so every existing floor keeps its place. One change set, one undo step.
+ */
+export function buildLevelBelowChanges({ nodes, buildingId, height, }) {
+    const building = nodes[buildingId];
+    const levels = (building?.type === 'building' ? building.children : []).flatMap((id) => {
+        const level = nodes[id];
+        return level?.type === 'level' ? [level] : [];
+    });
+    const lowest = levels.reduce((low, level) => (low === null || level.level < low.level ? level : low), null);
+    const standsAt = lowest
+        ? (getAuthoredLevelElevations(nodes).get(lowest.id)?.baseY ?? lowest.baseElevation)
+        : 0;
+    const newLevel = LevelNode.parse({
+        level: (lowest?.level ?? 1) - 1,
+        height,
+        children: [],
+        parentId: buildingId,
+        baseElevation: lowest ? standsAt - height : 0,
+    });
+    return {
+        newLevel,
+        create: [{ node: newLevel, parentId: buildingId }],
+        update: lowest && lowest.baseElevation !== 0
+            ? [{ id: lowest.id, data: { baseElevation: 0 } }]
+            : [],
+    };
+}

package/dist/building/merge-windows.d.ts

@@ -0,0 +1,58 @@
+import { type AgentRefusal } from '../agent-tools/refusal.js';
+import type { AnyNode, AnyNodeId, WindowNode } from '../schema/index.js';
+/**
+ * Two windows that exist become one: the one operation behind the editor's Merge windows button,
+ * Wrap the corner when a window already waits at the corner, and the agents' `merge_windows`.
+ *
+ * On two walls that meet at a corner, each reaching it within `CORNER_REACH_M`, they become one
+ * corner window: both adopted, each slid to the corner keeping its width, the glass fused, one sill.
+ * Side by side on one wall with at most `MERGE_GAP_M` between them and nothing between, they
+ * become one window spanning both outer edges. The first window named is the one whose height, sill
+ * and type (corner) or type and style (one wall) the result keeps. A `corner` either had that no
+ * longer makes a pair (its partner moved off the corner) is cleared on both sides.
+ */
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** The widest gap between two windows on one wall that still merges them (m). */
+export declare const MERGE_GAP_M = 0.3;
+export type WindowMerge = {
+    kind: 'corner' | 'same-wall';
+    /** The windows that stay, in the order named. */
+    windowIds: string[];
+    /** The window that went into the first (a merge on one wall). */
+    removedIds: string[];
+    wallIds: string[];
+    /** The bottom edge of the result (m). */
+    sillHeight: number;
+    height: number;
+    /** The width of the merged window (a merge on one wall). */
+    width?: number;
+    /** The angle the walls make (a corner). */
+    angle?: number;
+    changes: {
+        update: {
+            id: AnyNodeId;
+            data: Partial<WindowNode>;
+        }[];
+        delete: AnyNodeId[];
+    };
+    message: string;
+};
+/**
+ * The plan to merge two windows, or a refusal that says why. Pure: `changes` is for the caller to
+ * apply (the editor's store, an agent operation's `SceneChanges`).
+ */
+export declare function mergeWindows(nodes: Nodes, firstId: string, secondId: string): WindowMerge;
+/**
+ * What the Merge windows button does for a selection: nothing unless exactly two windows are
+ * selected; otherwise the merge they would make, or the refusal, whose code and details the panel
+ * words for a person (its message is written for agents, with node ids and metres).
+ */
+export declare function windowMergeOffer(nodes: Nodes, selectedIds: readonly string[]): {
+    merge: WindowMerge;
+    refusal: null;
+} | {
+    merge: null;
+    refusal: AgentRefusal;
+} | null;
+export {};
+//# sourceMappingURL=merge-windows.d.ts.map

package/dist/building/merge-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-windows.d.ts","sourceRoot":"","sources":["../../src/building/merge-windows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAA0B,MAAM,wBAAwB,CAAA;AAalF,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAY,UAAU,EAAE,MAAM,WAAW,CAAA;AAGzE;;;;;;;;;;GAUG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAE9C,iFAAiF;AACjF,eAAO,MAAM,WAAW,MAAM,CAAA;AAa9B,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAA;IAC5B,iDAAiD;IACjD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,iEAAiE;IACjE,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE;QAAE,MAAM,EAAE;YAAE,EAAE,EAAE,SAAS,CAAC;YAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;SAAE,EAAE,CAAC;QAAC,MAAM,EAAE,SAAS,EAAE,CAAA;KAAE,CAAA;IACxF,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAqCD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAuBzF;AA2JD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAAG,IAAI,CASvF"}

package/dist/building/merge-windows.js

@@ -0,0 +1,189 @@
+import { isAgentRefusal, refuse } from '../agent-tools/refusal.js';
+import { CORNER_REACH_M, cornerAngle, cornerLinkClears, cornerPair, fusesAtCorner, isWrappableAngle, wallEndPoint, wallLengthOf, windowEndGap, } from '../lib/corner-pair.js';
+import { findWallChildOverlap, resolveWallOpeningCeiling } from './wall-openings.js';
+/** The widest gap between two windows on one wall that still merges them (m). */
+export const MERGE_GAP_M = 0.3;
+/** What two windows share on a corner window: the second takes the first's. */
+const SHARED = [
+    'height',
+    'windowType',
+    'frameThickness',
+    'frameDepth',
+    'sill',
+    'sillDepth',
+    'sillThickness',
+];
+const metres = (value) => `${value.toFixed(2)} m`;
+const round = (value) => Math.round(value * 100) / 100;
+function windowOf(nodes, id) {
+    const node = nodes[id];
+    if (!node)
+        refuse('window_not_found', `Window not found: ${id}.`, { windowId: id });
+    if (node.type !== 'window')
+        refuse('not_a_window', `Node ${id} is a ${node.type}, not a window.`, {
+            windowId: id,
+            type: node.type,
+        });
+    const window = node;
+    const wall = nodes[window.parentId ?? ''];
+    if (wall?.type !== 'wall')
+        refuse('window_not_on_wall', `Window ${id} is not on a straight wall (a roof or dormer window), so it cannot join another.`, { windowId: id });
+    return { window, wall: wall };
+}
+const sillOf = (window) => window.position[1] - window.height / 2;
+const headOf = (window) => window.position[1] + window.height / 2;
+/** The shared point of two walls' ends, with the end of each there; null when they share none. */
+function sharedCorner(a, b) {
+    for (const endA of ['start', 'end'])
+        for (const endB of ['start', 'end']) {
+            const [p, q] = [wallEndPoint(a, endA), wallEndPoint(b, endB)];
+            if (Math.hypot(p[0] - q[0], p[1] - q[1]) <= 1e-3)
+                return { endA, endB, point: p };
+        }
+    return null;
+}
+/**
+ * The plan to merge two windows, or a refusal that says why. Pure: `changes` is for the caller to
+ * apply (the editor's store, an agent operation's `SceneChanges`).
+ */
+export function mergeWindows(nodes, firstId, secondId) {
+    if (firstId === secondId)
+        refuse('same_window', 'Pick two different windows to merge.');
+    const first = windowOf(nodes, firstId);
+    const second = windowOf(nodes, secondId);
+    for (const [mine, other] of [
+        [first.window, second.window],
+        [second.window, first.window],
+    ]) {
+        const partnerId = cornerPair(nodes, mine)?.partner.id;
+        if (partnerId === other.id)
+            refuse('windows_already_joined', `${mine.id} and ${other.id} already wrap this corner.`, {
+                windowIds: [mine.id, other.id],
+            });
+        if (partnerId)
+            refuse('window_already_joined', `Window ${mine.id} already wraps a corner with ${partnerId}; unwrap it before joining it to ${other.id}.`, { windowId: mine.id, partnerId });
+    }
+    return first.wall.id === second.wall.id
+        ? mergeOnOneWall(nodes, first, second)
+        : mergeAtCorner(nodes, first, second);
+}
+/** The links the merged windows' old, broken pairs leave on windows other than these two. */
+function brokenLinkClears(nodes, ...windows) {
+    const ids = new Set(windows.map((window) => window.id));
+    return windows
+        .flatMap((window) => cornerLinkClears(nodes, window.id))
+        .filter(({ id }) => !ids.has(id))
+        .map(({ id, data }) => ({ id: id, data: data }));
+}
+function mergeOnOneWall(nodes, first, second) {
+    const wall = first.wall;
+    const [a, b] = [first.window, second.window];
+    const [leftOf, rightOf] = a.position[0] <= b.position[0] ? [a, b] : [b, a];
+    const gap = rightOf.position[0] - rightOf.width / 2 - (leftOf.position[0] + leftOf.width / 2);
+    if (gap > MERGE_GAP_M + 1e-9)
+        refuse('windows_not_adjacent', `${a.id} and ${b.id} are ${metres(gap)} apart on wall ${wall.id}; windows join when at most ${metres(MERGE_GAP_M)} separates them.`, { windowIds: [a.id, b.id], gap, limit: MERGE_GAP_M });
+    // The union of the two: a window inside the other, or wider than it, does not shrink it.
+    const outerLeft = Math.min(a.position[0] - a.width / 2, b.position[0] - b.width / 2);
+    const outerRight = Math.max(a.position[0] + a.width / 2, b.position[0] + b.width / 2);
+    const bottom = Math.min(sillOf(a), sillOf(b));
+    const top = Math.max(headOf(a), headOf(b));
+    const centre = [(outerLeft + outerRight) / 2, (bottom + top) / 2];
+    const between = findWallChildOverlap(wall.id, nodes, centre[0], centre[1], outerRight - outerLeft, top - bottom, [a.id, b.id]);
+    if (between)
+        refuse('opening_between', `${between.type === 'item' ? 'An item' : `A ${between.type}`}, ${between.id}, sits between ${a.id} and ${b.id} on wall ${wall.id}, so they cannot become one window.`, { windowIds: [a.id, b.id], blockingId: between.id });
+    const width = outerRight - outerLeft;
+    return {
+        kind: 'same-wall',
+        windowIds: [a.id],
+        removedIds: [b.id],
+        wallIds: [wall.id],
+        sillHeight: bottom,
+        height: top - bottom,
+        width,
+        changes: {
+            update: [
+                {
+                    id: a.id,
+                    data: {
+                        width,
+                        height: top - bottom,
+                        position: [centre[0], centre[1], a.position[2]],
+                        ...(a.corner ? { corner: undefined } : {}),
+                    },
+                },
+                ...brokenLinkClears(nodes, a, b),
+            ],
+            delete: [b.id],
+        },
+        message: `Merged ${b.id} into ${a.id}: one window ${metres(width)} wide on wall ${wall.id}, from a sill of ${metres(bottom)} to ${metres(top)}. Its type and style are ${a.id}'s, the window named first.`,
+    };
+}
+function mergeAtCorner(nodes, first, second) {
+    const [a, b] = [first.window, second.window];
+    const joint = sharedCorner(first.wall, second.wall);
+    if (!joint || first.wall.parentId !== second.wall.parentId)
+        refuse('walls_not_meeting', `Wall ${first.wall.id} and wall ${second.wall.id} do not meet at a corner, so ${a.id} and ${b.id} cannot wrap one. On one wall, windows side by side merge instead.`, { wallIds: [first.wall.id, second.wall.id] });
+    const angle = cornerAngle({ wall: first.wall, end: joint.endA }, { wall: second.wall, end: joint.endB });
+    if (!isWrappableAngle(angle))
+        refuse('corner_angle', `The walls meet at ${Math.round(angle)}°: too close to ${angle < 90 ? 'folded back' : 'straight'} for a corner window.`, { angle });
+    const sides = [
+        { ...first, end: joint.endA },
+        { ...second, end: joint.endB },
+    ];
+    for (const { window, wall, end } of sides) {
+        const gap = windowEndGap(wall, window, end);
+        if (gap > CORNER_REACH_M + 1e-9)
+            refuse('window_not_at_corner', `Window ${window.id} is ${metres(gap)} from the corner of wall ${wall.id}; a window joins a corner window when it is within ${metres(CORNER_REACH_M)} of the corner.`, { windowId: window.id, gap, limit: CORNER_REACH_M });
+    }
+    const ceiling = resolveWallOpeningCeiling(second.wall, nodes);
+    if (headOf(a) > ceiling + 1e-6)
+        refuse('height_exceeds_wall', `Window ${a.id} is taller than wall ${second.wall.id} (${metres(headOf(a))} against ${metres(ceiling)}), so ${b.id} cannot take its height and sill. Name the other window first, or lower ${a.id}.`, { windowId: b.id, wallId: second.wall.id });
+    // Each side slides to the corner, keeping its width, if no other opening is in the way.
+    const post = fusesAtCorner(a) ? 'none' : 'post';
+    const centreAt = (window, wall, end) => end === 'start' ? window.width / 2 : wallLengthOf(wall) - window.width / 2;
+    const placed = sides.map(({ window, wall, end }, index) => {
+        const x = centreAt(window, wall, end);
+        const y = a.position[1];
+        const blocking = findWallChildOverlap(wall.id, nodes, x, y, window.width, a.height, window.id);
+        if (blocking)
+            refuse('opening_overlap', `Sliding ${window.id} to the corner of wall ${wall.id} would overlap ${blocking.type} ${blocking.id}.`, { windowId: window.id, blockingId: blocking.id });
+        const corner = { end, partnerId: sides[1 - index].window.id, post };
+        const aligned = index === 0
+            ? {}
+            : Object.fromEntries(SHARED.map((key) => [key, a[key]]).filter(([, v]) => v !== undefined));
+        return {
+            id: window.id,
+            data: { ...aligned, position: [x, y, window.position[2]], corner },
+        };
+    });
+    return {
+        kind: 'corner',
+        windowIds: [a.id, b.id],
+        removedIds: [],
+        wallIds: [first.wall.id, second.wall.id],
+        sillHeight: sillOf(a),
+        height: a.height,
+        angle: round(angle),
+        changes: { update: [...placed, ...brokenLinkClears(nodes, a, b)], delete: [] },
+        message: `Joined ${a.id} and ${b.id} as one corner window across ${first.wall.id} and ${second.wall.id} (${Math.round(angle)}°), ${post === 'none' ? 'the glass fused at the corner' : `the ${a.windowType} frames meeting at the corner`}. Both take ${a.id}'s height and sill (${metres(a.height)} tall from ${metres(sillOf(a))}) and type, as it was named first.`,
+    };
+}
+/**
+ * What the Merge windows button does for a selection: nothing unless exactly two windows are
+ * selected; otherwise the merge they would make, or the refusal, whose code and details the panel
+ * words for a person (its message is written for agents, with node ids and metres).
+ */
+export function windowMergeOffer(nodes, selectedIds) {
+    if (selectedIds.length !== 2)
+        return null;
+    if (selectedIds.some((id) => nodes[id]?.type !== 'window'))
+        return null;
+    try {
+        return { merge: mergeWindows(nodes, selectedIds[0], selectedIds[1]), refusal: null };
+    }
+    catch (error) {
+        if (isAgentRefusal(error))
+            return { merge: null, refusal: error };
+        throw error;
+    }
+}

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

@@ -5,7 +5,7 @@
  * 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 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. */
@@ -22,7 +22,7 @@ export type DoorStyleLook = {
 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 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'

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

@@ -1 +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"}
+{"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,YACtB,OAAO,EACP,OAAO,EACP,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,WAAW,EACX,eAAe,EACf,MAAM,CACE,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,YACxB,QAAQ,EACR,aAAa,EACb,aAAa,EACb,UAAU,EACV,SAAS,EACT,MAAM,EACN,WAAW,EACX,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,SAAS,CACD,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/photo-elevation.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Straightening a photo of a flat face: the plane-to-plane perspective transform (a homography)
+ * between metres on the face and pixels in the photo, and the warp that draws the face head-on.
+ * Several faces of one photo share its camera: the vanishing points of their lines give its focal
+ * length and rotation, and each face's homography is K·[along up origin].
+ * Pure over numbers and RGBA buffers, so the chat (canvas) and the MCP (any codec) share it.
+ */
+type Pt = [number, number];
+type Segment = readonly [Pt, Pt];
+export type Vec3 = [number, number, number];
+/**
+ * Row-major 3 × 3. A fitted one has `h[8]` normalised to 1; a camera's keeps its third row as the
+ * depth in metres, positive in front of the camera.
+ */
+export type Homography = number[];
+export type RgbaImage = {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};
+export declare function applyHomography(h: Homography, [x, y]: Pt): Pt | null;
+export declare function multiplyHomography(a: Homography, b: Homography): Homography;
+export declare function invertHomography(h: Homography): Homography | null;
+/**
+ * The homography taking each `from` to its `to`, fitted over all pairs by least squares on
+ * conditioned coordinates, so one point picked a few pixels off moves the fit, not breaks it.
+ * Null for fewer than four pairs or points that do not span the plane.
+ */
+export declare function solveHomography(pairs: readonly {
+    from: Pt;
+    to: Pt;
+}[]): Homography | null;
+/** Where the lines through `a` and through `b` cross; null when they are parallel. */
+export declare function lineIntersection(a: readonly [Pt, Pt], b: readonly [Pt, Pt]): Pt | null;
+type PhotoSize = {
+    width: number;
+    height: number;
+};
+/**
+ * Where lines that are parallel on the building meet in the photo: their vanishing point, as a unit
+ * homogeneous point (x, y, w) about the photo's centre with its longer side as unit, so lines
+ * parallel in the photo give w = 0 (a point at infinity) instead of a division by zero. Least
+ * squares over all the lines, each weighted by its length. Null for fewer than two distinct lines.
+ */
+export declare function vanishingPoint(segments: readonly Segment[], photo: PhotoSize): Vec3 | null;
+/** Root mean square distance, in photo pixels, of each segment's ends from the line through its middle and `direction`'s vanishing point. */
+export declare function vanishingResidualPx(camera: PhotoCamera, direction: Vec3, segments: readonly Segment[]): number;
+/**
+ * The photo's camera: square pixels, no skew, no lens distortion (straight lines stay straight).
+ * The principal point is at the photo's centre across; its height is fitted, since a
+ * perspective-corrected or shift photo keeps verticals parallel by moving it toward the horizon.
+ */
+export type PhotoCamera = {
+    width: number;
+    height: number;
+    /** Focal length, in photo pixels. */
+    focal: number;
+    /** Where the optical axis meets the photo, in photo pixels. */
+    centre: Pt;
+    /** World up, in camera coordinates: x right, y down, z forward. */
+    up: Vec3;
+};
+/** A face's axes in camera coordinates: along it left to right as seen, up, and out toward the camera. */
+export type FaceAxes = {
+    along: Vec3;
+    up: Vec3;
+    normal: Vec3;
+};
+/** A face's plane: its axes, and `normal · P` of its points, negative since it faces the camera. */
+export type CameraFace = FaceAxes & {
+    distance: number;
+};
+export type CameraFailure = 'needs_second_direction' | 'at_infinity' | 'unsolved';
+/**
+ * The photo's camera from vanishing points (from `vanishingPoint`): the vertical one when the
+ * verticals were picked, one per face, and which faces meet at a right angle. First the focal
+ * length and the principal point's height (`focalAndCentre`), then the rotation: up from the
+ * verticals (or across two faces), each face's direction from its vanishing point, made level, and
+ * turned so the face looks at the camera (`probe` is a photo pixel on it). `focalSpread` is the
+ * ratio between the largest and the smallest focal length the well-placed pairs give on their own:
+ * 1 when they agree.
+ */
+export declare function solvePhotoCamera(input: {
+    photo: PhotoSize;
+    vertical: Vec3 | null;
+    faces: readonly {
+        vanishing: Vec3;
+        probe: Pt;
+    }[];
+    perpendicular: readonly (readonly [number, number])[];
+}): {
+    camera: PhotoCamera;
+    faces: FaceAxes[];
+    focalSpread: number;
+} | {
+    failure: CameraFailure;
+};
+/** The ray from the camera through a photo pixel, in camera coordinates (its depth is 1). */
+export declare function photoRay(camera: PhotoCamera, [x, y]: Pt): Vec3;
+/** Where a photo pixel's ray meets a face's plane, in camera coordinates; null behind the camera. */
+export declare function pointOnFace(camera: PhotoCamera, face: CameraFace, pixel: Pt): Vec3 | null;
+/** A photo pixel's place on a face, (along, up) in the face's units, from where its normal meets it. */
+export declare function faceCoordinates(camera: PhotoCamera, face: CameraFace, pixel: Pt): Pt | null;
+/**
+ * The plane of a face from the camera and its two vertical edges `width` apart (the walls' extent):
+ * the one distance that puts them so far apart. Null when the edges come out the wrong way round.
+ */
+export declare function faceAtWidth(camera: PhotoCamera, axes: FaceAxes, edges: {
+    left: readonly Pt[];
+    right: readonly Pt[];
+}, width: number): CameraFace | null;
+/** The plane of a face through the corner it shares with another: `corner` is that edge's pixels. */
+export declare function faceThroughCorner(camera: PhotoCamera, axes: FaceAxes, other: CameraFace, corner: readonly Pt[]): CameraFace | null;
+/**
+ * Metres on a face, from `origin` (its face coordinates), to photo pixels: K·[along up origin].
+ * Its third row is the depth in metres, so a point behind the camera has w < 0.
+ */
+export declare function cameraFaceHomography(camera: PhotoCamera, face: CameraFace, origin: Pt): Homography;
+/**
+ * An image `width` × `height` whose every pixel samples `src` (bilinear) where `toSource` maps
+ * its centre. What falls outside the source stays transparent.
+ */
+export declare function warpImage(src: RgbaImage, toSource: Homography, width: number, height: number): RgbaImage;
+export {};
+//# sourceMappingURL=photo-elevation.d.ts.map

package/dist/building/photo-elevation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"photo-elevation.d.ts","sourceRoot":"","sources":["../../src/building/photo-elevation.ts"],"names":[],"mappings":"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"}