@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/opening-floor-datum.d.ts

@@ -0,0 +1,24 @@
+import type { AnyNode, DoorNode, WallNode, WindowNode } from '../schema/index.js';
+import { type WallSlabSupport, type WallSlabSupportSegment } from '../systems/slab/slab-support.js';
+export declare function wallSupportForNodes(wall: WallNode, nodes: Readonly<Record<string, AnyNode>>): WallSlabSupport;
+export declare function supportSegmentAt(segment: WallSlabSupportSegment, t: number): number;
+export declare function openingDatumFromSupport(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height'>, support: WallSlabSupport): number;
+/** Unclamped floor intent, used by authoring feasibility and legacy migration. */
+export declare function getOpeningFloorTarget(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height'>, nodes: Readonly<Record<string, AnyNode>>): number;
+export declare function openingFitsAtDatum(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'height'>, datum: number, nodes: Readonly<Record<string, AnyNode>>, support?: WallSlabSupport): boolean;
+export declare function getOpeningFloorDatum(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height'>, nodes: Readonly<Record<string, AnyNode>>, support?: WallSlabSupport): number;
+export declare function getOpeningWallCut(wall: WallNode, opening: DoorNode | WindowNode, nodes: Readonly<Record<string, AnyNode>>, support?: WallSlabSupport): {
+    aperture: import("./polygon-boolean.js").MultiPolygon;
+    band: import("./polygon-boolean.js").Ring;
+    datum: number;
+    bottom: number;
+    top: number;
+    covered: boolean;
+};
+export declare function getOpeningWallPlacement(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width' | 'height' | 'rotation'> & {
+    metadata?: Record<string, unknown>;
+}, nodes: Readonly<Record<string, AnyNode>>): {
+    position: [number, number, number];
+    rotation: [number, number, number];
+};
+//# sourceMappingURL=opening-floor-datum.d.ts.map

package/dist/lib/opening-floor-datum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-floor-datum.d.ts","sourceRoot":"","sources":["../../src/lib/opening-floor-datum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAY,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAElF,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC5B,MAAM,8BAA8B,CAAA;AAqBrC,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,eAAe,CAoCjB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,sBAAsB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAMnF;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,EACrE,OAAO,EAAE,eAAe,GACvB,MAAM,CAWR;AAED,kFAAkF;AAClF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,EACrE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAER;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,QAAQ,CAAC,EAC3D,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,kBAAmC,GACzC,OAAO,CAGT;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,EACrE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,kBAAmC,GACzC,MAAM,CAIR;AAUD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,kBAAmC;;;;;;;EA6D3C;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC,GAAG;IACnF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,EACD,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;;;EAyBzC"}

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

@@ -0,0 +1,144 @@
+import { getWallTop } from '../services/storey.js';
+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 { isFloorAnchoredOpening, openingAperture, wallOpeningBand, } from './floor-opening-footprints.js';
+import { area, intersection, union } from './polygon-boolean.js';
+import { levelBaseElevationAt } from './terrain-support-query.js';
+const supportCache = new WeakMap();
+const childrenCache = new WeakMap();
+export function wallSupportForNodes(wall, nodes) {
+    let cached = supportCache.get(nodes);
+    if (!cached) {
+        cached = new Map();
+        supportCache.set(nodes, cached);
+    }
+    const previous = cached.get(wall);
+    if (previous)
+        return previous;
+    let levels = childrenCache.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        childrenCache.set(nodes, levels);
+    }
+    let level = levels.get(wall.parentId);
+    if (!level) {
+        const children = Object.values(nodes)
+            .filter((node) => node.parentId === wall.parentId)
+            .sort((a, b) => a.id.localeCompare(b.id));
+        level = {
+            walls: children.filter((n) => n.type === 'wall'),
+            slabs: children.filter((n) => n.type === 'slab'),
+        };
+        levels.set(wall.parentId, level);
+    }
+    const ground = levelBaseElevationAt(nodes, wall.parentId, wall.start[0], wall.start[1]);
+    const result = computeWallSlabSupport(wall, level.slabs, level.walls, wall.supportSlabId, undefined, ground, nodes);
+    cached.set(wall, result);
+    return result;
+}
+export function supportSegmentAt(segment, t) {
+    return (segment.elevation +
+        ((t - segment.start) / (segment.end - segment.start)) *
+            ((segment.endElevation ?? segment.elevation) - segment.elevation));
+}
+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 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)] : [];
+    });
+    return heights.length ? Math.max(...heights) : support.elevation;
+}
+/** Unclamped floor intent, used by authoring feasibility and legacy migration. */
+export function getOpeningFloorTarget(wall, opening, nodes) {
+    return openingDatumFromSupport(wall, opening, wallSupportForNodes(wall, 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;
+}
+export function getOpeningFloorDatum(wall, opening, nodes, support = wallSupportForNodes(wall, nodes)) {
+    const target = openingDatumFromSupport(wall, opening, support);
+    if (target === support.elevation)
+        return target;
+    return openingFitsAtDatum(wall, opening, target, nodes, support) ? target : support.elevation;
+}
+const cutPlans = new WeakMap();
+export function getOpeningWallCut(wall, opening, nodes, support = wallSupportForNodes(wall, nodes)) {
+    let levels = cutPlans.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        cutPlans.set(nodes, levels);
+    }
+    let plan = levels.get(wall.parentId);
+    if (!plan) {
+        const walls = Object.values(nodes).filter((n) => n.type === 'wall' && n.parentId === wall.parentId);
+        if (!walls.some((w) => w.id === wall.id))
+            walls.push(wall);
+        const miters = calculateLevelMiters(walls);
+        const footprints = new Map(walls.map((w) => [
+            w.id,
+            getWallPlanFootprint(w, miters).map(({ x, y }) => [x, y]),
+        ]));
+        plan = { footprints, covers: new Map() };
+        levels.set(wall.parentId, plan);
+    }
+    const { footprints, covers } = plan;
+    const aperture = openingAperture(wall, opening, footprints);
+    const datum = getOpeningFloorDatum(wall, opening, nodes, support);
+    const cover = covers.get(datum) ??
+        union(Object.values(nodes).flatMap((n) => n.type === 'slab' &&
+            n.parentId === wall.parentId &&
+            n.support !== 'open' &&
+            Math.abs(n.elevation - datum) < 0.001 - 1e-9
+            ? [{ outer: n.polygon, holes: n.holes }]
+            : []));
+    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 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));
+    const bottom = isFloorAnchoredOpening(opening) && covered
+        ? Math.min(support.elevation, ...bottoms)
+        : datum + opening.position[1] - opening.height / 2;
+    return {
+        // The floor the doorway exposes: exactly the wall's own footprint.
+        aperture,
+        // What the wall body loses: the same span, overshooting both faces.
+        band: wallOpeningBand(wall, Math.max(0, from), Math.min(1, to)),
+        datum,
+        bottom,
+        top: datum + opening.position[1] + opening.height / 2,
+        covered,
+    };
+}
+export function getOpeningWallPlacement(wall, opening, nodes) {
+    if (opening.metadata?.curvedWindowMaster || getWallCurveLength(wall) < 1e-6)
+        return { position: opening.position, rotation: opening.rotation };
+    const frame = getWallCurveFrameAt(wall, opening.position[0] / getWallCurveLength(wall));
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]), cos = Math.cos(angle), sin = Math.sin(angle);
+    const offset = getWallBodyCenterOffset(wall) + opening.position[2];
+    const dx = frame.point.x + frame.normal.x * offset - wall.start[0], dz = frame.point.y + frame.normal.y * offset - wall.start[1];
+    return {
+        position: [
+            dx * cos + dz * sin,
+            opening.position[1] +
+                getOpeningFloorDatum(wall, opening, nodes) -
+                wallSupportForNodes(wall, nodes).elevation,
+            -dx * sin + dz * cos,
+        ],
+        rotation: [
+            opening.rotation[0],
+            opening.rotation[1] + angle - Math.atan2(frame.tangent.y, frame.tangent.x),
+            opening.rotation[2],
+        ],
+    };
+}

