@pascal-app/core 1.0.5 → 1.0.7

package/dist/building/wall-openings.d.ts.map

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

package/dist/building/wall-openings.js

@@ -1,14 +1,18 @@
 import { refuseParamsWithoutScript } from '../agent-operations/add-object.js';
 import { refuse } from '../agent-tools/refusal.js';
+import { doorPositionForFacing, getDoorOpeningSize } from '../lib/door-opening.js';
 import { matchScriptSlotsToLibrary, requireMeasured, scriptedSize, scriptSource, } from '../lib/geometry-script-node.js';
-import { wallSupportForNodes } from '../lib/opening-floor-datum.js';
+import { openingHostFacing } from '../lib/opening-casing.js';
+import { wallBottomUnderOpening, wallSupportForNodes } from '../lib/opening-floor-datum.js';
 import { DoorNode, getScaledDimensions, WindowNode, } from '../schema/index.js';
 import { getCurtainWallConfig } from '../schema/nodes/curtain-wall.js';
+import { isRailingWall, railingOpeningFields } from '../schema/nodes/railing-wall.js';
 import { getWallTop } from '../services/storey.js';
 import { resolveWallExteriorSide } from '../systems/wall/wall-assembly.js';
 import { getWallCurveLength, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { doorTypeFields, NEW_DOOR_FRAME_THICKNESS } from './door-types.js';
 import { doorStyleLook, getWindowStyleOverrides, } from './opening-style-presets.js';
-import { windowTakesStyle } from './window-types.js';
+import { NEW_WINDOW_FRAME_THICKNESS, windowTakesStyle, windowTypeFields } from './window-types.js';
 /** 1 µm: below any buildable difference, above floating-point noise. */
 const TOUCHING = 1e-6;
 const lengthOf = (wall) => Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
@@ -25,19 +29,35 @@ export function resolveWallOpeningCeiling(wall, nodes) {
 /** A curtain wall keeps its perimeter frame clear of openings. */
 const openingMargin = (wall) => wall.wallType === 'curtain' ? getCurtainWallConfig(wall).perimeterWidth : 0;
 /** A door's centre: slid along the wall to stay on it, standing on the floor. */
-export function clampDoorToWall(wall, localX, width, height) {
+export function clampDoorToWall(wall, localX, width, height, door, nodes = {}) {
     const margin = openingMargin(wall);
     const length = getWallCurveLength(wall);
-    const clampedX = Math.max(margin + width / 2, Math.min(length - margin - width / 2, localX));
-    return { clampedX, clampedY: height / 2 };
+    const size = getDoorOpeningSize({ ...door, width, height });
+    const offset = size.leafOffsetX * openingHostFacing(door ?? {});
+    const clampedX = Math.max(margin + size.width / 2, Math.min(length - margin - size.width / 2, localX - offset)) +
+        offset;
+    const transomHeight = door?.transomHeight !== undefined && size.height > height
+        ? Math.min(door.transomHeight, Math.max(0, resolveWallOpeningCeiling(wall, nodes) - margin - height))
+        : undefined;
+    return {
+        clampedX,
+        clampedY: height / 2,
+        ...(transomHeight === undefined ? {} : { transomHeight }),
+    };
 }
-/** A window's centre: slid to stay on the wall, and between the floor and the wall's ceiling. */
+/**
+ * A window's centre: slid to stay on the wall, and between the wall's bottom and its ceiling. The
+ * bottom is the floor, or lower where the wall fills down beside a sunken floor (a garage).
+ */
 export function clampWindowToWall(wall, localX, localY, width, height, nodes) {
     const ceiling = resolveWallOpeningCeiling(wall, nodes);
     const margin = openingMargin(wall);
     const length = getWallCurveLength(wall);
     const clampedX = Math.max(margin + width / 2, Math.min(length - margin - width / 2, localX));
-    const clampedY = Math.max(margin + height / 2, Math.min(ceiling - margin - height / 2, localY));
+    const support = wallSupportForNodes(wall, nodes);
+    const floor = Math.min(0, wallBottomUnderOpening(wall, { position: [clampedX, 0, 0], width }, support) -
+        support.elevation);
+    const clampedY = Math.max(floor + margin + height / 2, Math.min(ceiling - margin - height / 2, localY));
     return { clampedX, clampedY };
 }
 /**
@@ -74,11 +94,12 @@ export function findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, h
             childTop = item.position[1] + h;
         }
         else if (child.type === 'window' || child.type === 'door') {
-            const opening = child;
-            childLeft = opening.position[0] - opening.width / 2;
-            childRight = opening.position[0] + opening.width / 2;
-            childBottom = opening.position[1] - opening.height / 2;
-            childTop = opening.position[1] + opening.height / 2;
+            const size = child.type === 'door' ? getDoorOpeningSize(child) : { ...child, leafOffsetX: 0 };
+            const centerX = child.position[0] - size.leafOffsetX * openingHostFacing(child);
+            childLeft = centerX - size.width / 2;
+            childRight = centerX + size.width / 2;
+            childBottom = child.position[1] - child.height / 2;
+            childTop = childBottom + size.height;
         }
         else {
             continue;
@@ -161,6 +182,10 @@ export function planWallOpening(nodes, input) {
     const wall = host;
     if (isCurvedWall(wall))
         refuse('curved_wall', `Wall ${wallId} is curved; doors and windows go on straight walls, as in the editor.`, { wallId });
+    // A railing's openings are gaps in its guard: a door becomes one, a window has none to fill.
+    if (kind === 'window' && isRailingWall(wall))
+        refuse('railing_window', `Wall ${wallId} is a railing: it takes a door, which becomes a gap in the guard, not a window.`, { wallId });
+    const railingGap = kind === 'door' && isRailingWall(wall) ? railingOpeningFields(wall) : null;
     const { t, position } = input;
     if (t !== undefined && position !== undefined && Math.abs(t - position) > 1e-9)
         refuse('conflicting_position', `t (${t}) and position (${position}) disagree; they are the same field, pass one.`, { t, position });
@@ -179,23 +204,41 @@ export function planWallOpening(nodes, input) {
         requireMeasured(compiled, { label: `A ${kind}`, tool: `add_${kind}` });
     const [scriptedWidth, scriptedHeight] = compiled ? scriptedSize(compiled.manifest) : [];
     const width = scriptedWidth ?? input.width ?? DEFAULTS[kind].width;
-    const height = scriptedHeight ?? input.height ?? DEFAULTS[kind].height;
+    const height = railingGap?.height ?? scriptedHeight ?? input.height ?? DEFAULTS[kind].height;
+    const size = kind === 'door'
+        ? getDoorOpeningSize({
+            ...input,
+            ...(railingGap ? { openingKind: 'opening' } : {}),
+            width,
+            height,
+            ...(compiled ? { source: scriptSource(compiled, input) } : {}),
+        })
+        : { width, height, leafOffsetX: 0 };
     const wallLength = lengthOf(wall);
-    if (wallLength < width)
+    if (wallLength < size.width)
         refuse('wall_too_short', `Wall ${wallId} is ${metres(wallLength)} long, too short for a ${metres(width)} ${kind}.`, { wallId, wallLength, width });
+    if (kind === 'door') {
+        const wallHeight = resolveWallOpeningCeiling(wall, nodes) - openingMargin(wall);
+        if (size.height > wallHeight + TOUCHING)
+            refuse('wall_too_low', `Wall ${wallId} is ${metres(wallHeight)} high, too low for a ${metres(size.height)} door.`, { wallId, wallHeight, height: size.height });
+    }
     const rawX = along * wallLength;
     // A window with no sill given is centred on its wall, taller than the wall or not: the clamp
-    // below stands one that is too tall on the floor and reports it clamped.
-    const rawY = kind === 'door'
-        ? height / 2
-        : input.sillHeight === undefined
-            ? resolveWallOpeningCeiling(wall, nodes) / 2
-            : input.sillHeight + height / 2;
-    const { clampedX, clampedY } = kind === 'door'
-        ? clampDoorToWall(wall, rawX, width, height)
-        : clampWindowToWall(wall, rawX, rawY, width, height, nodes);
+    // below stands one that is too tall on the floor and reports it clamped. A door stands on the
+    // floor unless given a sill (rare: down to a floor sunk beside the wall); with one it keeps
+    // between the wall's bottom and its ceiling, as a window does. A railing's gap is on the floor.
+    const sill = railingGap ? undefined : input.sillHeight;
+    const onFloor = kind === 'door' && sill === undefined;
+    const rawY = sill !== undefined
+        ? sill + height / 2
+        : kind === 'door'
+            ? height / 2
+            : resolveWallOpeningCeiling(wall, nodes) / 2;
+    const { clampedX, clampedY } = onFloor
+        ? clampDoorToWall(wall, rawX, size.width, size.height)
+        : clampWindowToWall(wall, rawX, rawY + (size.height - height) / 2, size.width, size.height, nodes);
     if (!input.force) {
-        const blocking = findWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height);
+        const blocking = findWallChildOverlap(wallId, nodes, clampedX, clampedY, size.width, size.height);
         if (blocking) {
             const span = blocking.type === 'item'
                 ? getScaledDimensions(blocking)[0]
@@ -214,12 +257,14 @@ export function planWallOpening(nodes, input) {
     const base = {
         ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
         name: input.name ?? `${kind === 'door' ? 'Door' : 'Window'} ${siblings + 1}`,
-        position: [clampedX, clampedY, 0],
+        position: [clampedX + size.leafOffsetX, clampedY - (size.height - height) / 2, 0],
         rotation: [0, 0, 0],
         wallId,
         parentId: wallId,
         width,
         height,
+        casingFaceA: true,
+        casingFaceB: true,
         ...(input.openingShape ? { openingShape: input.openingShape } : {}),
         ...(input.archHeight === undefined ? {} : { archHeight: Math.min(input.archHeight, height) }),
         ...(input.cornerRadius === undefined ? {} : { cornerRadius: input.cornerRadius }),
@@ -233,27 +278,74 @@ export function planWallOpening(nodes, input) {
     const node = kind === 'door'
         ? DoorNode.parse({
             ...base,
+            ...(input.doorType ? doorTypeFields(input.doorType) : {}),
+            frameThickness: NEW_DOOR_FRAME_THICKNESS,
             ...doorFacing(wall),
+            position: doorPositionForFacing({ ...input, ...base, ...railingGap }, doorFacing(wall).rotation),
             ...doorHardwareSides(input),
+            handleStyle: input.handleStyle,
             swingDirection: input.swingDirection ?? 'inward',
+            sidelightLeft: input.sidelightLeft,
+            sidelightRight: input.sidelightRight,
+            transomHeight: input.transomHeight,
+            ...(input.leafCount === undefined ? {} : { leafCount: input.leafCount }),
+            slidingStyle: input.slidingStyle,
+            ...(input.slideDirection ? { slideDirection: input.slideDirection } : {}),
             ...(input.style ? doorStyleLook(input.style) : {}),
             ...(input.doorType ? { doorType: input.doorType } : {}),
             ...(input.openingKind ? { openingKind: input.openingKind } : {}),
+            ...railingGap,
         })
         : WindowNode.parse({
             ...base,
+            frameThickness: NEW_WINDOW_FRAME_THICKNESS,
             ...getWindowStyleOverrides(input.style),
-            ...(input.windowType ? { windowType: input.windowType } : {}),
+            ...windowTypeFields(windowType),
+            ...(input.hingesSide === undefined ? {} : { hingesSide: input.hingesSide }),
             ...(input.columns ? { columnRatios: equalRatios(input.columns) } : {}),
             ...(input.rows ? { rowRatios: equalRatios(input.rows) } : {}),
+            ...(input.windowType &&
+                !windowTakesStyle(input.windowType) &&
+                (input.columns || input.rows)
+                ? { sashGrid: true }
+                : input.sashGrid === undefined
+                    ? {}
+                    : { sashGrid: input.sashGrid }),
+            ...(input.windowHandle === undefined ? {} : { windowHandle: input.windowHandle }),
+            ...(input.sillInterior === undefined ? {} : { sillInterior: input.sillInterior }),
+            ...(input.shutters === undefined ? {} : { shutters: input.shutters }),
+            ...(input.shutterWidth === undefined ? {} : { shutterWidth: input.shutterWidth }),
+            ...(input.openingDirection === undefined
+                ? {}
+                : { openingDirection: input.openingDirection }),
+            ...(input.tiltTurnMode === undefined ? {} : { tiltTurnMode: input.tiltTurnMode }),
+            ...(input.sillOverhang === undefined ? {} : { sillOverhang: input.sillOverhang }),
+            ...(input.sillInteriorDepth === undefined
+                ? {}
+                : { sillInteriorDepth: input.sillInteriorDepth }),
+            ...(input.sillInteriorThickness === undefined
+                ? {}
+                : { sillInteriorThickness: input.sillInteriorThickness }),
+            ...(input.sillInteriorOverhang === undefined
+                ? {}
+                : { sillInteriorOverhang: input.sillInteriorOverhang }),
+            ...(input.shutterOpen === undefined ? {} : { shutterOpen: input.shutterOpen }),
+            ...(input.shutterSides === undefined ? {} : { shutterSides: input.shutterSides }),
+            ...(input.rollerShutter === undefined ? {} : { rollerShutter: input.rollerShutter }),
+            ...(input.rollerShutterBoxHeight === undefined
+                ? {}
+                : { rollerShutterBoxHeight: input.rollerShutterBoxHeight }),
+            ...(input.rollerShutterOpen === undefined
+                ? {}
+                : { rollerShutterOpen: input.rollerShutterOpen }),
         });
     return {
         node,
         wallId,
-        localX: clampedX,
+        localX: node.position[0],
         t: along,
         wallLength,
-        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(clampedY - rawY) > 1e-9,
-        ...(kind === 'window' ? { sillHeight: clampedY - height / 2 } : {}),
+        clamped: Math.abs(clampedX - rawX) > 1e-9 || Math.abs(node.position[1] - rawY) > 1e-9,
+        ...(onFloor ? {} : { sillHeight: node.position[1] - height / 2 }),
     };
 }

package/dist/building/window-types.d.ts

@@ -1,5 +1,6 @@
 import type { WindowNode } from '../schema/index.js';
 import type { WindowType } from '../schema/nodes/opening-types.js';
+export declare const NEW_WINDOW_FRAME_THICKNESS = 0.02;
 /** The window types whose top takes a shape (rounded, arch); the others are rectangular. */
 export declare const SHAPED_WINDOW_TYPES: ReadonlySet<WindowType>;
 /** The window types that project from the wall and have no sill. */

package/dist/building/window-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-types.d.ts","sourceRoot":"","sources":["../../src/building/window-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAE/D,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,UAAU,CAMtD,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,UAAU,CAA2B,CAAA;AAErF,qGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE1D;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAMtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,EACtC,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAIrB"}
+{"version":3,"file":"window-types.d.ts","sourceRoot":"","sources":["../../src/building/window-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAG/D,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAE9C,4FAA4F;AAC5F,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,UAAU,CAMtD,CAAA;AAEF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,UAAU,CAA2B,CAAA;AAErF,qGAAqG;AACrG,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE1D;AAED,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAOtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,EACtC,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAIrB"}

package/dist/building/window-types.js

@@ -1,3 +1,5 @@
+// The schema keeps 0.05 m for saved windows that omit the field (E-003).
+export const NEW_WINDOW_FRAME_THICKNESS = 0.02;
 /** The window types whose top takes a shape (rounded, arch); the others are rectangular. */
 export const SHAPED_WINDOW_TYPES = new Set([
     'fixed',
@@ -16,6 +18,7 @@ export function windowTakesStyle(type) {
 export function windowTypeFields(type) {
     return {
         windowType: type,
+        ...(type === 'casement' || type === 'awning' ? { openingDirection: 'outward' } : {}),
         ...(SHAPED_WINDOW_TYPES.has(type) ? {} : { openingShape: 'rectangle' }),
         ...(SILLLESS_WINDOW_TYPES.has(type) ? { sill: false } : {}),
     };

package/dist/coherence/__fixtures__/enclosure-scenes.d.ts

@@ -0,0 +1,84 @@
+import { type AnyNode, WallNode } from '../../schema/index.js';
+/**
+ * Buildings under a roof, for the Enclosure family: where the roof sits against the wall tops.
+ * Built from the geometry alone (levels, explicit wall heights, a roof's pitch and seat), so a
+ * scene can be broken by one number. Plan axes: x east, z south; a wall drawn clockwise has its
+ * interior on the front side.
+ */
+export type EnclosureScene = {
+    nodes: Record<string, AnyNode>;
+    rootNodeIds: string[];
+};
+export declare function graph(...nodes: AnyNode[]): EnclosureScene;
+/** What a maker declares about a wall that meets a roof. */
+export type Declaration = {
+    roofJunction?: 'parapet';
+    cap?: boolean;
+};
+type Declarations = Declaration | (Declaration | undefined)[] | undefined;
+/** The four walls of a rectangle, drawn clockwise so the room is on their front side. */
+export declare function rectangleWalls(levelId: string, [x0, z0, x1, z1]: [number, number, number, number], heights: [number?, number?, number?, number?] | number | undefined, sides?: 'exterior' | 'interior', tag?: string, declare?: Declarations): WallNode[];
+export declare const building: () => {
+    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: `building_${string}`;
+    type: "building";
+    children: (`elevator_${string}` | `level_${string}` | `unit_${string}`)[];
+    position: [number, number, number];
+    rotation: [number, number, number];
+    groundLevelId?: `level_${string}` | undefined;
+};
+export declare const storey: (height: number) => {
+    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: (`beam_${string}` | `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;
+};
+export {};
+//# sourceMappingURL=enclosure-scenes.d.ts.map

package/dist/coherence/__fixtures__/enclosure-scenes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enclosure-scenes.d.ts","sourceRoot":"","sources":["../../../src/coherence/__fixtures__/enclosure-scenes.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EAQZ,QAAQ,EAET,MAAM,cAAc,CAAA;AAErB;;;;;GAKG;AAEH,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAEtF,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,cAAc,CAczD;AAID,4DAA4D;AAC5D,MAAM,MAAM,WAAW,GAAG;IAAE,YAAY,CAAC,EAAE,SAAS,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,CAAA;AACrE,KAAK,YAAY,GAAG,WAAW,GAAG,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,GAAG,SAAS,CAAA;AAEzE,yFAAyF;AACzF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClD,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,GAAG,SAAS,EAClE,KAAK,GAAE,UAAU,GAAG,UAAuB,EAC3C,GAAG,SAAS,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,QAAQ,EAAE,CAqBZ;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoD,CAAA;AACzE,eAAO,MAAM,MAAM,WAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOjC,CAAA"}

package/dist/coherence/__fixtures__/enclosure-scenes.js

@@ -0,0 +1,44 @@
+import { BuildingNode, CeilingNode, DoorNode, LevelNode, RoofNode, RoofSegmentNode, SlabNode, WallNode, ZoneNode, } from '../../schema/index.js';
+export function graph(...nodes) {
+    const byId = Object.fromEntries(nodes.map((node) => [node.id, { ...node }]));
+    for (const node of Object.values(byId)) {
+        const parent = node.parentId ? byId[node.parentId] : undefined;
+        if (parent && Array.isArray(parent.children) && !parent.children.includes(node.id))
+            parent.children = [...parent.children, node.id];
+    }
+    return {
+        nodes: byId,
+        rootNodeIds: nodes.filter((node) => node.type === 'building').map((node) => node.id),
+    };
+}
+/** The four walls of a rectangle, drawn clockwise so the room is on their front side. */
+export function rectangleWalls(levelId, [x0, z0, x1, z1], heights, sides = 'exterior', tag = 'wall', declare) {
+    const corners = [
+        [x0, z0],
+        [x1, z0],
+        [x1, z1],
+        [x0, z1],
+    ];
+    return corners.map((start, index) => {
+        const end = corners[(index + 1) % 4];
+        const height = Array.isArray(heights) ? heights[index] : heights;
+        return WallNode.parse({
+            id: `${tag}_${index}`,
+            parentId: levelId,
+            start,
+            end,
+            ...(height === undefined ? {} : { height }),
+            ...(Array.isArray(declare) ? declare[index] : declare),
+            frontSide: 'interior',
+            backSide: sides,
+        });
+    });
+}
+export const building = () => BuildingNode.parse({ id: 'building_main' });
+export const storey = (height) => LevelNode.parse({
+    id: 'level_0',
+    parentId: 'building_main',
+    level: 0,
+    name: 'Ground',
+    height,
+});

package/dist/commands/structure/attached-walls.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, AnyNodeId } from '../../schema/index.js';
+import { type WallPlanPoint } from '../../systems/wall/wall-move.js';
+/**
+ * The writes that keep walls T'd into a moving wall on it
+ * (`planAttachedWallUpdates`): each such wall's new ends and, where its start
+ * moved, the doors, windows and wall items on it shifted along so they stay
+ * where they were. A wall whose opening the stretch would leave off its ends
+ * lets go instead. The invisible walls on it come along too
+ * (`planAttachedSeparatorUpdates`), so a porch they close off it stays closed.
+ * `exclude` are walls the move already rewrites.
+ */
+export declare function planAttachedWallChanges(nodes: Readonly<Record<string, AnyNode>>, movingWallId: string, originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint, exclude?: ReadonlySet<string>): Array<{
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}>;
+//# sourceMappingURL=attached-walls.d.ts.map

package/dist/commands/structure/attached-walls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attached-walls.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/attached-walls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAA2B,MAAM,cAAc,CAAA;AAC/E,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAG1F;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,aAAa,EAC1B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,WAAW,CAAC,MAAM,CAAa,GACvC,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CA0DlD"}

package/dist/commands/structure/attached-walls.js

@@ -0,0 +1,53 @@
+import { planAttachedWallUpdates } from '../../systems/wall/wall-move.js';
+import { planAttachedSeparatorUpdates } from './move-separators.js';
+/**
+ * The writes that keep walls T'd into a moving wall on it
+ * (`planAttachedWallUpdates`): each such wall's new ends and, where its start
+ * moved, the doors, windows and wall items on it shifted along so they stay
+ * where they were. A wall whose opening the stretch would leave off its ends
+ * lets go instead. The invisible walls on it come along too
+ * (`planAttachedSeparatorUpdates`), so a porch they close off it stays closed.
+ * `exclude` are walls the move already rewrites.
+ */
+export function planAttachedWallChanges(nodes, movingWallId, originalStart, originalEnd, nextStart, nextEnd, exclude = new Set()) {
+    const moving = nodes[movingWallId];
+    if (moving?.type !== 'wall')
+        return [];
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' &&
+        node.parentId === moving.parentId &&
+        node.id !== moving.id &&
+        !exclude.has(node.id));
+    const children = Object.values(nodes).filter((node) => 'position' in node && Array.isArray(node.position) && node.parentId);
+    const changes = [];
+    for (const update of planAttachedWallUpdates(walls, originalStart, originalEnd, nextStart, nextEnd)) {
+        const wall = nodes[update.id];
+        const length = Math.hypot(update.end[0] - update.start[0], update.end[1] - update.start[1]);
+        const ux = (update.end[0] - update.start[0]) / length;
+        const uz = (update.end[1] - update.start[1]) / length;
+        // How far the old start sits along the wall from the new one.
+        const shift = (wall.start[0] - update.start[0]) * ux + (wall.start[1] - update.start[1]) * uz;
+        const hosted = children.filter((child) => child.parentId === wall.id);
+        const moved = hosted.map((child) => {
+            const position = child.position;
+            return { child, position, x: position[0] + shift };
+        });
+        if (moved.some(({ x }) => x < 0 || x > length))
+            continue;
+        changes.push({ id: wall.id, data: { start: update.start, end: update.end } });
+        if (Math.abs(shift) < 1e-9)
+            continue;
+        for (const { child, position, x } of moved) {
+            changes.push({
+                id: child.id,
+                data: {
+                    position: [x, position[1], position[2]],
+                    ...('wallT' in child ? { wallT: x / length } : {}),
+                },
+            });
+        }
+    }
+    const separators = Object.values(nodes).filter((node) => node.type === 'separator' && node.parentId === moving.parentId && !exclude.has(node.id));
+    for (const update of planAttachedSeparatorUpdates(separators, originalStart, originalEnd, nextStart, nextEnd))
+        changes.push({ id: update.id, data: { start: update.start, end: update.end } });
+    return changes;
+}

package/dist/commands/structure/index.d.ts

@@ -1,4 +1,5 @@
 export { applyZoneTransformPlan, type CeilingHostAssignment, type HostedZoneTransformPlan, resolveZoneTransformHosts, type SupportHostAssignment, } from './apply-zone-transform.js';
+export { planAttachedWallChanges } from './attached-walls.js';
 export { type CreateMezzanineInput, createMezzanine } from './create-mezzanine.js';
 export { type CreateZoneInput, createZone, outdoorRoomConflicts, walledRoomAt, } from './create-zone.js';
 export { type DeleteZonePayload, deleteZone, SHARED_WALLS_DELETE_MESSAGE } from './delete-zone.js';
@@ -7,6 +8,7 @@ export { type DuplicateZoneInput, duplicateZone } from './duplicate-zone.js';
 export { type CutFloorOpeningInput, cutFloorOpening, type FloorOpeningHint, floorOpeningHints, removeFloorOpening, } from './floor-opening.js';
 export { type LockOutsideFacesInput, lockOutsideFaces } from './lock-outside-faces.js';
 export { mergeZones } from './merge-zones.js';
+export { joinedSeparatorIds, planAttachedSeparatorUpdates, SEPARATOR_JOIN_REACH, type SeparatorSpan, setSeparatorEnd, translateSeparators, } from './move-separators.js';
 export { type MezzanineStairPlan, planMezzanineStair } from './plan-mezzanine-stair.js';
 export { planWallDeletion } from './plan-wall-deletion.js';
 export { rebaseFloorReference } from './rebase-floor-reference.js';
@@ -19,4 +21,5 @@ export { setZoneEdges } from './set-zone-edges.js';
 export { setZoneIntent, ZoneIntentPatch } from './set-zone-intent.js';
 export { type NodeChange, type Point, type SpanRef, type StructureConflict, type StructureMintId, type StructureNodes, type StructurePlan, structureChangeBatch, } from './shared.js';
 export { type TransformZoneInput, transformZone, type ZoneTransformPlan } from './transform-zone.js';
+export { finishWallEdit, retypeOutlineBridges, sameWallConstruction, trimWallOverlaps, WALL_CONSTRUCTION_FIELDS, wallConstructionPatch, wallsRunAlong, } from './wall-overlap.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/structure/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,yBAAyB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,KAAK,oBAAoB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EACL,KAAK,eAAe,EACpB,UAAU,EACV,oBAAoB,EACpB,YAAY,GACb,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAC/F,OAAO,EACL,yBAAyB,EACzB,UAAU,EACV,gBAAgB,EAChB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,eAAe,EACf,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,KAAK,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,KAAK,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,oBAAoB,GACrB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,yBAAyB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,EAAE,KAAK,oBAAoB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EACL,KAAK,eAAe,EACpB,UAAU,EACV,oBAAoB,EACpB,YAAY,GACb,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAC/F,OAAO,EACL,yBAAyB,EACzB,UAAU,EACV,gBAAgB,EAChB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,eAAe,EACf,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,KAAK,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EACL,kBAAkB,EAClB,4BAA4B,EAC5B,oBAAoB,EACpB,KAAK,aAAa,EAClB,eAAe,EACf,mBAAmB,GACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,KAAK,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,oBAAoB,GACrB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACjG,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,wBAAwB,EACxB,qBAAqB,EACrB,aAAa,GACd,MAAM,gBAAgB,CAAA"}

package/dist/commands/structure/index.js

@@ -1,4 +1,5 @@
 export { applyZoneTransformPlan, resolveZoneTransformHosts, } from './apply-zone-transform.js';
+export { planAttachedWallChanges } from './attached-walls.js';
 export { createMezzanine } from './create-mezzanine.js';
 export { createZone, outdoorRoomConflicts, walledRoomAt, } from './create-zone.js';
 export { deleteZone, SHARED_WALLS_DELETE_MESSAGE } from './delete-zone.js';
@@ -7,6 +8,7 @@ export { duplicateZone } from './duplicate-zone.js';
 export { cutFloorOpening, floorOpeningHints, removeFloorOpening, } from './floor-opening.js';
 export { lockOutsideFaces } from './lock-outside-faces.js';
 export { mergeZones } from './merge-zones.js';
+export { joinedSeparatorIds, planAttachedSeparatorUpdates, SEPARATOR_JOIN_REACH, setSeparatorEnd, translateSeparators, } from './move-separators.js';
 export { planMezzanineStair } from './plan-mezzanine-stair.js';
 export { planWallDeletion } from './plan-wall-deletion.js';
 export { rebaseFloorReference } from './rebase-floor-reference.js';
@@ -18,3 +20,4 @@ export { setZoneEdges } from './set-zone-edges.js';
 export { setZoneIntent, ZoneIntentPatch } from './set-zone-intent.js';
 export { structureChangeBatch, } from './shared.js';
 export { transformZone } from './transform-zone.js';
+export { finishWallEdit, retypeOutlineBridges, sameWallConstruction, trimWallOverlaps, WALL_CONSTRUCTION_FIELDS, wallConstructionPatch, wallsRunAlong, } from './wall-overlap.js';

package/dist/commands/structure/move-separators.d.ts

@@ -0,0 +1,62 @@
+import { SeparatorNode } from '../../schema/index.js';
+import { type WallPlanPoint } from '../../systems/wall/wall-move.js';
+import { type Point, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+/**
+ * Invisible walls (room separators) move the way walls do, so the rooms they close stay closed:
+ * a separator joined end to end with a moving one stretches to its moved end (or takes a jog
+ * where it runs on in line), one T'd into its body slides along its own line to stay on it, and
+ * an end of the moving one sitting on a wall, a railing or another separator slides along that
+ * line. Walls never move with them.
+ */
+/** A stretch of an invisible wall: `[0, 1]` is all of it. */
+export type SeparatorSpan = {
+    separatorId: string;
+    t0: number;
+    t1: number;
+};
+/**
+ * How near invisible walls meet: ends this near are one corner and an end this near a line is on
+ * it, as far as the room graph joins them (`WALL_JUNCTION_TOLERANCE`). A move puts such ends
+ * exactly together, so a corner drawn a little open closes.
+ */
+export declare const SEPARATOR_JOIN_REACH = 0.08;
+/** The invisible walls joined at `endpoint` of `separator`: the ones a drag of that end takes. */
+export declare function joinedSeparatorIds(nodes: StructureNodes, separator: SeparatorNode, endpoint: 'start' | 'end'): string[];
+/**
+ * Pushes invisible-wall stretches `offset` as one line: a room's edge of separators, a selected
+ * separator's side arrow. A stretch shorter than its separator is split off first and only it
+ * moves, the rest staying joined to it by a jog. An end that sat on a wall, a railing or another
+ * separator slides along it to where the moved line meets it; one the move carries off its end
+ * leaves a short invisible wall back to where it was, so the room stays closed. Separators joined
+ * to the moving ones end to end follow the junction rules of a wall move, and those T'd into
+ * their bodies stretch along their own lines. One plan, one undo step.
+ */
+export declare function translateSeparators(nodes: StructureNodes, input: {
+    spans: readonly SeparatorSpan[];
+    offset: Point;
+    mintId: StructureMintId;
+}): StructurePlan;
+/**
+ * Moves one end of an invisible wall to `point`, as a wall's end drag does: the separators joined
+ * at that end follow it, stretching and turning about their far ends, and those T'd into its
+ * body slide along their own lines to stay on it. `detach` (Alt) leaves them where they are.
+ */
+export declare function setSeparatorEnd(nodes: StructureNodes, input: {
+    separatorId: string;
+    endpoint: 'start' | 'end';
+    point: Point;
+    detach?: boolean;
+}): StructurePlan;
+/**
+ * The invisible walls a moving wall carries along, so the rooms they close stay closed: one T'd
+ * into its body slides along its own line onto the moved line, as a wall T'd into it does, and
+ * one joined at a moving end follows that end while the end moves along the separator's own line
+ * (a corner pushed square). A corner the move turns leaves its separators where they are, on the
+ * wall it stretched; an end the move would carry off the wall lets go.
+ */
+export declare function planAttachedSeparatorUpdates(separators: readonly SeparatorNode[], originalStart: WallPlanPoint, originalEnd: WallPlanPoint, nextStart: WallPlanPoint, nextEnd: WallPlanPoint): Array<{
+    id: SeparatorNode['id'];
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+}>;
+//# sourceMappingURL=move-separators.d.ts.map

package/dist/commands/structure/move-separators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-separators.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/move-separators.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,aAAa,EAAiB,MAAM,cAAc,CAAA;AAEzE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,8BAA8B,CAAA;AAErC,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB;;;;;;GAMG;AAEH,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3E;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,OAA0B,CAAA;AA+G3D,kGAAkG;AAClG,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,OAAO,GAAG,KAAK,GACxB,MAAM,EAAE,CAKV;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GACjF,aAAa,CA8Kf;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GACxF,aAAa,CAwCf;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,SAAS,aAAa,EAAE,EACpC,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,aAAa,EAC1B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,aAAa,GACrB,KAAK,CAAC;IAAE,EAAE,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IAAC,KAAK,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,CAAC,CA6B9E"}