@pascal-app/core 1.0.6 → 1.1.0

package/dist/lib/roof-eave.js

@@ -0,0 +1,186 @@
+import { getRoofSegmentDeckReach, getSegmentSlopeFrame, } from '../schema/nodes/roof-segment.js';
+import { LUMBER_DEPTH } from './build-up.js';
+const inches = (value) => value * 0.0254;
+/** A 1x board's actual thickness: every fascia and rake board is nominal 1x. */
+export const FASCIA_THICKNESS = inches(0.75);
+/** How far a fascia or rake board drops below the tails' lowest point, past a soffit's edge. */
+export const FASCIA_DROP = inches(0.75);
+/** The least it drops where a 1x then needs no ripping. */
+const FASCIA_DROP_MIN = inches(0.25);
+/** The run of a plumb-and-level tail's level cut: a 2x4's width for the soffit's edge to nail to. */
+export const LEVEL_CUT_RUN = inches(3.5);
+/** A boxed eave's soffit: a 1/2 in panel nailed up to the level cuts. */
+export const SOFFIT_THICKNESS = inches(0.5);
+/** The sheathing a plane without layers is taken to carry over its tails: Bones' 7/16 in. */
+const BARE_SHEATHING = inches(7 / 16);
+/** The 1x boards a fascia or rake board is cut from, narrowest first, at their actual widths. */
+export const FASCIA_STOCK = [
+    { size: '1x6', width: inches(5.5) },
+    { size: '1x8', width: inches(7.25) },
+    { size: '1x10', width: inches(9.25) },
+    { size: '1x12', width: inches(11.25) },
+];
+/**
+ * The 1x a board `width` wide is cut from: the narrowest stock as wide, ripped down to it when
+ * wider. Past a 1x12 no 1x is wide enough: a ripped width of wider stock (`stock` null).
+ */
+export function fasciaStockFor(width) {
+    const stock = FASCIA_STOCK.find((candidate) => candidate.width >= width - 1e-4);
+    if (!stock)
+        return { stock: null, ripped: true };
+    return { stock: stock.size, ripped: stock.width - width > 1e-3 };
+}
+/**
+ * How wide a board covering `cover` is, `scale` its width per unit of the cover's measure (a rake
+ * board's, its plumb depth's cosine): `FASCIA_DROP` past it, or a 1x whole where one drops between
+ * `least` and that, so the board is stock, not ripped.
+ */
+function boardWidth(cover, scale = 1, least = FASCIA_DROP_MIN) {
+    const whole = FASCIA_STOCK.find(({ width }) => width >= (cover + least) * scale - 1e-6 && width <= (cover + FASCIA_DROP) * scale + 1e-6);
+    return whole ? whole.width : (cover + FASCIA_DROP) * scale;
+}
+/**
+ * An eave cut to its plane's rule. The tails reach `reach` out from the plate line along the
+ * sheathing's top, the deck's full depth under it:
+ *  - plumb: the tails cut plumb there; a plumb 1x fascia covers their face, its top flush with the
+ *    sheathing's top (under the drip edge), its bottom about `FASCIA_DROP` below their lowest point;
+ *  - square: the tails cut square to the slope through the sheathing's outer edge, the fascia square
+ *    to the slope on them, its top face in the sheathing's plane;
+ *  - plumb-level: the plumb cut, and under it a level cut `LEVEL_CUT_RUN` long (at most half the tail's
+ *    plumb depth deep) that a soffit nails up to, run level from the fascia's back to the wall.
+ * The fascia is as deep as that takes (a whole 1x where one drops at least 1/4 in under the tails,
+ * else one ripped to it), unless the plane sets its own.
+ */
+export function roofEaveProfile(input) {
+    const tan = Number.isFinite(input.tan) ? input.tan : 0;
+    const cos = 1 / Math.hypot(1, tan);
+    const sin = tan * cos;
+    const { reach, wallOut, tailLift } = input;
+    const deck = Math.max(0, input.deckDepth);
+    const top = (s) => deck / cos - s * tan;
+    const under = (s) => tailLift - s * tan;
+    const thickness = input.fasciaThickness ?? FASCIA_THICKNESS;
+    const cut = tan > 1e-6 ? (input.cut ?? 'plumb') : 'plumb';
+    const corner = [reach, top(reach)];
+    let end;
+    let low;
+    let height;
+    let corners;
+    let soffit = null;
+    if (cut === 'square') {
+        // the sheathing's top to the tails' underside, square to the slope
+        const depth = deck - tailLift * cos;
+        height = input.fasciaHeight ?? boardWidth(depth);
+        const down = (d) => [reach - d * sin, corner[1] - d * cos];
+        const out = (point) => [
+            point[0] + thickness * cos,
+            point[1] - thickness * sin,
+        ];
+        const foot = down(depth);
+        end = [corner, foot];
+        low = foot[1];
+        const bottom = down(height);
+        corners = [corner, out(corner), out(bottom), bottom];
+    }
+    else {
+        let foot = under(reach);
+        if (cut === 'plumb-level') {
+            const run = Math.min(LEVEL_CUT_RUN, input.tailDepth / cos / (2 * tan));
+            foot = under(reach) + run * tan;
+            end = [corner, [reach, foot], [reach - run, foot]];
+            soffit = { y: foot, thickness: SOFFIT_THICKNESS, from: wallOut, to: reach };
+        }
+        else
+            end = [corner, [reach, foot]];
+        low = foot;
+        const topY = corner[1] + (input.fasciaRise ?? 0);
+        // past a boxed eave's soffit, the fascia drops its whole 3/4 in under the level cuts
+        height =
+            input.fasciaHeight ??
+                boardWidth(topY - foot, 1, cut === 'plumb-level' ? SOFFIT_THICKNESS + FASCIA_DROP_MIN : FASCIA_DROP_MIN);
+        corners = [
+            [reach, topY],
+            [reach + thickness, topY],
+            [reach + thickness, topY - height],
+            [reach, topY - height],
+        ];
+    }
+    // A rake board meets the eave's fascia flush at the corner: as deep at its foot (plumb, or square
+    // along the cut), so neither hangs past the other. Over a boxed eave it covers the barge whole,
+    // held level with the fascia's bottom at the corner.
+    const rakeHeight = input.fasciaHeight ??
+        (cut === 'plumb'
+            ? height
+            : cut === 'square'
+                ? height / cos
+                : boardWidth(deck / cos - tailLift, cos) / cos);
+    return {
+        cut,
+        tan,
+        cos,
+        sin,
+        reach,
+        wallOut,
+        top,
+        under,
+        end,
+        low,
+        fascia: {
+            corners,
+            height,
+            thickness,
+            square: cut === 'square',
+            ...fasciaStockFor(height),
+        },
+        soffit,
+        rake: { height: rakeHeight, width: rakeHeight * cos, ...fasciaStockFor(rakeHeight * cos) },
+    };
+}
+/**
+ * Whether a point of an eave's section, out past the wall's outer face, lies in the shell's eave
+ * (`tolerance` either way): under the sheathing's top, inside the tails' end cut, and over their
+ * underside or a boxed eave's soffit.
+ */
+export function eaveContains(profile, [s, y], tolerance = 0) {
+    const { reach, cut, cos, sin, top, under, soffit } = profile;
+    if (y > top(s) + tolerance || s > reach + tolerance)
+        return false;
+    const [cs, cy] = profile.end[0];
+    if (cut === 'square' && (s - cs) * cos - (y - cy) * sin > tolerance)
+        return false;
+    // a boxed eave stands on its soffit: under it the deck is cut away
+    const floor = soffit ? soffit.y - soffit.thickness : under(s);
+    return y >= floor - tolerance;
+}
+/**
+ * The numbers a roof plane's eaves are cut from (`roofEaveProfile`): its reach and wall, its layers'
+ * structure and deck, its eave cut and fascia. Its rafters sit on the plate; a truss's top chord on
+ * its bottom chord at the heel. A plane without layers is taken as rafters under a 7/16 in sheet,
+ * as deep as its deck. `high`: a shed's high edge, rising outward, cut plumb.
+ */
+export function roofSegmentEaveInput(node, edge = 'eave') {
+    const { tanTheta } = getSegmentSlopeFrame(node);
+    const deck = Math.max(0, node.deckThickness);
+    const structure = node.buildUp?.structure;
+    const chord = structure ? LUMBER_DEPTH[structure.size] : 0;
+    const tailDepth = structure ? chord : Math.max(0, deck - Math.min(BARE_SHEATHING, deck / 2));
+    return {
+        tan: edge === 'high' ? -tanTheta : tanTheta,
+        reach: getRoofSegmentDeckReach(node).z,
+        wallOut: Math.max(0, node.wallThickness) / 2,
+        tailDepth,
+        tailLift: structure?.system === 'trusses' ? chord : 0,
+        deckDepth: deck,
+        cut: edge === 'high' ? 'plumb' : (node.eaveCut ?? 'plumb'),
+        ...(node.fasciaHeight !== undefined ? { fasciaHeight: node.fasciaHeight } : {}),
+        ...(node.fasciaDepth !== undefined ? { fasciaThickness: node.fasciaDepth } : {}),
+        // a flat roof's boards sized on purpose rise over its membrane's edge: a coping band
+        ...(node.roofType === 'flat' && node.fasciaHeight !== undefined
+            ? { fasciaRise: Math.max(0, node.shingleThickness ?? 0) }
+            : {}),
+    };
+}
+/** A roof plane's eave (`roofSegmentEaveInput`, `roofEaveProfile`). */
+export function roofSegmentEaveProfile(node, edge = 'eave') {
+    return roofEaveProfile(roofSegmentEaveInput(node, edge));
+}