package/dist/lib/own-floor-intent.d.ts

@@ -0,0 +1,15 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+type Update = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+export declare function ownFloorIntentChanges(nodes: Readonly<Record<string, AnyNode>>, updates: readonly Update[]): {
+    updates: Update[];
+    conflicts: {
+        code: string;
+        nodeIds: string[];
+        message: string;
+    }[];
+};
+export {};
+//# sourceMappingURL=own-floor-intent.d.ts.map

package/dist/lib/own-floor-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"own-floor-intent.d.ts","sourceRoot":"","sources":["../../src/lib/own-floor-intent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAsB,MAAM,WAAW,CAAA;AAavE,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAEvD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE;aAKT,MAAM,EAAE;;;;;;EA+N1B"}

package/dist/lib/own-floor-intent.js

@@ -0,0 +1,201 @@
+import { boundaries, diffStructure, roomFace } from '../commands/structure/shared.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { getLevelElevations, getWallTop } from '../services/storey.js';
+import { MIN_WALL_HEIGHT } from '../systems/wall/wall-top.js';
+import { reconcileStructureWithStableIds } from '../utils/structure-id.js';
+import { mintFloorFootprintKey } from './floor-footprint-key.js';
+import { floorPlateHoldsUnderside } from './floor-foundation-datum.js';
+import { floorIntentConflicts } from './floor-intent-changes.js';
+import { isFloorAnchoredOpening } from './floor-opening-footprints.js';
+import { floorRoomFaces } from './floor-room-faces.js';
+import { getOpeningFloorDatum, wallSupportForNodes } from './opening-floor-datum.js';
+import { getRoomBaseElevation, roundFloorElevation } from './room-floor-feasibility.js';
+export function ownFloorIntentChanges(nodes, updates) {
+    const result = [];
+    let changed = false;
+    const refuse = (id, detail) => ({
+        updates: [],
+        conflicts: [
+            { code: 'room-floor-footprint', nodeIds: [id], message: `Level the floors first. ${detail}` },
+        ],
+    });
+    for (const update of updates) {
+        const zone = nodes[update.id];
+        const data = update.data;
+        if (zone?.type !== 'zone' ||
+            !Object.hasOwn(data, 'floor') ||
+            (!zone.floor?.footprint && !data.floor?.footprint)) {
+            result.push(update);
+            continue;
+        }
+        const floor = { ...data.floor };
+        const mint = floor.footprint === 'new';
+        if (mint)
+            floor.footprint = mintFloorFootprintKey(zone.id);
+        const key = floor.footprint;
+        if (key === zone.floor?.footprint) {
+            if (key && floor.elevation !== zone.floor?.elevation) {
+                const conflicts = floorIntentConflicts(nodes, [update]);
+                if (conflicts.length)
+                    return { updates: [], conflicts };
+            }
+            result.push(update);
+            continue;
+        }
+        if (zone.spaceRole !== 'room' ||
+            zone.floor?.support === 'open' ||
+            zone.floor?.sourceSlabId ||
+            zone.hasFloor === false)
+            return refuse(zone.id, 'Only a grounded room with a generated floor can change its footprint.');
+        const faces = floorRoomFaces(boundaries(nodes, zone.parentId));
+        const face = roomFace(nodes, zone, faces);
+        const neighbours = Object.values(nodes).filter((node) => node.type === 'zone' &&
+            node.spaceRole === 'room' &&
+            node.id !== zone.id &&
+            node.parentId === zone.parentId &&
+            node.floor?.support !== 'open' &&
+            node.hasFloor !== false &&
+            !!roomFace(nodes, node, faces)?.spans.some((other) => face?.spans.some((span) => span.boundaryId === other.boundaryId &&
+                span.face !== other.face &&
+                Math.min(span.t1, other.t1) - Math.max(span.t0, other.t0) > 1e-6)));
+        const base = Object.values(nodes).find((node) => node.type === 'slab' && node.plateRole === 'base' && !!node.zoneIds?.includes(zone.id));
+        if (!base)
+            return refuse(zone.id, 'This room has no single base plate to convert.');
+        const top = roundFloorElevation(zone.floor?.elevation ?? getRoomBaseElevation(nodes, zone.id));
+        if (mint &&
+            floorPlateHoldsUnderside(nodes, base) &&
+            base.thickness + top - base.elevation < 0.02 - 1e-9)
+            return refuse(zone.id, 'The floor must retain at least 0.02 m above its soffit.');
+        // Room intent stores the level-local walking top, preserving its world height
+        // when the destination base is at a different height.
+        floor.elevation = top;
+        if (!key &&
+            !base.zoneIds?.some((id) => id !== zone.id &&
+                nodes[id]?.type === 'zone' &&
+                nodes[id].floor?.footprint === zone.floor?.footprint)) {
+            const target = Object.values(nodes)
+                .filter((node) => node.type === 'slab' &&
+                node.plateRole === 'base' &&
+                node.id !== base.id &&
+                !!node.zoneIds?.some((id) => neighbours.some((room) => room.id === id && !room.floor?.footprint)))
+                .sort((a, b) => a.id.localeCompare(b.id))[0];
+            if (target)
+                result.push({
+                    id: base.id,
+                    data: {
+                        floorHeight: target.floorHeight ?? target.elevation,
+                        referenceFloorElevation: target.referenceFloorElevation,
+                        thickness: target.thickness,
+                        foundation: target.foundation,
+                        slots: target.slots,
+                    },
+                });
+        }
+        result.push({ ...update, data: { ...data, floor } });
+        changed = true;
+    }
+    if (!changed)
+        return { updates: result, conflicts: [] };
+    const draft = { ...nodes };
+    for (const { id, data } of result)
+        draft[id] = { ...draft[id], ...data };
+    let next = reconcileStructureWithStableIds({ nodes: draft }).nodes;
+    const beforeLevels = getLevelElevations(nodes);
+    const afterLevels = getLevelElevations(next);
+    for (const [id, level] of beforeLevels)
+        if (Math.abs(level.baseY - (afterLevels.get(id)?.baseY ?? level.baseY)) > 1e-6)
+            return refuse(id, 'Changing the footprint would move another storey.');
+    const wallUpdates = [];
+    for (const old of Object.values(nodes)) {
+        const current = next[old.id];
+        if (old.type !== 'wall' || current?.type !== 'wall' || !old.parentId)
+            continue;
+        const oldTop = getWallTop(old, old.parentId, nodes, wallSupportForNodes(old, nodes).elevation);
+        const support = wallSupportForNodes(current, next).elevation;
+        const newTop = getWallTop(current, current.parentId, next, support);
+        if (Math.abs(oldTop - newTop) <= 1e-6)
+            continue;
+        if (oldTop - support < MIN_WALL_HEIGHT)
+            return refuse(old.id, `The preserved wall top would leave less than ${MIN_WALL_HEIGHT} m of wall.`);
+        wallUpdates.push({ id: old.id, data: { height: roundFloorElevation(oldTop - support) } });
+    }
+    if (wallUpdates.length) {
+        result.push(...wallUpdates);
+        for (const { id, data } of wallUpdates)
+            draft[id] = { ...draft[id], ...data };
+        next = reconcileStructureWithStableIds({ nodes: draft }).nodes;
+    }
+    const ceilingUpdates = [];
+    for (const old of Object.values(nodes)) {
+        const current = next[old.id];
+        if (old.type !== 'ceiling' || current?.type !== 'ceiling')
+            continue;
+        const height = resolveCeilingHeight(old, nodes);
+        if (Math.abs(height - resolveCeilingHeight(current, next)) > 1e-6)
+            ceilingUpdates.push({
+                id: old.id,
+                data: { height, metadata: { ...old.metadata, floorReassignmentHeight: true } },
+            });
+    }
+    if (ceilingUpdates.length) {
+        result.push(...ceilingUpdates);
+        for (const { id, data } of ceilingUpdates)
+            draft[id] = { ...draft[id], ...data };
+        next = reconcileStructureWithStableIds({ nodes: draft }).nodes;
+        for (const { id, data } of ceilingUpdates) {
+            const ceiling = next[id];
+            if (ceiling?.type !== 'ceiling' ||
+                Math.abs(resolveCeilingHeight(ceiling, next) - data.height) > 1e-6)
+                return refuse(id, 'Changing the footprint cannot preserve the ceiling beneath the covering floor.');
+        }
+    }
+    const openingUpdates = [];
+    for (const old of Object.values(nodes)) {
+        const current = next[old.id];
+        if ((old.type !== 'door' && old.type !== 'window') ||
+            (current?.type !== 'door' && current?.type !== 'window'))
+            continue;
+        const oldWall = nodes[old.parentId], newWall = next[current.parentId];
+        if (oldWall?.type !== 'wall' || newWall?.type !== 'wall')
+            continue;
+        const delta = getOpeningFloorDatum(oldWall, old, nodes) +
+            old.position[1] -
+            getOpeningFloorDatum(newWall, current, next) -
+            current.position[1];
+        if (Math.abs(delta) <= 1e-6)
+            continue;
+        openingUpdates.push({
+            id: old.id,
+            data: {
+                position: [current.position[0], current.position[1] + delta, current.position[2]],
+                // Keep the anchoring rule when compensation crosses the implicit sill threshold.
+                verticalAnchor: isFloorAnchoredOpening(old) ? 'floor' : 'wall',
+            },
+        });
+    }
+    if (openingUpdates.length) {
+        result.push(...openingUpdates);
+        for (const { id, data } of openingUpdates)
+            draft[id] = { ...draft[id], ...data };
+        next = reconcileStructureWithStableIds({ nodes: draft }).nodes;
+    }
+    for (const old of Object.values(nodes)) {
+        const current = next[old.id];
+        if ((old.type !== 'door' && old.type !== 'window') ||
+            (current?.type !== 'door' && current?.type !== 'window'))
+            continue;
+        const oldWall = nodes[old.parentId], newWall = next[current.parentId];
+        if (oldWall?.type !== 'wall' || newWall?.type !== 'wall')
+            continue;
+        if (Math.abs(getOpeningFloorDatum(oldWall, old, nodes) +
+            old.position[1] -
+            getOpeningFloorDatum(newWall, current, next) -
+            current.position[1]) > 1e-6)
+            return refuse(old.id, 'Changing the footprint would move a door or window.');
+    }
+    const diff = diffStructure(nodes, next);
+    const conflicts = floorIntentConflicts(nodes, diff.flatMap((patch) => (patch.op === 'update' ? [{ id: patch.id, data: patch.data }] : [])), diff.flatMap((patch) => (patch.op === 'create' ? [patch.node] : [])), diff.flatMap((patch) => (patch.op === 'delete' ? [patch.id] : [])));
+    if (conflicts.length)
+        return refuse(result[0].id, conflicts.map((c) => c.message).join(' '));
+    return { updates: result, conflicts: [] };
+}

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

