@pascal-app/core 1.0.5 → 1.0.7

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

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAsB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAG3E,MAAM,MAAM,UAAU,GAAG,SAAS,CAAA;AAClC,MAAM,MAAM,cAAc,GAAG,UAAU,CAAA;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,KAAK,MAAM,CAAA;AAC7E,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AACpF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACjC,CAAA;AACD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AAE7E,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,mBAAmB,CAQxF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQ/E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG,UAAU,EAAE,CAwBzF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAExF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAIvE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CAKjF;AAOD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,QAAQ,EACd,KAAK,kCAAkD,6CA6BxD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,WAc9E;AAED,wBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAE7D;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK;;;;EAS7D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,WAEvD"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAsB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAG3E,MAAM,MAAM,UAAU,GAAG,SAAS,CAAA;AAClC,MAAM,MAAM,cAAc,GAAG,UAAU,CAAA;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,KAAK,MAAM,CAAA;AAC7E,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AACpF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACjC,CAAA;AACD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AAE7E,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,mBAAmB,CAQxF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQ/E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG,UAAU,EAAE,CAwBzF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAExF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAIvE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CAKjF;AAOD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,QAAQ,EACd,KAAK,kCAAkD,6CA6BxD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,WAc9E;AAED,wBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAE7D;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK;;;;EAS7D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,WAEvD"}

package/dist/commands/structure/wall-overlap.d.ts

@@ -0,0 +1,45 @@
+import type { AnyNode, AnyNodeId, WallNode } from '../../schema/index.js';
+import { type WallTopologyChanges } from '../../systems/wall/wall-topology.js';
+import type { StructureConflict } from './shared.js';
+type Nodes = Record<string, AnyNode>;
+/** The walls on `wall`'s level it runs along for more than a sliver: what it would take over. */
+export declare function wallsRunAlong(nodes: Readonly<Nodes>, wall: WallNode): WallNode[];
+/**
+ * Let each wall of `winnerIds` take over the stretches of parallel walls it
+ * runs along (`nodes` is mutated). Walls among the winners don't cut each
+ * other. A conflict when an opening would straddle a cut; `nodes` may then
+ * be half done, so callers work on a copy.
+ */
+export declare function trimWallOverlaps(nodes: Nodes, winnerIds: readonly string[], mintId: () => string): StructureConflict | null;
+/**
+ * The fields that make a wall's construction (its wall type): assembly,
+ * thickness, finishes and trims. Position, support, paint regions, height and
+ * justification stay with each wall.
+ */
+export declare const WALL_CONSTRUCTION_FIELDS: readonly ["thickness", "wallType", "curtainWall", "railing", "assembly", "material", "materialPreset", "interiorMaterial", "interiorMaterialPreset", "exteriorMaterial", "exteriorMaterialPreset", "slots", "legacyFaceMaterials", "skirting", "crown", "chairRail", "finishScripts", "cap"];
+/** `wall`'s construction as a patch for another wall (unset fields cleared). */
+export declare function wallConstructionPatch(wall: WallNode): Partial<WallNode>;
+/** True when two walls are built the same (`WALL_CONSTRUCTION_FIELDS`). */
+export declare function sameWallConstruction(a: WallNode, b: WallNode): boolean;
+/**
+ * The jog walls a move bridges in (`bridgeIds`) copy the wall they continue —
+ * often a partition, when an outside wall is pushed out past one. A jog left
+ * on the outline of the storey, beside a moved wall that is on it too, is an
+ * outside wall: it takes the moved wall's construction instead (`nodes` is
+ * mutated).
+ */
+export declare function retypeOutlineBridges(nodes: Nodes, movedWallId: string, bridgeIds: readonly string[]): void;
+/**
+ * `changes` (a planned wall edit against `nodes`) with the overlaps its
+ * `winnerIds` now run along trimmed, and its outline jogs (`bridgeIds`, beside
+ * `movedWallId`) retyped. The plan unchanged when an opening would straddle a
+ * cut.
+ */
+export declare function finishWallEdit(nodes: Record<AnyNodeId, AnyNode>, changes: WallTopologyChanges, options: {
+    winnerIds: readonly string[];
+    movedWallId?: string;
+    bridgeIds?: readonly string[];
+    mintId: () => string;
+}): WallTopologyChanges;
+export {};
+//# sourceMappingURL=wall-overlap.d.ts.map