package/dist/lib/room-floor-elevation.d.ts

@@ -0,0 +1,12 @@
+import type { AnyNode, SlabNode } from '../schema/index.js';
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** The level's footprints, largest first (ties by id, so the order is stable). */
+export declare function levelFootprints(nodes: Record<string, AnyNode>, levelId: string): SlabNode[];
+/** A room's separate base plate, only when no other ground room shares it. */
+export declare function roomOwnPlate(nodes: Nodes, zoneId: string): SlabNode | null;
+/** The walking surface of a room: its own elevation, else its plate's. */
+export declare function roomFloorElevation(nodes: Nodes, zoneId: string): number;
+/** The walking surface of a room the separator closes, else zero. */
+export declare function separatorFloorElevation(nodes: Nodes, separatorId: string): number;
+export {};
+//# sourceMappingURL=room-floor-elevation.d.ts.map

package/dist/lib/room-floor-elevation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-floor-elevation.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-elevation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAY,MAAM,WAAW,CAAA;AAG5D,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAK9C,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CAW3F;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAW1E;AAED,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUvE;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKjF"}

package/dist/lib/room-floor-elevation.js

@@ -0,0 +1,41 @@
+import { area } from './polygon-boolean.js';
+const isRoom = (node) => node?.type === 'zone' && node.spaceRole === 'room';
+const isGroundRoom = (node) => isRoom(node) && node.floor?.support !== 'open';
+/** The level's footprints, largest first (ties by id, so the order is stable). */
+export function levelFootprints(nodes, levelId) {
+    return Object.values(nodes)
+        .filter((node) => node.type === 'slab' && node.plateRole === 'base' && node.parentId === levelId)
+        .sort((a, b) => area([{ outer: b.polygon, holes: b.holes }]) -
+        area([{ outer: a.polygon, holes: a.holes }]) || a.id.localeCompare(b.id));
+}
+/** A room's separate base plate, only when no other ground room shares it. */
+export function roomOwnPlate(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    if (!isRoom(zone) || !zone.floor?.footprint || zone.floor.support === 'open')
+        return null;
+    const plate = zone.parentId
+        ? levelFootprints(nodes, zone.parentId).find((plate) => plate.zoneIds?.includes(zoneId))
+        : null;
+    if (!plate)
+        return null;
+    const alone = !(plate.zoneIds ?? []).some((id) => id !== zoneId && isGroundRoom(nodes[id]));
+    return alone ? plate : null;
+}
+/** The walking surface of a room: its own elevation, else its plate's. */
+export function roomFloorElevation(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    if (zone?.type !== 'zone')
+        return 0;
+    const own = roomOwnPlate(nodes, zoneId);
+    if (own)
+        return own.elevation;
+    if (typeof zone.floor?.elevation === 'number')
+        return zone.floor.elevation;
+    const plate = Object.values(nodes).find((node) => node.type === 'slab' && node.zoneIds?.includes(zoneId));
+    return plate?.type === 'slab' ? (plate.elevation ?? 0.05) : 0.05;
+}
+/** The walking surface of a room the separator closes, else zero. */
+export function separatorFloorElevation(nodes, separatorId) {
+    const zone = Object.values(nodes).find((node) => node.type === 'zone' && node.boundarySeparatorIds.includes(separatorId));
+    return zone ? roomFloorElevation(nodes, zone.id) : 0;
+}

