@pascal-app/core 1.0.5 → 1.0.7

package/dist/lib/opening-floor-datum.js

@@ -3,7 +3,9 @@ import { computeWallSlabSupport, } from '../systems/slab/slab-support.js';
 import { getWallCurveFrameAt, getWallCurveLength } from '../systems/wall/wall-curve.js';
 import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
 import { getWallBodyCenterOffset } from '../systems/wall/wall-frame.js';
+import { getDoorOpeningSize } from './door-opening.js';
 import { isFloorAnchoredOpening, openingAperture, wallOpeningBand, } from './floor-opening-footprints.js';
+import { openingHostFacing } from './opening-casing.js';
 import { area, intersection, union } from './polygon-boolean.js';
 import { levelBaseElevationAt } from './terrain-support-query.js';
 const supportCache = new WeakMap();
@@ -47,8 +49,10 @@ export function openingDatumFromSupport(wall, opening, support) {
     if (!isFloorAnchoredOpening(opening))
         return support.elevation;
     const length = getWallCurveLength(wall);
-    const from = Math.max(0, (opening.position[0] - opening.width / 2) / length);
-    const to = Math.min(1, (opening.position[0] + opening.width / 2) / length);
+    const size = getDoorOpeningSize({ ...opening, height: opening.height ?? 0 });
+    const centerX = opening.position[0] - size.leafOffsetX * openingHostFacing(opening);
+    const from = Math.max(0, (centerX - size.width / 2) / length);
+    const to = Math.min(1, (centerX + size.width / 2) / length);
     const heights = [...support.faceDatum.a, ...support.faceDatum.b].flatMap((segment) => {
         const start = Math.max(from, segment.start), end = Math.min(to, segment.end);
         return end > start ? [supportSegmentAt(segment, start), supportSegmentAt(segment, end)] : [];
@@ -61,7 +65,31 @@ export function getOpeningFloorTarget(wall, opening, nodes) {
 }
 export function openingFitsAtDatum(wall, opening, datum, nodes, support = wallSupportForNodes(wall, nodes)) {
     const top = getWallTop(wall, wall.parentId, nodes, support.elevation);
-    return datum + opening.position[1] + opening.height / 2 <= top + 1e-9;
+    return (datum +
+        opening.position[1] -
+        opening.height / 2 +
+        getDoorOpeningSize({ ...opening, width: 0 }).height <=
+        top + 1e-9);
+}
+/**
+ * The lowest the wall reaches under the opening's span, level-local, on its centreline or either
+ * face: where a face goes down beside a floor sunk under the one the wall stands on (a garage
+ * beside the house), lower than that floor.
+ */
+export function wallBottomUnderOpening(wall, opening, support) {
+    const length = getWallCurveLength(wall);
+    if (length < 1e-9)
+        return support.baseElevation;
+    const size = getDoorOpeningSize({ ...opening, height: opening.height ?? 0 });
+    const centerX = opening.position[0] - size.leafOffsetX * openingHostFacing(opening);
+    const from = Math.max(0, (centerX - size.width / 2) / length);
+    const to = Math.min(1, (centerX + size.width / 2) / length);
+    const segments = [...support.baseSegments, ...support.faceBottom.a, ...support.faceBottom.b];
+    const heights = segments.flatMap((segment) => {
+        const start = Math.max(from, segment.start), end = Math.min(to, segment.end);
+        return end > start ? [supportSegmentAt(segment, start), supportSegmentAt(segment, end)] : [];
+    });
+    return heights.length ? Math.min(...heights) : support.baseElevation;
 }
 export function getOpeningFloorDatum(wall, opening, nodes, support = wallSupportForNodes(wall, nodes)) {
     const target = openingDatumFromSupport(wall, opening, support);
@@ -102,13 +130,17 @@ export function getOpeningWallCut(wall, opening, nodes, support = wallSupportFor
     covers.set(datum, cover);
     const covered = area(aperture) > 0 && area(intersection(aperture, cover)) >= area(aperture) - 0.00001;
     const length = getWallCurveLength(wall);
-    const from = (opening.position[0] - opening.width / 2) / length, to = (opening.position[0] + opening.width / 2) / length;
+    const size = getDoorOpeningSize({ ...opening, height: opening.height ?? 0 });
+    const centerX = opening.position[0] - size.leafOffsetX * openingHostFacing(opening);
+    const from = (centerX - size.width / 2) / length, to = (centerX + size.width / 2) / length;
     const bottoms = [...support.faceBottom.a, ...support.faceBottom.b]
         .filter((s) => s.end > from && s.start < to)
         .map((s) => Math.min(s.elevation, s.endElevation ?? s.elevation));
+    // An opening may reach below its floor (a negative sill: a garage door down to the garage floor
+    // sunk beside the wall), never below the wall itself.
     const bottom = isFloorAnchoredOpening(opening) && covered
         ? Math.min(support.elevation, ...bottoms)
-        : datum + opening.position[1] - opening.height / 2;
+        : Math.max(datum + opening.position[1] - opening.height / 2, Math.min(datum, wallBottomUnderOpening(wall, opening, support)));
     return {
         // The floor the doorway exposes: exactly the wall's own footprint.
         aperture,
@@ -116,7 +148,7 @@ export function getOpeningWallCut(wall, opening, nodes, support = wallSupportFor
         band: wallOpeningBand(wall, Math.max(0, from), Math.min(1, to)),
         datum,
         bottom,
-        top: datum + opening.position[1] + opening.height / 2,
+        top: datum + opening.position[1] - opening.height / 2 + size.height,
         covered,
     };
 }

package/dist/lib/opening-frame-depth.d.ts

@@ -0,0 +1,18 @@
+import type { AnyNode, DoorNode, WindowNode } from '../schema/index.js';
+type FrameDepthOpening = Pick<DoorNode | WindowNode, 'frameDepth'>;
+/** An opening without an explicit frame depth follows its host wall. */
+export declare function isAutoFrameDepth(opening: FrameDepthOpening): boolean;
+/**
+ * The depth a door's or window's frame runs through its wall. An explicit
+ * `frameDepth` is kept as stored; left out, the frame is the host wall's
+ * thickness exactly.
+ */
+export declare function resolveOpeningFrameDepth(opening: FrameDepthOpening, wallThickness: number): number;
+/**
+ * `resolveOpeningFrameDepth` against the opening's host in `nodes`: its parent
+ * wall's thickness, or the default wall thickness off a wall (a roof face, a
+ * dormer, an unparented preview).
+ */
+export declare function resolveHostedOpeningFrameDepth(opening: Pick<DoorNode | WindowNode, 'frameDepth' | 'parentId'>, nodes: Readonly<Record<string, AnyNode | undefined>>): number;
+export {};
+//# sourceMappingURL=opening-frame-depth.d.ts.map

package/dist/lib/opening-frame-depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-frame-depth.d.ts","sourceRoot":"","sources":["../../src/lib/opening-frame-depth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAG9D,KAAK,iBAAiB,GAAG,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,YAAY,CAAC,CAAA;AAElE,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAEpE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,iBAAiB,EAC1B,aAAa,EAAE,MAAM,GACpB,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,YAAY,GAAG,UAAU,CAAC,EAC/D,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,GACnD,MAAM,CAMR"}

package/dist/lib/opening-frame-depth.js

@@ -0,0 +1,22 @@
+import { DEFAULT_WALL_THICKNESS, getWallThickness } from '../systems/wall/wall-footprint.js';
+/** An opening without an explicit frame depth follows its host wall. */
+export function isAutoFrameDepth(opening) {
+    return opening.frameDepth === undefined;
+}
+/**
+ * The depth a door's or window's frame runs through its wall. An explicit
+ * `frameDepth` is kept as stored; left out, the frame is the host wall's
+ * thickness exactly.
+ */
+export function resolveOpeningFrameDepth(opening, wallThickness) {
+    return opening.frameDepth ?? wallThickness;
+}
+/**
+ * `resolveOpeningFrameDepth` against the opening's host in `nodes`: its parent
+ * wall's thickness, or the default wall thickness off a wall (a roof face, a
+ * dormer, an unparented preview).
+ */
+export function resolveHostedOpeningFrameDepth(opening, nodes) {
+    const host = opening.parentId ? nodes[opening.parentId] : undefined;
+    return resolveOpeningFrameDepth(opening, host?.type === 'wall' ? getWallThickness(host) : DEFAULT_WALL_THICKNESS);
+}

package/dist/lib/outdoor-room.d.ts

@@ -0,0 +1,32 @@
+import type { ZoneNode } from '../schema/index.js';
+export declare const OUTDOOR_ROOM_TYPES: readonly ['porch', 'deck', 'patio'];
+export type OutdoorRoomType = (typeof OUTDOOR_ROOM_TYPES)[number];
+/** A porch or patio slab steps down from the house's finish floor by 1.5 in at most. */
+export declare const PORCH_FLOOR_DROP: number;
+/** Deck boards ride 1 in under the threshold so water sheds away from the door. */
+export declare const DECK_FLOOR_DROP: number;
+/**
+ * The deck boards on a deck's floor unless its room says otherwise (5/4x6, 1 in: `lib/deck-boards`);
+ * the framing hangs under them.
+ */
+export declare const DECKING_THICKNESS: number;
+export type OutdoorRoomDefaults = {
+    /** The name a room of the type is given while it has a default name. */
+    name: string;
+    drop: number;
+    /** The floor finish it starts with. */
+    finish: string;
+    /** Whether it has a ceiling (a covered porch). */
+    covered: boolean;
+    /** How the framing plugin reads its floor plate (`metadata.floor`). */
+    floorTag: 'porch-slab' | 'deck';
+};
+export declare const OUTDOOR_ROOM_DEFAULTS: Record<OutdoorRoomType, OutdoorRoomDefaults>;
+export declare function isOutdoorRoomType(value: unknown): value is OutdoorRoomType;
+/** Whether a room is one of the outdoor room types. */
+export declare function isOutdoorRoom(zone: Pick<ZoneNode, 'roomType'>): boolean;
+/** "Porch", "Porch 2", …: the next free name for a room of `type` among `names`. */
+export declare function nextOutdoorRoomName(type: OutdoorRoomType, names: Iterable<string>): string;
+/** Whether `name` is a type's default name ("Deck", "Deck 3"), so a type change may rename it. */
+export declare function isOutdoorRoomDefaultName(name: string | undefined): boolean;
+//# sourceMappingURL=outdoor-room.d.ts.map

package/dist/lib/outdoor-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outdoor-room.d.ts","sourceRoot":"","sources":["../../src/lib/outdoor-room.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAezC,eAAO,MAAM,kBAAkB,YAAI,OAAO,EAAE,MAAM,EAAE,OAAO,CAAU,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjE,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,QAAW,CAAA;AACxC,mFAAmF;AACnF,eAAO,MAAM,eAAe,QAAS,CAAA;AACrC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAA0C,CAAA;AAExE,MAAM,MAAM,mBAAmB,GAAG;IAChC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAA;IAChB,uEAAuE;IACvE,QAAQ,EAAE,YAAY,GAAG,MAAM,CAAA;CAChC,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAsB9E,CAAA;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E;AAED,uDAAuD;AACvD,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAAG,OAAO,CAEvE;AAED,oFAAoF;AACpF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,CAK1F;AAED,kGAAkG;AAClG,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAO1E"}

package/dist/lib/outdoor-room.js

@@ -0,0 +1,66 @@
+import { DEFAULT_DECK_BOARDS, deckBoardThickness } from './deck-boards.js';
+/**
+ * Rooms outside the house, the outdoor room types: a porch (a covered floor a step
+ * down from the house), a deck (a framed floor of boards) and a patio (an uncovered slab). A room
+ * of one of these types is outdoors whatever covers it, so the house walls it faces are exterior
+ * walls even under a porch ceiling, and its floor steps down from the house's (`floor.drop`).
+ *
+ * A room closed off outside the house by invisible walls starts as a porch: its floor a concrete
+ * slab 1.5 in under the house's and its ceiling at the house's, both adjustable in its panel.
+ */
+const IN = 0.0254;
+export const OUTDOOR_ROOM_TYPES = ['porch', 'deck', 'patio'];
+/** A porch or patio slab steps down from the house's finish floor by 1.5 in at most. */
+export const PORCH_FLOOR_DROP = 1.5 * IN;
+/** Deck boards ride 1 in under the threshold so water sheds away from the door. */
+export const DECK_FLOOR_DROP = 1 * IN;
+/**
+ * The deck boards on a deck's floor unless its room says otherwise (5/4x6, 1 in: `lib/deck-boards`);
+ * the framing hangs under them.
+ */
+export const DECKING_THICKNESS = deckBoardThickness(DEFAULT_DECK_BOARDS);
+export const OUTDOOR_ROOM_DEFAULTS = {
+    porch: {
+        name: 'Porch',
+        drop: PORCH_FLOOR_DROP,
+        finish: 'library:concrete-raw',
+        covered: true,
+        floorTag: 'porch-slab',
+    },
+    deck: {
+        name: 'Deck',
+        drop: DECK_FLOOR_DROP,
+        finish: 'library:wood-woodfine11',
+        covered: false,
+        floorTag: 'deck',
+    },
+    patio: {
+        name: 'Patio',
+        drop: PORCH_FLOOR_DROP,
+        finish: 'library:concrete-raw',
+        covered: false,
+        floorTag: 'porch-slab',
+    },
+};
+export function isOutdoorRoomType(value) {
+    return typeof value === 'string' && OUTDOOR_ROOM_TYPES.includes(value);
+}
+/** Whether a room is one of the outdoor room types. */
+export function isOutdoorRoom(zone) {
+    return isOutdoorRoomType(zone.roomType);
+}
+/** "Porch", "Porch 2", …: the next free name for a room of `type` among `names`. */
+export function nextOutdoorRoomName(type, names) {
+    const base = OUTDOOR_ROOM_DEFAULTS[type].name;
+    const taken = new Set(names);
+    if (!taken.has(base))
+        return base;
+    for (let n = 2;; n++)
+        if (!taken.has(`${base} ${n}`))
+            return `${base} ${n}`;
+}
+/** Whether `name` is a type's default name ("Deck", "Deck 3"), so a type change may rename it. */
+export function isOutdoorRoomDefaultName(name) {
+    return (typeof name === 'string' &&
+        OUTDOOR_ROOM_TYPES.some((type) => new RegExp(`^${OUTDOOR_ROOM_DEFAULTS[type].name}( \\d+)?$`).test(name)));
+}

package/dist/lib/plate-surface.d.ts

@@ -92,6 +92,14 @@ export declare function plateOpeningLandings(context: PlateLevelContext): import
  * `platePartitionSignature`. Returns `null` for anything that is not an
  * unrecessed floor plate — manual slabs and pools keep the plain two-slot path.
  */
+/**
+ * The doorways cut out of `plate`, each its wall's span past both faces (whole, so a cut never
+ * runs along the plate's own edge): those of the openings reaching below their floor (a negative
+ * sill: a garage door down to the garage floor sunk beside its wall) where the plate stands above
+ * the opening's bottom. The doorway is then open from its bottom to its head on both faces, with
+ * no strip of the floor the wall stands on left across it.
+ */
+export declare function plateDoorwayCuts(plate: SlabNode, context: PlateLevelContext): MultiPolygon;
 export declare function computePlateSurfacePartition(plate: SlabNode, context: PlateLevelContext): PlateSurfacePartition | null;
 /**
  * The doorway keys of every step `zoneId` owns on its level — what the room

package/dist/lib/plate-surface.d.ts.map

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

package/dist/lib/plate-surface.js

@@ -1,6 +1,7 @@
 import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
-import { getWallCurveFrameAt, getWallCurveStationAtPoint } from '../systems/wall/wall-curve.js';
+import { getWallCurveFrameAt, getWallCurveLength, getWallCurveStationAtPoint, isCurvedWall, } from '../systems/wall/wall-curve.js';
 import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { getWallFaceOffsets } from '../systems/wall/wall-frame.js';
 import { openingLandings } from './floor-opening-footprints.js';
 import { floorRoomFaces } from './floor-room-faces.js';
 import { exposedIntervals } from './level-footprints.js';
@@ -566,7 +567,13 @@ function classifySides(plate, top, context, prepared) {
                     ...(hi < b ? [[hi, b]] : []),
                 ]);
         const role = adjacent || neighbour ? 'riser' : 'edge';
-        const owner = role === 'riser' || plate.plateRole !== 'base' ? ownerId : undefined;
+        // A base plate's side facing into one of its own holes (a void, a stairwell) belongs to the
+        // room around the hole, so it can wear that room's floor edge rather than the facade's.
+        const holeOwner = plate.plateRole === 'base' &&
+            top.some(({ outer }) => containsPoint([{ outer, holes: [] }], outside))
+            ? zones.find((entry) => containsPoint(entry.polygon, inside))?.zone.id
+            : undefined;
+        const owner = role === 'riser' || plate.plateRole !== 'base' ? ownerId : holeOwner;
         // A door jamb's side of the step meets the aperture only at its edge, so
         // the doorway is looked for on both sides of the face too.
         const doorway = opening ??
@@ -600,6 +607,48 @@ const partitionCache = new Map();
  * `platePartitionSignature`. Returns `null` for anything that is not an
  * unrecessed floor plate — manual slabs and pools keep the plain two-slot path.
  */
+/**
+ * The doorways cut out of `plate`, each its wall's span past both faces (whole, so a cut never
+ * runs along the plate's own edge): those of the openings reaching below their floor (a negative
+ * sill: a garage door down to the garage floor sunk beside its wall) where the plate stands above
+ * the opening's bottom. The doorway is then open from its bottom to its head on both faces, with
+ * no strip of the floor the wall stands on left across it.
+ */
+export function plateDoorwayCuts(plate, context) {
+    if (!isFloorPlate(plate) || plate.recessed || plate.polygon.length < 3)
+        return [];
+    const elevation = plate.elevation ?? DEFAULT_SLAB_ELEVATION;
+    const top = slabTop(plate);
+    return union(levelInputs(context).openings.flatMap(({ opening, wall, cut }) => {
+        if (opening.position[1] - opening.height / 2 >= -BELOW_FLOOR_SILL)
+            return [];
+        if (cut.bottom >= elevation - 1e-3)
+            return [];
+        const band = doorwayBand(wall, opening);
+        return area(intersection(band, top)) > 0 ? [band] : [];
+    }));
+}
+/**
+ * The doorway's span of the wall, past both faces by {@link DOORWAY_OVERSHOOT}: a plate edge a few
+ * millimetres off the face (a plate drawn to the wall's line, a wall a hair out of square) would
+ * otherwise leave a sliver whose side face shows as a bar across the doorway.
+ */
+function doorwayBand(wall, opening) {
+    const length = getWallCurveLength(wall);
+    const from = Math.max(0, (opening.position[0] - opening.width / 2) / length);
+    const to = Math.min(1, (opening.position[0] + opening.width / 2) / length);
+    const faces = getWallFaceOffsets(wall);
+    const count = isCurvedWall(wall) ? Math.max(2, Math.ceil((to - from) * 96)) : 1;
+    const side = (offset) => Array.from({ length: count + 1 }, (_, i) => {
+        const frame = getWallCurveFrameAt(wall, from + ((to - from) * i) / count);
+        return [frame.point.x + frame.normal.x * offset, frame.point.y + frame.normal.y * offset];
+    });
+    return [...side(faces.a + DOORWAY_OVERSHOOT), ...side(faces.b - DOORWAY_OVERSHOOT).reverse()];
+}
+/** How far past each wall face a doorway is cut out of the plates it crosses. */
+const DOORWAY_OVERSHOOT = 0.02;
+/** A sill this far under its floor reaches below it; nearer is the floor (rounding). */
+const BELOW_FLOOR_SILL = 1e-3;
 export function computePlateSurfacePartition(plate, context) {
     if (!isFloorPlate(plate) || plate.recessed || plate.polygon.length < 3)
         return null;
@@ -607,7 +656,8 @@ export function computePlateSurfacePartition(plate, context) {
     const cached = partitionCache.get(signature);
     if (cached)
         return cached;
-    const top = slabTop(plate);
+    const doorways = plateDoorwayCuts(plate, context);
+    const top = doorways.length ? difference(slabTop(plate), doorways) : slabTop(plate);
     if (!top.length)
         return null;
     const wallCover = levelWallCover(context.walls);

package/dist/lib/porch-framing-sync.d.ts

@@ -0,0 +1,46 @@
+import type { AnyNode, AnyNodeId, SlabNode, ZoneNode } from '../schema/index.js';
+/**
+ * A porch's posts and beams (`lib/porch-framing`), kept by the structure kernel as it keeps a
+ * room's floor and ceiling: made when a covered porch has an open side, moved with the porch,
+ * rebuilt when its framing settings change, removed when it stops being a covered porch. A deck
+ * or patio gets the same once they are switched on, to carry a roof over it. They are ordinary
+ * post and beam nodes. Moving, resizing or deleting one hands the room's framing to the user
+ * (`porchFraming.auto: false`): framing edited by hand stops rebuilding; turning it back on
+ * rebuilds it.
+ */
+type Nodes = Readonly<Record<string, AnyNode>>;
+/** What the kernel stamps on a porch part: the porch, which part, and what it made it as. */
+export type PorchPartMetadata = {
+    porchOf: string;
+    porchPart: string;
+    porchSeed: string;
+};
+/** The porch a post or beam was made for, when the kernel made it. */
+export declare function porchPartOf(node: AnyNode | null | undefined): PorchPartMetadata | null;
+/** Keep generated parts linked when reconciliation assigns their room its stable ID. */
+export declare function remapPorchOwner(metadata: Record<string, unknown> | undefined, ids: ReadonlyMap<string, string>): Record<string, unknown> | undefined;
+/**
+ * A porch part's id and shape, for the structure sync to notice a hand edit or a delete (and run
+ * the kernel, which hands the porch's framing over); null for any other node.
+ */
+export declare function porchPartSignature(node: AnyNode | null | undefined): string | null;
+/**
+ * The kernel's porch framing pass over one level: which posts and beams to put and delete, and
+ * the porches whose framing a hand edit has handed to the user. `zones` are the level's rooms as
+ * the pass leaves them, `plates` its floor plates, `current` a node as the pass has it so far;
+ * `previousNodes` (the scene before the edit) tells a deleted part from one never made.
+ */
+export declare function reconcilePorchFraming({ levelId, nodes, previousNodes, zones, plates, current, mintId, }: {
+    levelId: string;
+    nodes: Nodes;
+    previousNodes?: Nodes;
+    zones: readonly ZoneNode[];
+    plates: readonly SlabNode[];
+    current: (id: string) => AnyNode | undefined;
+    mintId: (kind: 'column' | 'beam') => string;
+}): {
+    put: AnyNode[];
+    delete: AnyNodeId[];
+};
+export {};
+//# sourceMappingURL=porch-framing-sync.d.ts.map

package/dist/lib/porch-framing-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"porch-framing-sync.d.ts","sourceRoot":"","sources":["../../src/lib/porch-framing-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAYvE;;;;;;;;GAQG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAG9C,6FAA6F;AAC7F,MAAM,MAAM,iBAAiB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzF,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,iBAAiB,GAAG,IAAI,CAMtF;AAED,wFAAwF;AACxF,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,GAAG,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAIrC;AAmBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAElF;AA0HD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,OAAO,EACP,KAAK,EACL,aAAa,EACb,KAAK,EACL,MAAM,EACN,OAAO,EACP,MAAM,GACP,EAAE;IACD,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,KAAK,CAAA;IACZ,aAAa,CAAC,EAAE,KAAK,CAAA;IACrB,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC3B,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAA;IAC5C,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,KAAK,MAAM,CAAA;CAC5C,GAAG;IAAE,GAAG,EAAE,OAAO,EAAE,CAAC;IAAC,MAAM,EAAE,SAAS,EAAE,CAAA;CAAE,CAmE1C"}

package/dist/lib/porch-framing-sync.js

@@ -0,0 +1,206 @@
+import { beamBottomElevation, createBeam } from './beam.js';
+import { createFramingPost, FRAMING_POST_MIN_HEIGHT, framingPostFields, framingPostSize, } from './framing-post.js';
+import { planPorchFraming, porchFramingSettings } from './porch-framing.js';
+/** The porch a post or beam was made for, when the kernel made it. */
+export function porchPartOf(node) {
+    if (node?.type !== 'column' && node?.type !== 'beam')
+        return null;
+    const metadata = node.metadata;
+    return typeof metadata?.porchOf === 'string' && typeof metadata.porchPart === 'string'
+        ? metadata
+        : null;
+}
+/** Keep generated parts linked when reconciliation assigns their room its stable ID. */
+export function remapPorchOwner(metadata, ids) {
+    return typeof metadata?.porchOf === 'string' && ids.has(metadata.porchOf)
+        ? { ...metadata, porchOf: ids.get(metadata.porchOf) }
+        : undefined;
+}
+const round = (value) => Math.round(value * 1e6) / 1e6;
+/** A part's shape, as it was made: anything else is a hand edit. */
+function seedOf(part) {
+    if (part.type === 'column')
+        return JSON.stringify([part.position[0], part.position[2], part.width, part.depth, part.height, part.rotation].map(round));
+    return JSON.stringify([
+        ...[...part.start, ...part.end, part.width, part.depth].map(round),
+        part.topElevation === undefined ? null : round(part.topElevation),
+        part.placement,
+    ]);
+}
+/**
+ * A porch part's id and shape, for the structure sync to notice a hand edit or a delete (and run
+ * the kernel, which hands the porch's framing over); null for any other node.
+ */
+export function porchPartSignature(node) {
+    return porchPartOf(node) ? JSON.stringify([node.id, seedOf(node)]) : null;
+}
+function edited(part) {
+    return seedOf(part) !== porchPartOf(part)?.porchSeed;
+}
+/**
+ * A room the kernel frames, still closed and its framing automatic: a covered porch (automatic
+ * unless switched off), or a deck or patio whose posts and beam are switched on (`auto: true`, to
+ * carry a roof over it; off by default).
+ */
+function framedPorch(zone) {
+    if (!zone || zone.enclosureStatus === 'open')
+        return false;
+    if (zone.roomType === 'porch')
+        return zone.hasCeiling !== false && zone.porchFraming?.auto !== false;
+    return coverOptional(zone) && zone.porchFraming?.auto === true;
+}
+/** A deck or patio: its posts and beam are off until switched on. */
+function coverOptional(zone) {
+    return zone.roomType === 'deck' || zone.roomType === 'patio';
+}
+/** The floor plate a porch's posts stand on: its own step-down plate, else the one it shares. */
+function porchPlate(zone, plates) {
+    const holding = plates.filter((plate) => plate.zoneIds?.includes(zone.id));
+    return holding.find((plate) => plate.plateRole !== 'base') ?? holding[0];
+}
+const yawOf = (start, end) => Math.atan2(-(end[1] - start[1]), end[0] - start[0]);
+function withPorch(node, zone, key) {
+    const metadata = { porchOf: zone.id, porchPart: key, porchSeed: '' };
+    const tagged = { ...node, metadata: { ...node.metadata, ...metadata } };
+    tagged.metadata.porchSeed = seedOf(tagged);
+    return tagged;
+}
+/** The porch's planned parts as nodes, reusing the ids (and the touches) of the ones it has. */
+function buildParts(zone, plan, owned, plate, levelId, nodes, mintId) {
+    const settings = porchFramingSettings(zone);
+    const byKey = new Map(owned.map((part) => [porchPartOf(part).porchPart, part]));
+    const beams = new Map();
+    for (const planned of plan.beams) {
+        const existing = byKey.get(planned.key);
+        const fresh = createBeam({
+            start: planned.start,
+            end: planned.end,
+            preset: settings.beamSize,
+            levelId,
+            supportSlabId: plate?.id,
+            name: `${zone.name} beam`,
+        });
+        const beam = existing?.type === 'beam'
+            ? {
+                ...existing,
+                start: fresh.start,
+                end: fresh.end,
+                width: fresh.width,
+                depth: fresh.depth,
+                size: fresh.size,
+                plies: fresh.plies,
+                material: fresh.material,
+                placement: 'dropped',
+                topElevation: undefined,
+                supportSlabId: plate?.id,
+            }
+            : { ...fresh, id: mintId('beam') };
+        beams.set(planned.key, withPorch(beam, zone, planned.key));
+    }
+    const foot = plate?.elevation ?? 0;
+    const posts = plan.posts.map((planned) => {
+        // Up to the underside of the beam it carries (the lower of two at a corner).
+        const bottoms = planned.beams.flatMap((key) => {
+            const beam = beams.get(key);
+            return beam ? [beamBottomElevation(nodes, beam)] : [];
+        });
+        const height = Math.max(FRAMING_POST_MIN_HEIGHT, Math.min(...bottoms) - foot);
+        const run = plan.beams.find((beam) => beam.key === planned.beams.at(-1));
+        const rotation = run ? yawOf(run.start, run.end) : 0;
+        const existing = byKey.get(planned.key);
+        const position = [planned.position[0], 0, planned.position[1]];
+        const post = existing?.type === 'column'
+            ? {
+                ...existing,
+                ...(framingPostSize(existing) === settings.postSize
+                    ? {}
+                    : framingPostFields(settings.postSize, existing.postBase ?? 'post-base')),
+                position,
+                rotation,
+                height,
+                supportSlabId: plate?.id,
+            }
+            : {
+                ...createFramingPost({
+                    position: planned.position,
+                    size: settings.postSize,
+                    base: 'post-base',
+                    height,
+                    levelId,
+                    supportSlabId: plate?.id,
+                    rotation,
+                    name: `${zone.name} post`,
+                }),
+                id: mintId('column'),
+            };
+        return withPorch(post, zone, planned.key);
+    });
+    return [...beams.values(), ...posts];
+}
+/**
+ * The kernel's porch framing pass over one level: which posts and beams to put and delete, and
+ * the porches whose framing a hand edit has handed to the user. `zones` are the level's rooms as
+ * the pass leaves them, `plates` its floor plates, `current` a node as the pass has it so far;
+ * `previousNodes` (the scene before the edit) tells a deleted part from one never made.
+ */
+export function reconcilePorchFraming({ levelId, nodes, previousNodes, zones, plates, current, mintId, }) {
+    const put = [];
+    const remove = [];
+    const owned = new Map();
+    for (const node of Object.values(nodes)) {
+        const part = porchPartOf(node);
+        if (!part || node.parentId !== levelId)
+            continue;
+        const latest = (current(node.id) ?? node);
+        owned.set(part.porchOf, [...(owned.get(part.porchOf) ?? []), latest]);
+    }
+    const zonesById = new Map(zones.map((zone) => [zone.id, zone]));
+    // A porch gone, or no longer a covered one: what it made goes with it; a part edited by hand
+    // stays, the user's own. A deck's or patio's switched off goes whole, edited or not.
+    for (const [zoneId, parts] of owned) {
+        const zone = zonesById.get(zoneId);
+        if (framedPorch(zone) || zone?.porchFraming?.auto === false)
+            continue;
+        const switchedOff = !!zone && coverOptional(zone) && zone.porchFraming?.auto === undefined;
+        for (const part of parts) {
+            if (switchedOff || !edited(part))
+                remove.push(part.id);
+            else {
+                const { porchOf: _porchOf, porchPart: _porchPart, porchSeed: _seed, ...metadata } = part.metadata;
+                put.push({ ...part, metadata });
+            }
+        }
+    }
+    for (const zone of zones) {
+        if (!framedPorch(zone))
+            continue;
+        const parts = owned.get(zone.id) ?? [];
+        const before = previousNodes?.[zone.id];
+        const settingsChanged = before?.type !== 'zone' ||
+            before.roomType !== zone.roomType ||
+            JSON.stringify(before.porchFraming ?? null) !== JSON.stringify(zone.porchFraming ?? null);
+        const plan = planPorchFraming(zone, nodes);
+        if (!settingsChanged) {
+            // A part of the plan gone since the edit before: deleted by hand. (One the plan dropped
+            // went with an earlier pass.)
+            const planned = new Set([...plan.posts, ...plan.beams].map((part) => part.key));
+            const deleted = Object.values(previousNodes ?? {}).some((node) => {
+                const part = porchPartOf(node);
+                return part?.porchOf === zone.id && planned.has(part.porchPart) && !nodes[node.id];
+            });
+            if (deleted || parts.some(edited)) {
+                put.push({ ...zone, porchFraming: { ...zone.porchFraming, auto: false } });
+                continue;
+            }
+        }
+        const built = buildParts(zone, plan, 
+        // Settings changed: what a hand made goes too; the porch is rebuilt from its settings.
+        parts, porchPlate(zone, plates), levelId, nodes, mintId);
+        const kept = new Set(built.map((part) => part.id));
+        for (const part of parts)
+            if (!kept.has(part.id))
+                remove.push(part.id);
+        put.push(...built);
+    }
+    return { put, delete: remove };
+}