package/dist/commands/structure/wall-overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-overlap.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/wall-overlap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAuBjD,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAqDpC,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAShF;AA+GD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,MAAM,EAAE,MAAM,MAAM,GACnB,iBAAiB,GAAG,IAAI,CAW1B;AAED;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,8RAmBa,CAAA;AAElD,gFAAgF;AAChF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAIvE;AAED,2EAA2E;AAC3E,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,IAAI,CAeN;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE;IACP,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,MAAM,EAAE,MAAM,MAAM,CAAA;CACrB,GACA,mBAAmB,CAuBrB"}

package/dist/commands/structure/wall-overlap.js

@@ -0,0 +1,289 @@
+import { enclosedWallIds } from '../../lib/exterior-wall-loops.js';
+import { isCurvedWall } from '../../systems/wall/wall-curve.js';
+import { getWallFaceOffsets } from '../../systems/wall/wall-frame.js';
+import { WALL_MIN_LENGTH, wallAttachmentSpan, } from '../../systems/wall/wall-topology.js';
+import { rehostWallChild, remapWallReferences, wallSlice } from './zone-wall-merge.js';
+/**
+ * A wall placed, moved or stretched over part of a parallel wall takes that
+ * stretch over: the other wall keeps only what lies past the placed wall's
+ * ends (cut back, split in two round it, or deleted when covered), so no
+ * length of wall is doubled. Doors, windows and wall items on the stretch
+ * taken over move onto the placed wall; rooms that named the cut wall name its
+ * pieces and the placed wall.
+ *
+ * Two walls run along each other when they are parallel and the body centre of
+ * the thinner lies inside the thicker's body: the same line, or a wall
+ * face-aligned inside a thicker one. Walls side by side, face to face, are
+ * left alone. The wall moves, the wall tool and the push arrows all finish
+ * through here.
+ */
+// Walls within about 1° of each other count as parallel.
+const PARALLEL_TOLERANCE = Math.sin(Math.PI / 180);
+const ON_LINE = 1e-6;
+const SPAN_TOLERANCE = 1e-4;
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
+function straightFrame(wall) {
+    if (isCurvedWall(wall))
+        return null;
+    const delta = sub(wall.end, wall.start);
+    const length = Math.hypot(delta[0], delta[1]);
+    if (length < WALL_MIN_LENGTH)
+        return null;
+    const dir = [delta[0] / length, delta[1] / length];
+    return { dir, normal: [-dir[1], dir[0]], length };
+}
+/** The wall's body across `normal` (a unit vector square to it), from `origin`. */
+function bodyAcross(wall, wallNormal, normal, origin) {
+    const { a, b } = getWallFaceOffsets(wall);
+    const line = dot(sub(wall.start, origin), normal);
+    const sign = Math.sign(dot(wallNormal, normal)) || 1;
+    return [line + Math.min(a * sign, b * sign), line + Math.max(a * sign, b * sign)];
+}
+/** True when `other` runs along `wall`: parallel, the thinner body centred inside the thicker. */
+function runsAlong(wall, other) {
+    const own = straightFrame(wall);
+    const theirs = straightFrame(other);
+    if (!(own && theirs))
+        return false;
+    if (Math.abs(own.dir[0] * theirs.dir[1] - own.dir[1] * theirs.dir[0]) > PARALLEL_TOLERANCE) {
+        return false;
+    }
+    const ownBody = bodyAcross(wall, own.normal, theirs.normal, other.start);
+    const theirBody = bodyAcross(other, theirs.normal, theirs.normal, other.start);
+    const [thin, thick] = ownBody[1] - ownBody[0] <= theirBody[1] - theirBody[0]
+        ? [ownBody, theirBody]
+        : [theirBody, ownBody];
+    const middle = (thin[0] + thin[1]) / 2;
+    return middle > thick[0] + SPAN_TOLERANCE && middle < thick[1] - SPAN_TOLERANCE;
+}
+/** Where `winner` covers `other`, as `[lo, hi]` of `other`; null under a wall's length. */
+function coveredSpan(winner, other) {
+    const frame = straightFrame(other);
+    if (!frame)
+        return null;
+    const station = (point) => dot(sub(point, other.start), frame.dir) / frame.length;
+    const s0 = station(winner.start);
+    const s1 = station(winner.end);
+    const lo = Math.max(0, Math.min(s0, s1));
+    const hi = Math.min(1, Math.max(s0, s1));
+    return (hi - lo) * frame.length < WALL_MIN_LENGTH ? null : { frame, s0, s1, lo, hi };
+}
+/** The walls on `wall`'s level it runs along for more than a sliver: what it would take over. */
+export function wallsRunAlong(nodes, wall) {
+    return Object.values(nodes).filter((node) => node.type === 'wall' &&
+        node.id !== wall.id &&
+        node.parentId === wall.parentId &&
+        runsAlong(wall, node) &&
+        coveredSpan(wall, node) !== null);
+}
+function wallAttachments(nodes, wall) {
+    return Object.values(nodes).filter((node) => node.parentId === wall.id || ('wallId' in node && node.wallId === wall.id));
+}
+/**
+ * Cut `winner`'s stretch out of `other` in `nodes` (mutated). Null when done,
+ * a conflict when an opening straddles a cut.
+ */
+function cutAlong(nodes, winner, other, mintId) {
+    const covered = coveredSpan(winner, other);
+    if (!covered)
+        return null;
+    const { frame, s0, s1, lo, hi } = covered;
+    // Where the cut wall now ends: on the winner's own end when the two share a
+    // line, so they meet exactly; else straight across from it on its own line.
+    const sameLine = Math.abs(dot(sub(winner.start, other.start), frame.normal)) < ON_LINE &&
+        Math.abs(dot(sub(winner.end, other.start), frame.normal)) < ON_LINE;
+    const pointAt = (t) => {
+        if (t <= 0)
+            return [other.start[0], other.start[1]];
+        if (t >= 1)
+            return [other.end[0], other.end[1]];
+        if (sameLine) {
+            if (Math.abs(s0 - t) * frame.length < ON_LINE)
+                return [winner.start[0], winner.start[1]];
+            if (Math.abs(s1 - t) * frame.length < ON_LINE)
+                return [winner.end[0], winner.end[1]];
+        }
+        return [
+            other.start[0] + (other.end[0] - other.start[0]) * t,
+            other.start[1] + (other.end[1] - other.start[1]) * t,
+        ];
+    };
+    const spans = [
+        [0, lo],
+        [hi, 1],
+    ].filter(([t0, t1]) => (t1 - t0) * frame.length >= WALL_MIN_LENGTH);
+    const pieces = spans.map(([t0, t1], index) => ({
+        id: index === 0 ? other.id : mintId(),
+        t0: t0,
+        t1: t1,
+    }));
+    // Every attachment goes to the kept piece it sits on, or onto the winner
+    // when it sits on the stretch taken over; one across a cut stops the edit.
+    const placed = new Map();
+    for (const child of wallAttachments(nodes, other)) {
+        const span = wallAttachmentSpan(child);
+        if (!span) {
+            placed.set(child.id, pieces[0] ?? 'winner');
+            continue;
+        }
+        const t0 = span.min / frame.length;
+        const t1 = span.max / frame.length;
+        const tolerance = SPAN_TOLERANCE / frame.length;
+        const piece = pieces.find((p) => t0 >= p.t0 - tolerance && t1 <= p.t1 + tolerance);
+        if (piece)
+            placed.set(child.id, piece);
+        else if (t0 >= lo - tolerance && t1 <= hi + tolerance)
+            placed.set(child.id, 'winner');
+        else
+            return {
+                code: 'hosted-openings',
+                nodeIds: [child.id],
+                message: 'A door or window would sit across where the walls meet.',
+            };
+    }
+    const slices = pieces.map((piece) => wallSlice(other, pointAt(piece.t0), pointAt(piece.t1), piece.id, [piece.t0, piece.t1]));
+    const winnerChildren = new Set(winner.children ?? []);
+    for (const child of wallAttachments(nodes, other)) {
+        const target = placed.get(child.id);
+        if (target === 'winner') {
+            rehostWallChild(nodes, child, other, winner);
+            winnerChildren.add(child.id);
+            continue;
+        }
+        if (!target)
+            continue;
+        const slice = slices[pieces.indexOf(target)];
+        slice.children = [...(slice.children ?? []), child.id];
+        if (!('position' in child && Array.isArray(child.position))) {
+            nodes[child.id] = { ...child, parentId: slice.id };
+            continue;
+        }
+        const x = child.position[0] - target.t0 * frame.length;
+        const length = (target.t1 - target.t0) * frame.length;
+        nodes[child.id] = {
+            ...child,
+            parentId: slice.id,
+            ...('wallId' in child ? { wallId: slice.id } : {}),
+            position: [x, child.position[1], child.position[2]],
+            ...('wallT' in child ? { wallT: length > 1e-6 ? x / length : 0 } : {}),
+        };
+    }
+    nodes[winner.id] = { ...winner, children: [...winnerChildren] };
+    remapWallReferences(nodes, other, [...slices, nodes[winner.id]]);
+    delete nodes[other.id];
+    for (const slice of slices)
+        nodes[slice.id] = slice;
+    return null;
+}
+/**
+ * Let each wall of `winnerIds` take over the stretches of parallel walls it
+ * runs along (`nodes` is mutated). Walls among the winners don't cut each
+ * other. A conflict when an opening would straddle a cut; `nodes` may then
+ * be half done, so callers work on a copy.
+ */
+export function trimWallOverlaps(nodes, winnerIds, mintId) {
+    const winners = new Set(winnerIds);
+    for (const id of winnerIds) {
+        const winner = nodes[id];
+        if (winner?.type !== 'wall' || !straightFrame(winner))
+            continue;
+        for (const other of wallsRunAlong(nodes, winner).filter((node) => !winners.has(node.id))) {
+            const conflict = cutAlong(nodes, nodes[id], other, mintId);
+            if (conflict)
+                return conflict;
+        }
+    }
+    return null;
+}
+/**
+ * The fields that make a wall's construction (its wall type): assembly,
+ * thickness, finishes and trims. Position, support, paint regions, height and
+ * justification stay with each wall.
+ */
+export const WALL_CONSTRUCTION_FIELDS = [
+    'thickness',
+    'wallType',
+    'curtainWall',
+    'railing',
+    'assembly',
+    'material',
+    'materialPreset',
+    'interiorMaterial',
+    'interiorMaterialPreset',
+    'exteriorMaterial',
+    'exteriorMaterialPreset',
+    'slots',
+    'legacyFaceMaterials',
+    'skirting',
+    'crown',
+    'chairRail',
+    'finishScripts',
+    'cap',
+];
+/** `wall`'s construction as a patch for another wall (unset fields cleared). */
+export function wallConstructionPatch(wall) {
+    const patch = {};
+    for (const field of WALL_CONSTRUCTION_FIELDS)
+        patch[field] = structuredClone(wall[field]);
+    return patch;
+}
+/** True when two walls are built the same (`WALL_CONSTRUCTION_FIELDS`). */
+export function sameWallConstruction(a, b) {
+    return JSON.stringify(wallConstructionPatch(a)) === JSON.stringify(wallConstructionPatch(b));
+}
+/**
+ * The jog walls a move bridges in (`bridgeIds`) copy the wall they continue —
+ * often a partition, when an outside wall is pushed out past one. A jog left
+ * on the outline of the storey, beside a moved wall that is on it too, is an
+ * outside wall: it takes the moved wall's construction instead (`nodes` is
+ * mutated).
+ */
+export function retypeOutlineBridges(nodes, movedWallId, bridgeIds) {
+    const moved = nodes[movedWallId];
+    if (moved?.type !== 'wall' || bridgeIds.length === 0)
+        return;
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === moved.parentId && node.visible !== false);
+    const enclosed = enclosedWallIds(walls);
+    if (enclosed.has(moved.id))
+        return;
+    const patch = wallConstructionPatch(moved);
+    for (const id of bridgeIds) {
+        const bridge = nodes[id];
+        if (bridge?.type !== 'wall' || enclosed.has(bridge.id))
+            continue;
+        nodes[id] = { ...bridge, ...patch };
+    }
+}
+/**
+ * `changes` (a planned wall edit against `nodes`) with the overlaps its
+ * `winnerIds` now run along trimmed, and its outline jogs (`bridgeIds`, beside
+ * `movedWallId`) retyped. The plan unchanged when an opening would straddle a
+ * cut.
+ */
+export function finishWallEdit(nodes, changes, options) {
+    const scratch = { ...nodes };
+    for (const id of changes.delete)
+        delete scratch[id];
+    for (const { node, parentId } of changes.create)
+        scratch[node.id] = { ...node, parentId: parentId ?? node.parentId };
+    for (const { id, data } of changes.update)
+        if (scratch[id])
+            scratch[id] = { ...scratch[id], ...data };
+    if (options.movedWallId) {
+        retypeOutlineBridges(scratch, options.movedWallId, options.bridgeIds ?? []);
+    }
+    const trimmed = { ...scratch };
+    const conflict = trimWallOverlaps(trimmed, options.winnerIds, options.mintId);
+    const after = conflict ? scratch : trimmed;
+    const before = nodes;
+    return {
+        create: Object.values(after)
+            .filter((node) => !before[node.id])
+            .map((node) => ({ node, parentId: node.parentId })),
+        update: Object.values(after)
+            .filter((node) => before[node.id] && node !== before[node.id])
+            .map((node) => ({ id: node.id, data: node })),
+        delete: Object.keys(before).filter((id) => !after[id]),
+    };
+}