package/dist/lib/room-floor-feasibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"room-floor-feasibility.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-feasibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAC5D,OAAO,EAEL,0BAA0B,EAC1B,kBAAkB,EACnB,MAAM,sBAAsB,CAAA;AAgB7B,eAAO,MAAM,uBAAuB,QAAQ,CAAA;AAC5C,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,CAAA;AAEzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EACA,wBAAwB,GACxB,gCAAgC,GAChC,uBAAuB,GACvB,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,mBAAmB,GACnB,oBAAoB,GACpB,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,CAAA;IACtB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAID,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,MAAM,CA8CR;AAID,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAoE7B;AAID,wBAAgB,cAAc,CAC5B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM;;;;;;EAa1B;AAwKD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,MAAM,CAMR;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAWR"}
+{"version":3,"file":"room-floor-feasibility.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-feasibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAC5D,OAAO,EAEL,0BAA0B,EAC1B,kBAAkB,EACnB,MAAM,sBAAsB,CAAA;AAgB7B,eAAO,MAAM,uBAAuB,QAAQ,CAAA;AAC5C,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,CAAA;AAEzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EACA,wBAAwB,GACxB,gCAAgC,GAChC,uBAAuB,GACvB,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,mBAAmB,GACnB,oBAAoB,GACpB,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,CAAA;IACtB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAID,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,MAAM,CA8CR;AAID,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAoE7B;AAID,wBAAgB,cAAc,CAC5B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM;;;;;;EAa1B;AA2KD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,MAAM,CAMR;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAWR"}