@@ -0,0 +1,3 @@
+import type { AnyNode, SlabNode } from '../schema/index.js';
+export declare function replacementPlateFor(node: AnyNode, field: 'supportSlabId' | 'deckSlabId', plates: readonly SlabNode[], nodes: Readonly<Record<string, AnyNode>>): string | undefined;
+//# sourceMappingURL=plate-reference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plate-reference.d.ts","sourceRoot":"","sources":["../../src/lib/plate-reference.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAelD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,eAAe,GAAG,YAAY,EACrC,MAAM,EAAE,SAAS,QAAQ,EAAE,EAC3B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,GAAG,SAAS,CA4GpB"}

package/dist/lib/plate-reference.js

@@ -0,0 +1,91 @@
+import { proceduralFootprint } from '../procedural-items/query.js';
+import { getFenceCenterlineFrameAt } from '../systems/fence/fence-centerline.js';
+import { getStairFloorPlacedFootprints } from '../systems/stair/stair-floor-footprints.js';
+import { stairArrivalOpening } from '../systems/stair/stair-footprint.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { planFootprintCorners } from './plan-footprint.js';
+import { area, containsPoint, intersection, union, } from './polygon-boolean.js';
+export function replacementPlateFor(node, field, plates, nodes) {
+    let footprint = [];
+    let point;
+    if (field === 'deckSlabId' && node.type === 'stair') {
+        if (!node.position || !node.children)
+            return undefined;
+        const arrival = stairArrivalOpening(node, nodes);
+        if (arrival.length)
+            point = [
+                arrival.reduce((s, p) => s + p[0], 0) / arrival.length,
+                arrival.reduce((s, p) => s + p[1], 0) / arrival.length,
+            ];
+    }
+    else if (node.type === 'item') {
+        footprint = planFootprintCorners(node.position, node.asset.dimensions.map((v, i) => v * node.scale[i]), node.rotation[1]);
+    }
+    else if (node.type === 'procedural-item') {
+        const box = proceduralFootprint(node);
+        footprint = planFootprintCorners(box.position, box.dimensions, box.rotation[1]);
+    }
+    else if (node.type === 'stair') {
+        footprint = union(getStairFloorPlacedFootprints(node, nodes).map((box) => planFootprintCorners(box.position ?? node.position, box.dimensions, box.rotation[1])));
+    }
+    else if (node.type === 'block') {
+        const positions = node.topology.vertices.map((vertex) => vertex.position);
+        if (positions.length) {
+            const minX = Math.min(...positions.map((p) => p[0])), maxX = Math.max(...positions.map((p) => p[0]));
+            const minZ = Math.min(...positions.map((p) => p[2])), maxZ = Math.max(...positions.map((p) => p[2]));
+            const x = (minX + maxX) / 2, z = (minZ + maxZ) / 2;
+            footprint = planFootprintCorners([
+                node.position[0] + x * Math.cos(node.rotation) + z * Math.sin(node.rotation),
+                node.position[1],
+                node.position[2] - x * Math.sin(node.rotation) + z * Math.cos(node.rotation),
+            ], [maxX - minX, 0, maxZ - minZ], node.rotation);
+        }
+    }
+    else if (node.type === 'fence') {
+        const sides = [1, -1].map((sign) => Array.from({ length: 97 }, (_, i) => {
+            const frame = getFenceCenterlineFrameAt(node, i / 96);
+            return [
+                frame.point.x + (sign * frame.normal.x * node.thickness) / 2,
+                frame.point.y + (sign * frame.normal.y * node.thickness) / 2,
+            ];
+        }));
+        footprint = [...sides[0], ...sides[1].reverse()];
+    }
+    else if (node.type === 'wall') {
+        const walls = Object.values(nodes).filter((candidate) => candidate.type === 'wall' && candidate.parentId === node.parentId);
+        footprint = getWallPlanFootprint(node, calculateLevelMiters(walls)).map((point) => [point.x, point.y]);
+    }
+    else if ('polygon' in node && Array.isArray(node.polygon))
+        footprint = node.polygon;
+    else if ('position' in node && Array.isArray(node.position)) {
+        const rotation = 'rotation' in node ? (Array.isArray(node.rotation) ? node.rotation[1] : node.rotation) : 0;
+        if ('width' in node &&
+            'depth' in node &&
+            typeof node.width === 'number' &&
+            typeof node.depth === 'number')
+            footprint = planFootprintCorners(node.position, [node.width, 0, node.depth], typeof rotation === 'number' ? rotation : 0);
+        else
+            point = [node.position[0], node.position[2]];
+    }
+    return plates
+        .filter((plate) => plate.parentId ===
+        (field === 'deckSlabId' && 'deckSlabId' in node
+            ? (nodes[node.deckSlabId ?? '']?.parentId ?? node.parentId)
+            : node.parentId) &&
+        (node.type !== 'wall' ||
+            (plate.support !== 'open' &&
+                plate.plateRole !== 'platform' &&
+                plate.plateRole !== 'sunken')))
+        .map((plate) => ({
+        plate,
+        overlap: point
+            ? Number(containsPoint([{ outer: plate.polygon, holes: plate.holes }], point))
+            : footprint.length
+                ? area(intersection(footprint, { outer: plate.polygon, holes: plate.holes }))
+                : 0,
+    }))
+        .filter((p) => p.overlap > 0)
+        .sort((a, b) => b.plate.elevation - a.plate.elevation ||
+        b.overlap - a.overlap ||
+        a.plate.id.localeCompare(b.plate.id))[0]?.plate.id;
+}

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