package/dist/lib/room-floor-feasibility.js

@@ -176,7 +176,7 @@ function computeRoomFloor(nodes, zoneId, proposedElevation) {
     for (const wall of walls) {
         const hasOpenings = wall.children.some((id) => nodes[id]?.type === 'door' || nodes[id]?.type === 'window');
         const support = hasOpenings || wall.height !== undefined ? wallSupportForNodes(wall, candidate) : undefined;
-        const top = getWallTop(wall, level.id, nodes, support?.elevation ?? 0);
+        const top = Math.min(getWallTop(wall, level.id, nodes, support?.elevation ?? 0, 0), getWallTop(wall, level.id, nodes, support?.elevation ?? 0, 1));
         const openingSpans = hasOpenings && linked
             ? (roomFace(nodes, zone, floorRoomFaces(boundaries(nodes, zone.parentId)))?.spans ?? [])
             : spans;

package/dist/lib/room-floor-plate.d.ts

@@ -1,3 +1,5 @@
-import type { SlabNode } from '../schema/index.js';
+import type { AnyNode, AnyNodeId, SlabNode, ZoneNode } from '../schema/index.js';
 export declare function roomFloorPlate(slabs: readonly SlabNode[], zoneId: string): SlabNode | undefined;
+/** A dedicated plate's room; shared base plates do not inherit one room's outdoor type. */
+export declare function floorPlateRoom(slab: Pick<SlabNode, 'zoneIds' | 'plateRole'>, resolve: (id: AnyNodeId) => AnyNode | undefined): ZoneNode | undefined;
 //# sourceMappingURL=room-floor-plate.d.ts.map

package/dist/lib/room-floor-plate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"room-floor-plate.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-plate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAG/F"}
+{"version":3,"file":"room-floor-plate.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-plate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEvE,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAG/F;AAED,2FAA2F;AAC3F,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,WAAW,CAAC,EAC7C,OAAO,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,GAAG,SAAS,GAC9C,QAAQ,GAAG,SAAS,CAItB"}

package/dist/lib/room-floor-plate.js

@@ -2,3 +2,10 @@ export function roomFloorPlate(slabs, zoneId) {
     const owned = slabs.filter((slab) => slab.zoneIds?.includes(zoneId));
     return owned.find((slab) => slab.plateRole !== 'base') ?? owned[0];
 }
+/** A dedicated plate's room; shared base plates do not inherit one room's outdoor type. */
+export function floorPlateRoom(slab, resolve) {
+    if (slab.plateRole === 'base' || slab.zoneIds?.length !== 1)
+        return undefined;
+    const zone = resolve(slab.zoneIds[0]);
+    return zone?.type === 'zone' ? zone : undefined;
+}

package/dist/lib/space-detection.d.ts

@@ -29,12 +29,25 @@ type WallSideUpdate = {
     frontSide: 'interior' | 'exterior' | 'unknown';
     backSide: 'interior' | 'exterior' | 'unknown';
 };
+type SceneNodes = Record<string, any>;
 export declare function detectSpacesForLevel(levelId: string, walls: BoundaryNode[]): {
     rooms: ExtractedRoom[];
     roomPolygons: import("./room-graph.js").Point2D[][];
     spaces: Space[];
     wallUpdates: WallSideUpdate[];
 };
+/**
+ * Levels whose structure intent differs between two versions of a scene: what a paused batch's
+ * resume (and a detached scene's reconciliation) re-derives.
+ */
+export declare function changedStructureLevelIds(before: SceneNodes, after: SceneNodes): string[];
+/**
+ * Levels whose structure an edit from `before` to `after` asks to re-derive, chosen as space
+ * detection chooses them for a store commit: from the nodes the edit changed (walls by level, and
+ * the fallbacks for levels, stairs, openings, slabs, ceilings, zones and separators), without
+ * signing every level of the scene.
+ */
+export declare function structureLevelsForChange(before: SceneNodes, after: SceneNodes): string[];
 /** Pause structure reconciliation. Refcounted — pair with `resumeSpaceDetection`. */
 export declare function pauseSpaceDetection(): void;
 /** Resume structure reconciliation. No-op if not currently paused. */

package/dist/lib/space-detection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAGd,MAAM,WAAW,CAAA;AAelB,OAAO,EACL,KAAK,aAAa,EAIlB,KAAK,iBAAiB,EAGvB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,YAAY,EAAqB,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAG/F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAG/D,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEzE;AAID,OAAO,EAAE,KAAK,aAAa,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEvF,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IACtC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;IAC9B,aAAa,EAAE,iBAAiB,EAAE,CAAA;IAClC,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,SAAS,GAAG,UAAU,CAAA;IAChC,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,wBAAwB,EAAE,MAAM,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,2BAA2B,KAAK,IAAI,CAAA;CACnE,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC9C,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;CAC9C,CAAA;AA0YD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE;;;;;EAE1E;AA8BD,qFAAqF;AACrF,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,IAAI,IAAI,CAI3C;AAED,6DAA6D;AAC7D,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED,wBAAgB,uBAAuB,qCAMtC;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,GAAG,EACf,WAAW,EAAE,GAAG,EAChB,OAAO,GAAE,yBAA8B,GACtC,MAAM,IAAI,CAyKZ;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,CAiBjF"}
+{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAGd,MAAM,WAAW,CAAA;AAuBlB,OAAO,EACL,KAAK,aAAa,EAIlB,KAAK,iBAAiB,EAGvB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,YAAY,EAAqB,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAG/F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAG/D,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEzE;AAID,OAAO,EAAE,KAAK,aAAa,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEvF,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IACtC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;IAC9B,aAAa,EAAE,iBAAiB,EAAE,CAAA;IAClC,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,SAAS,GAAG,UAAU,CAAA;IAChC,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,wBAAwB,EAAE,MAAM,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,2BAA2B,KAAK,IAAI,CAAA;CACnE,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC9C,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;CAC9C,CAAA;AA+PD,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAkKrC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE;;;;;EAE1E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAMxF;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAWxF;AA+CD,qFAAqF;AACrF,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C;AAED,6DAA6D;AAC7D,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED,wBAAgB,uBAAuB,qCAMtC;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,GAAG,EACf,WAAW,EAAE,GAAG,EAChB,OAAO,GAAE,yBAA8B,GACtC,MAAM,IAAI,CAuLZ;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,CAiBjF"}

package/dist/lib/space-detection.js

@@ -1,10 +1,14 @@
 import { ZoneNode, } from '../schema/index.js';
 import { generateId } from '../schema/base.js';
 import { findLevelAboveId, getLevelBelow, getLevelElevations } from '../services/storey.js';
+import { isSettlingDocument } from '../store/document-settling.js';
 import { activeSceneCommitNodeIds, getSceneHistoryPauseDepth, isRestoringSceneHistory, notifySceneCommit, pauseSceneHistory, resumeSceneHistory, subscribeSceneCommits, } from '../store/history-control.js';
+import { currentSceneEnvironment, sceneEnvironmentOf, } from '../store/scene-environment.js';
 import { getClampedWallCurveOffset } from '../systems/wall/wall-curve.js';
 import { changedLevelConstructionDisplacements } from './floor-foundation-stack.js';
 import { createFloorOpeningIndex, floorOpeningTargets } from './floor-opening-intent.js';
+import { porchPartOf, porchPartSignature } from './porch-framing-sync.js';
+import { railingFencedRoomIds, railingWallIds } from './railing-rooms.js';
 import { extractRooms, pointToTuple, polygonSignature, sampleWallPointsForRoomDetection, WALL_JUNCTION_TOLERANCE, } from './room-graph.js';
 import { distanceToSegment, RoomTopologyIndex } from './room-topology-index.js';
 import { applyStructureReconciliation } from './structure-commit.js';
@@ -31,7 +35,13 @@ function wallGeometrySignature(wall, nodes, levelId) {
         // Plane-bound (no stored height) is a distinct state, not a default
         // value: it resolves to the storey plane, so it must not alias an
         // explicit height of the same magnitude in the trigger signature.
-        wall.height == null ? 'plane' : wall.height.toFixed(4),
+        // A legacy height that is not a number still signs, rather than throwing.
+        wall.height == null
+            ? 'plane'
+            : typeof wall.height === 'number'
+                ? wall.height.toFixed(4)
+                : String(wall.height),
+        (wall.endHeightOffset ?? 0).toFixed(4),
         wall.supportSlabId ?? 'elected',
         (wall.supportOffset ?? 0).toFixed(4),
         getClampedWallCurveOffset(wall).toFixed(4),
@@ -74,6 +84,9 @@ function zoneGeometrySignature(zone) {
         zone.wallMaterial,
         zone.wallOverrides,
         zone.seed,
+        // A porch's type and framing settings rebuild its posts and beam.
+        zone.roomType,
+        zone.porchFraming,
         // A drawn zone's outline is intent (it may be adopted); a room's outline is
         // derived, and an edit to it must be re-derived here as the hosted path does.
         // The kernel's own write is not a change: the baseline is taken after it.
@@ -92,11 +105,19 @@ function levelStructureSnapshots(nodes) {
     const zonesByLevel = new Map();
     const slabElevationsByLevel = new Map();
     const coveringUndersidesByLevel = new Map();
+    const porchPartsByLevel = new Map();
     const floorOpenings = [];
     for (const node of Object.values(nodes)) {
         if (!(node && typeof node === 'object' && 'parentId' in node && node.parentId))
             continue;
         const levelId = node.parentId;
+        // A porch's own post or beam moved, resized or deleted by hand hands its framing over.
+        const porchPart = porchPartSignature(node);
+        if (porchPart) {
+            const parts = porchPartsByLevel.get(levelId) ?? [];
+            parts.push(porchPart);
+            porchPartsByLevel.set(levelId, parts);
+        }
         if (node.type === 'stair' && nodes[node.deckSlabId]?.support === 'open') {
             const target = nodes[node.deckSlabId].parentId;
             const arrivals = arrivalsByLevel.get(target) ?? [];
@@ -196,6 +217,7 @@ function levelStructureSnapshots(nodes) {
         ...zonesByLevel.keys(),
         ...separatorsByLevel.keys(),
         ...openingsByLevel.keys(),
+        ...porchPartsByLevel.keys(),
     ]);
     for (const levelId of levelIds) {
         const walls = wallsByLevel.get(levelId) ?? [];
@@ -207,7 +229,7 @@ function levelStructureSnapshots(nodes) {
         const aboveSlabKey = aboveId
             ? (coveringUndersidesByLevel.get(aboveId) ?? []).sort().join(';')
             : '';
-        snapshots.set(levelId, `${(arrivalsByLevel.get(levelId) ?? []).sort().join('|')}#${(separatorsByLevel.get(levelId) ?? []).sort().join('|')}#${storeyKey}#${levelWallSnapshot(walls, nodes, levelId)}##${zones.map(zoneGeometrySignature).sort().join('||')}##${slabKey}##${aboveSlabKey}##${(ceilingIdsByLevel.get(levelId) ?? []).sort().join('|')}##${(openingsByLevel.get(levelId) ?? []).sort().join('|')}`);
+        snapshots.set(levelId, `${(arrivalsByLevel.get(levelId) ?? []).sort().join('|')}#${(separatorsByLevel.get(levelId) ?? []).sort().join('|')}#${storeyKey}#${levelWallSnapshot(walls, nodes, levelId)}##${zones.map(zoneGeometrySignature).sort().join('||')}##${slabKey}##${aboveSlabKey}##${(ceilingIdsByLevel.get(levelId) ?? []).sort().join('|')}##${(openingsByLevel.get(levelId) ?? []).sort().join('|')}##${(porchPartsByLevel.get(levelId) ?? []).sort().join('|')}`);
     }
     return snapshots;
 }
@@ -335,11 +357,17 @@ function fallbackLevelIdsForCandidates(before, current, candidateIds) {
                 if (wall?.parentId)
                     levelIds.add(wall.parentId);
             }
+            else if (porchPartOf(node)) {
+                // A porch's own post or beam edited by hand: the kernel hands its framing over.
+                if (porchPartSignature(before[id]) !== porchPartSignature(current[id]) && node.parentId)
+                    levelIds.add(node.parentId);
+            }
             else if (node.type === 'slab') {
                 const old = before[id], next = current[id];
                 const changed = !old ||
                     !next ||
-                    ['thickness', 'floorHeight', 'polygon', 'holes', 'elevation'].some((field) => JSON.stringify(old[field]) !==
+                    // Everything the covering underside below reads, as well as this level's own floor.
+                    ['thickness', 'floorHeight', 'polygon', 'holes', 'elevation', 'recessed'].some((field) => JSON.stringify(old[field]) !==
                         JSON.stringify(next[field]));
                 addLevelAndLower(node.parentId, nodes, changed);
                 if (node.plateRole === 'base' && changed)
@@ -375,9 +403,12 @@ function detectSpacesFromWalls(levelId, boundaries) {
     const rooms = extractRooms(boundaries);
     const walls = boundaries.filter((boundary) => boundary.type === 'wall');
     const roomPolygons = rooms.map((room) => room.polygon);
+    const spans = rooms.flatMap((room) => room.spans);
+    // A room a railing fences off from the outside (a deck's guard) is outside.
+    const fenced = railingFencedRoomIds(spans, railingWallIds(walls));
     const wallUpdates = walls.map((wall) => ({
         wallId: wall.id,
-        ...classifyWallSides(wall, rooms.flatMap((room) => room.spans)),
+        ...classifyWallSides(wall, spans, fenced),
     }));
     return {
         rooms,
@@ -389,6 +420,48 @@ function detectSpacesFromWalls(levelId, boundaries) {
 export function detectSpacesForLevel(levelId, walls) {
     return detectSpacesFromWalls(levelId, walls);
 }
+/**
+ * Levels whose structure intent differs between two versions of a scene: what a paused batch's
+ * resume (and a detached scene's reconciliation) re-derives.
+ */
+export function changedStructureLevelIds(before, after) {
+    const previous = levelStructureSnapshots(before);
+    const current = levelStructureSnapshots(after);
+    return [...new Set([...previous.keys(), ...current.keys()])].filter((id) => previous.get(id) !== current.get(id));
+}
+/**
+ * Levels whose structure an edit from `before` to `after` asks to re-derive, chosen as space
+ * detection chooses them for a store commit: from the nodes the edit changed (walls by level, and
+ * the fallbacks for levels, stairs, openings, slabs, ceilings, zones and separators), without
+ * signing every level of the scene.
+ */
+export function structureLevelsForChange(before, after) {
+    const candidateIds = new Set();
+    for (const id in after)
+        if (after[id] !== before[id] && !onlyChildrenChanged(before[id], after[id]))
+            candidateIds.add(id);
+    for (const id in before)
+        if (!(id in after))
+            candidateIds.add(id);
+    if (!candidateIds.size)
+        return [];
+    const levels = fallbackLevelIdsForCandidates(before, after, candidateIds);
+    for (const levelId of changedWallIdsByLevel(before, after, candidateIds).keys())
+        levels.add(levelId);
+    return [...levels];
+}
+/**
+ * A parent whose child list alone changed: the children created or deleted are candidates of
+ * their own, so the parent adds nothing (an item placed on a level re-derives no structure).
+ */
+function onlyChildrenChanged(before, after) {
+    if (!(before && after))
+        return false;
+    for (const key of new Set([...Object.keys(before), ...Object.keys(after)]))
+        if (key !== 'children' && before[key] !== after[key])
+            return false;
+    return true;
+}
 function syncSceneStructure(levelIds, sceneStore, previousNodes, mintId) {
     applyStructureReconciliation(sceneStore, { levelIds, previousNodes, mintId });
 }
@@ -402,26 +475,28 @@ function publishSpaces(levelIds, nodes, editorStore) {
     }
     editorStore.getState().setSpaces(nextSpaces);
 }
-// Batch writers pause intermediate topology; the final resume reconciles every
-// level whose intent changed, including batches completed outside a store commit.
-let spaceDetectionPauseDepth = 0;
-const resumeListeners = new Set();
+const SPACE_DETECTION_PAUSE = Symbol('space-detection-pause');
+const pauseOf = (environment = currentSceneEnvironment()) => environment.slot(SPACE_DETECTION_PAUSE, () => ({
+    depth: 0,
+    resumeListeners: new Set(),
+}));
 /** Pause structure reconciliation. Refcounted — pair with `resumeSpaceDetection`. */
 export function pauseSpaceDetection() {
-    spaceDetectionPauseDepth += 1;
+    pauseOf().depth += 1;
 }
 /** Resume structure reconciliation. No-op if not currently paused. */
 export function resumeSpaceDetection() {
-    if (spaceDetectionPauseDepth === 0)
+    const pause = pauseOf();
+    if (pause.depth === 0)
         return;
-    spaceDetectionPauseDepth -= 1;
-    if (spaceDetectionPauseDepth === 0)
-        for (const reconcile of resumeListeners)
+    pause.depth -= 1;
+    if (pause.depth === 0)
+        for (const reconcile of pause.resumeListeners)
             reconcile();
 }
 /** True iff structure reconciliation is currently paused. */
 export function isSpaceDetectionPaused() {
-    return spaceDetectionPauseDepth > 0;
+    return pauseOf().depth > 0;
 }
 export function createRoomTopologyIndex() {
     return new RoomTopologyIndex({
@@ -436,6 +511,7 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
     // scene that merely loaded — rerunning on hydration resurrected auto slabs
     // the user had deleted in an earlier session.
     const initialNodes = sceneStore.getState().nodes;
+    const pause = pauseOf(sceneEnvironmentOf(sceneStore));
     const topologyIndex = new RoomTopologyIndex({
         detectRooms: extractRooms,
         sampleWall: (wall) => sampleWallPointsForRoomDetection(wall).map(pointToTuple),
@@ -459,11 +535,11 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
         previousNodes = nodes;
     };
     adoptSceneBaseline(initialNodes);
-    const unsubscribeCommits = subscribeSceneCommits((commit) => {
+    const unsubscribeCommits = sceneEnvironmentOf(sceneStore).run(() => subscribeSceneCommits((commit) => {
         if (commit.origin === 'local')
             return;
         adoptSceneBaseline(commit.current.nodes);
-    });
+    }));
     // Keep reconciliation in this synchronous store subscription. Zundo emits
     // the originating local SceneCommit only after subscribers return, so the
     // history-paused derived writes below join that commit's current snapshot
@@ -476,11 +552,27 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
             adoptSceneBaseline(state.nodes);
             return;
         }
-        if (getSceneHistoryPauseDepth() > 0 || sceneStore.temporal.getState().isTracking === false)
+        // A settling host derives this edit's structure itself (reconcileDocument): only the topology
+        // and spaces of the levels whose walls it changed are brought up to date here. Its derived
+        // writes are history-paused, so this runs before the pause check: the baseline must take them
+        // in, or the next edit would derive the host's rooms again from before it.
+        if (isSettlingDocument(sceneStore)) {
+            const levels = [
+                ...changedWallIdsByLevel(previousNodes, state.nodes, activeSceneCommitNodeIds()).keys(),
+            ];
+            for (const levelId of levels)
+                topologyIndex.rebuildLevel(levelId, state.nodes);
+            if (levels.length)
+                publishSpaces(levels, state.nodes, editorStore);
+            previousNodes = state.nodes;
+            return;
+        }
+        if (getSceneHistoryPauseDepth(sceneStore) > 0 ||
+            sceneStore.temporal.getState().isTracking === false)
             return;
         const nodes = state.nodes;
         const candidateIds = activeSceneCommitNodeIds();
-        if (spaceDetectionPauseDepth > 0)
+        if (pause.depth > 0)
             return;
         const changedWalls = changedWallIdsByLevel(previousNodes, nodes, candidateIds);
         if (candidateIds && changedWalls.size > 0) {
@@ -563,10 +655,7 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
             return { nodes, rootNodeIds, collections, materials, installedPlugins };
         };
         const beforeCommit = capture();
-        const nodes = beforeCommit.nodes;
-        const before = levelStructureSnapshots(previousNodes);
-        const after = levelStructureSnapshots(nodes);
-        const levels = [...new Set([...before.keys(), ...after.keys()])].filter((id) => before.get(id) !== after.get(id));
+        const levels = changedStructureLevelIds(previousNodes, beforeCommit.nodes);
         if (!levels.length)
             return;
         isProcessing = true;
@@ -586,11 +675,11 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
         // so collaboration receives the originator's ids even for AI/template batches.
         notifySceneCommit({ origin: 'local', before: beforeCommit, current: capture() });
     };
-    resumeListeners.add(reconcilePaused);
+    pause.resumeListeners.add(reconcilePaused);
     return () => {
         unsubscribe();
         unsubscribeCommits();
-        resumeListeners.delete(reconcilePaused);
+        pause.resumeListeners.delete(reconcilePaused);
     };
 }
 export function wallTouchesOthers(wall, otherWalls) {