@@ -0,0 +1,120 @@
+import type { AnyNode, AnyNodeId, DoorNode, SlabNode, WallNode, WindowNode, ZoneNode } from '../schema/index.js';
+import { type MultiPolygon } from './polygon-boolean.js';
+/**
+ * Who draws the walking surface of a floor plate, and what the plate's vertical
+ * faces are.
+ *
+ * A plate (`slab.boundary === 'auto'`) spans every room it carries plus the
+ * wall footprints between them, so one mesh cannot hold one finish: the top is
+ * partitioned into cells by the polygon kernel and each cell draws its own
+ * resolved material. Priority, highest first:
+ *
+ *   1. a manual slab top at the same height  → masked out of the plate entirely
+ *   2. the zone's `floor.regions`            → later entries win
+ *   3. the zone's `floor.finish`             → inside the zone CLEAR polygon
+ *   4. the plate's own `surface` slot        → under walls and unfinished rooms
+ *
+ * The side faces are classified per exposed interval: `edge` where the face
+ * looks at the exterior, `riser` where it looks at a lower plate or the open
+ * air of a sub-zone step. Wall-covered steps are hidden except under doors;
+ * facade edges still show the slab thickness.
+ *
+ * Everything here is pure 2D and memoised per plate per topology/finish
+ * revision — `computePlateSurfacePartition` is the only entry point a renderer
+ * needs and never runs per frame.
+ */
+/** A zone floor finish: a `MaterialRef` string, or an inline legacy material. */
+export type PlateFinish = string | Record<string, unknown>;
+export type PlateTopCell = {
+    /** Paint role for a hit on this cell — a slab slot id or a `room:` route. */
+    role: string;
+    /** Finish drawing the cell; absent = the plate's own `surface` slot. */
+    finish?: PlateFinish;
+    /** Equal keys ⇒ one shared material instance, so batches never fragment. */
+    materialKey: string;
+    polygons: MultiPolygon;
+};
+export type PlateSideRole = 'edge' | 'riser' | 'hidden';
+export type PlateSideInterval = {
+    start: [number, number];
+    end: [number, number];
+    role: PlateSideRole;
+    /** Lower neighbouring plate top, in level-local metres. */
+    dropTo?: number;
+    zoneId?: string;
+    /**
+     * The doorway a room-owned riser steps through (`lib/floor-step-finish`):
+     * the door it sits under, else the lower room it looks at.
+     */
+    stepKey?: string;
+    bottom?: number;
+    top?: number;
+};
+export type PlateSurfacePartition = {
+    /** Disjoint, together covering the plate top minus `masked`. */
+    cells: PlateTopCell[];
+    /** Plate top covered by a manual surface or solid platform. */
+    masked: MultiPolygon;
+    sides: PlateSideInterval[];
+    /** True when the top is one plain `surface` cell — renderers skip the clip. */
+    plainTop: boolean;
+};
+export type PlateLevelContext = {
+    walls: WallNode[];
+    zones: ZoneNode[];
+    slabs: SlabNode[];
+    openings?: (DoorNode | WindowNode)[];
+    platform?: boolean;
+    nodes?: Readonly<Record<string, AnyNode>>;
+};
+export declare function isFloorPlate(slab: Pick<SlabNode, 'boundary'>): boolean;
+/** `room:<zoneId>` paints the room's floor finish; `/regionId` paints one region. */
+export declare function roomFinishRole(zoneId: string, regionId?: string): string;
+export declare function parseRoomFinishRole(role: string): {
+    zoneId: string;
+    regionId: string | null;
+} | null;
+/** Stable identity of a finish, so two rooms painted alike share one material. */
+export declare function plateFinishKey(finish: PlateFinish | undefined): string;
+/** Level neighbourhood a plate partition reads — walls, zones and sibling slabs. */
+export declare function plateLevelContext(parent: AnyNode | null, resolve: (id: AnyNodeId) => AnyNode | undefined): PlateLevelContext;
+/**
+ * Everything the partition of ONE plate depends on. Written into the geometry
+ * builder's memo and into the slab dependency tracker, so a finish edit rebuilds
+ * exactly the plates that show it and nothing else re-clips.
+ */
+export declare function platePartitionSignature(plate: SlabNode, context: PlateLevelContext): string;
+/** Joined plan footprints of every wall on the level — the "under a wall" mask. */
+export declare function levelWallCover(walls: readonly WallNode[]): MultiPolygon;
+export declare function plateOpeningLandings(context: PlateLevelContext): import("./floor-opening-footprints.js").OpeningLanding[];
+/**
+ * The plate's top cells and side classification, memoised on
+ * `platePartitionSignature`. Returns `null` for anything that is not an
+ * unrecessed floor plate — manual slabs and pools keep the plain two-slot path.
+ */
+export declare function computePlateSurfacePartition(plate: SlabNode, context: PlateLevelContext): PlateSurfacePartition | null;
+/**
+ * The doorway keys of every step `zoneId` owns on its level — what the room
+ * scope of a step paints. Reads the same memoised partitions the renderer does.
+ */
+export declare function floorStepKeysOf(nodes: Readonly<Record<string, AnyNode>>, levelId: string, zoneId: string): string[];
+/** Test seam — drops every memo so a test can assert a rebuild is deterministic. */
+export declare function clearPlateSurfaceCaches(): void;
+/**
+ * Role of a plate side face at a point on the plate outline.
+ */
+export declare function classifyPlateSideAt(partition: PlateSurfacePartition, point: readonly [number, number], tolerance?: number): PlateSideRole;
+/**
+ * Where the classification changes along one plate outline segment, as
+ * parameters in `[0, 1]` of that segment. A side quad is cut at these stations
+ * so a single edge can be exterior for part of its length and a step for the
+ * rest.
+ */
+export declare function plateSideRuns(partition: PlateSurfacePartition, start: readonly [number, number], end: readonly [number, number]): Array<{
+    t0: number;
+    t1: number;
+    role: PlateSideRole;
+    dropTo?: number;
+    zoneId?: string;
+}>;
+//# sourceMappingURL=plate-surface.d.ts.map

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

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