@pascal-app/core 1.0.3 → 1.0.4

package/dist/lib/level-name.js

@@ -1,10 +1,18 @@
+/** What an unnamed level is called: Ground floor, Floor 1, Floor 2…, Basement, Basement 2… */
 export function getDefaultLevelName(level) {
     if (level === 0)
-        return 'Ground Floor';
+        return 'Ground floor';
     if (level > 0)
         return `Floor ${level}`;
-    return `Basement ${-level}`;
+    return level === -1 ? 'Basement' : `Basement ${-level}`;
 }
+/**
+ * The one way a level's name is shown. A name the user gave wins; a level
+ * without one — or still carrying the "Level N" an older build stamped on
+ * every new level — reads by its place in the building. Display only: the
+ * stored name is never rewritten.
+ */
 export function getLevelDisplayName(level) {
-    return level.name || getDefaultLevelName(level.level);
+    const name = level.name?.trim();
+    return name && name !== `Level ${level.level}` ? name : getDefaultLevelName(level.level);
 }

package/dist/lib/new-zone.d.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { ZoneNode } from '../schema/nodes/zone.js';
+/**
+ * A zone being created (never one being loaded): parsed, and given its
+ * creation colour (`zoneColorForSeed`) unless the creator chose one.
+ */
+export declare function newZone(input: Omit<z.input<typeof ZoneNode>, 'id'> & {
+    id?: string;
+}): ZoneNode;
+//# sourceMappingURL=new-zone.d.ts.map

package/dist/lib/new-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new-zone.d.ts","sourceRoot":"","sources":["../../src/lib/new-zone.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAG/C;;;GAGG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,QAAQ,CAG/F"}

package/dist/lib/new-zone.js

@@ -0,0 +1,10 @@
+import { ZoneNode } from '../schema/nodes/zone.js';
+import { zoneColorForSeed } from './zone-colors.js';
+/**
+ * A zone being created (never one being loaded): parsed, and given its
+ * creation colour (`zoneColorForSeed`) unless the creator chose one.
+ */
+export function newZone(input) {
+    const zone = ZoneNode.parse(input);
+    return input.color === undefined ? { ...zone, color: zoneColorForSeed(zone.id) } : zone;
+}

package/dist/lib/node-ancestry.d.ts

@@ -0,0 +1,30 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+export declare function resolveLevelId(node: AnyNode, nodes: Record<string, AnyNode>): string;
+/**
+ * Walks the parent chain of `nodeId` and returns the id of the first ancestor
+ * whose `type` is `'level'`, or `null` when no level ancestor exists (orphaned
+ * node, top-level building node, etc.). Unlike `resolveLevelId`, this variant:
+ *
+ * - accepts a node **id** rather than a resolved node, saving the caller a
+ *   `nodes[id]` lookup when only the id is at hand.
+ * - returns `null` instead of the `'default'` fallback, which lets callers
+ *   distinguish "genuinely has no level" from "is a level".
+ * - has a loop guard (16 iterations) so a corrupt parent-chain cycle cannot
+ *   hang the frame loop.
+ */
+export declare function findLevelAncestorId(nodeId: AnyNodeId, nodes: Record<string, AnyNode>): string | null;
+/**
+ * Returns the building id that contains the given level, or `null` if
+ * the level is unparented or no enclosing building exists.
+ *
+ * Most scenes record the relationship via `level.parentId →
+ * building.id`, but older serialisations occasionally drop `parentId`
+ * even though the building's `children` array still references the
+ * level. The fallback scan covers that case.
+ *
+ * Used by `FloorplanRegistryLayer` to discover building-scoped kinds
+ * (`def.floorplanScope === 'building'`) without hardcoding any kind
+ * name in the editor layer.
+ */
+export declare function resolveBuildingForLevel(levelId: AnyNodeId, nodes: Record<AnyNodeId, AnyNode>): AnyNodeId | null;
+//# sourceMappingURL=node-ancestry.d.ts.map

package/dist/lib/node-ancestry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-ancestry.d.ts","sourceRoot":"","sources":["../../src/lib/node-ancestry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,GAAG,IAAI,CASf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAgBlB"}

package/dist/lib/node-ancestry.js

@@ -0,0 +1,76 @@
+export function resolveLevelId(node, nodes) {
+    // If the node itself is a level
+    if (node.type === 'level')
+        return node.id;
+    // Walk up parent chain to find level
+    // This assumes you track parentId or can derive it
+    let current = node;
+    while (current) {
+        if (current.type === 'level')
+            return current.id;
+        // Find parent (you might need to add parentId to your schema or derive it)
+        if (current.parentId) {
+            current = nodes[current.parentId];
+        }
+        else {
+            current = undefined;
+        }
+    }
+    return 'default'; // fallback for orphaned items
+}
+/**
+ * Walks the parent chain of `nodeId` and returns the id of the first ancestor
+ * whose `type` is `'level'`, or `null` when no level ancestor exists (orphaned
+ * node, top-level building node, etc.). Unlike `resolveLevelId`, this variant:
+ *
+ * - accepts a node **id** rather than a resolved node, saving the caller a
+ *   `nodes[id]` lookup when only the id is at hand.
+ * - returns `null` instead of the `'default'` fallback, which lets callers
+ *   distinguish "genuinely has no level" from "is a level".
+ * - has a loop guard (16 iterations) so a corrupt parent-chain cycle cannot
+ *   hang the frame loop.
+ */
+export function findLevelAncestorId(nodeId, nodes) {
+    let current = nodes[nodeId];
+    let guard = 0;
+    while (current && guard < 16) {
+        if (current.type === 'level')
+            return current.id;
+        current = current.parentId ? nodes[current.parentId] : undefined;
+        guard += 1;
+    }
+    return null;
+}
+/**
+ * Returns the building id that contains the given level, or `null` if
+ * the level is unparented or no enclosing building exists.
+ *
+ * Most scenes record the relationship via `level.parentId →
+ * building.id`, but older serialisations occasionally drop `parentId`
+ * even though the building's `children` array still references the
+ * level. The fallback scan covers that case.
+ *
+ * Used by `FloorplanRegistryLayer` to discover building-scoped kinds
+ * (`def.floorplanScope === 'building'`) without hardcoding any kind
+ * name in the editor layer.
+ */
+export function resolveBuildingForLevel(levelId, nodes) {
+    const level = nodes[levelId];
+    if (!level)
+        return null;
+    const directParent = level.parentId ?? null;
+    if (directParent) {
+        const candidate = nodes[directParent];
+        if (candidate?.type === 'building')
+            return candidate.id;
+    }
+    for (const candidate of Object.values(nodes)) {
+        if (candidate?.type !== 'building')
+            continue;
+        const children = candidate.children;
+        if (Array.isArray(children) && children.includes(levelId)) {
+            return candidate.id;
+        }
+    }
+    return null;
+}

package/dist/lib/object-cuts.d.ts

@@ -0,0 +1,11 @@
+import type { GeometryContext } from '../registry/types.js';
+import type { AnyNode, CeilingNode, SlabNode } from '../schema/index.js';
+type Surface = CeilingNode | SlabNode;
+export declare function getEffectiveCutterNode(node: AnyNode): AnyNode;
+/** Only the host's neighbourhood is needed; pure builders need no scene store. */
+export declare function cutterContextNodes(surface: Surface, context: GeometryContext): Record<string, AnyNode>;
+/** Through-holes are derived, so moving/deleting/undoing the owner cannot leave stale openings. */
+export declare function hostedCutterHoles(surface: Surface, nodes: Readonly<Record<string, AnyNode>>): [number, number][][];
+export declare function withHostedCutterHoles<T extends Surface>(surface: T, nodes: Readonly<Record<string, AnyNode>>): T;
+export {};
+//# sourceMappingURL=object-cuts.d.ts.map

package/dist/lib/object-cuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-cuts.d.ts","sourceRoot":"","sources":["../../src/lib/object-cuts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAK/D,KAAK,OAAO,GAAG,WAAW,GAAG,QAAQ,CAAA;AAErC,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAa7D;AAED,kFAAkF;AAClF,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,eAAe,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB;AAED,mGAAmG;AACnG,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CA0BtB;AAED,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,EACrD,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,CAAC,CAGH"}

package/dist/lib/object-cuts.js

@@ -0,0 +1,63 @@
+import { getEffectiveNode } from '../store/use-live-node-overrides.js';
+import useLiveTransforms from '../store/use-live-transforms.js';
+import { resolveCutterHost } from './cutter-host.js';
+export function getEffectiveCutterNode(node) {
+    const effective = getEffectiveNode(node);
+    const live = useLiveTransforms.getState().get(node.id);
+    if (effective.type !== 'item' || !live)
+        return effective;
+    // Ceiling drags publish building-local Y; the mounting depth stays host-relative.
+    return {
+        ...effective,
+        position: effective.asset.attachTo === 'ceiling'
+            ? [live.position[0], effective.position[1], live.position[2]]
+            : live.position,
+        rotation: [effective.rotation[0], live.rotation, effective.rotation[2]],
+    };
+}
+/** Only the host's neighbourhood is needed; pure builders need no scene store. */
+export function cutterContextNodes(surface, context) {
+    const nodes = { [surface.id]: surface };
+    const parent = context.parent;
+    if (parent)
+        nodes[parent.id] = parent;
+    for (const id of [
+        ...(parent && 'children' in parent ? parent.children : []),
+        ...('children' in surface ? surface.children : []),
+    ]) {
+        const node = context.resolve(id);
+        if (node)
+            nodes[node.id] = getEffectiveCutterNode(node);
+    }
+    return nodes;
+}
+/** Through-holes are derived, so moving/deleting/undoing the owner cannot leave stale openings. */
+export function hostedCutterHoles(surface, nodes) {
+    const holes = [];
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'item' || !node.source?.manifest.cutters?.length)
+            continue;
+        for (const cutter of node.source.manifest.cutters) {
+            const name = cutter.host === 'mounted' ? 'cutout' : `cut:${cutter.host}`;
+            if (resolveCutterHost(node, name, nodes)?.id !== surface.id)
+                continue;
+            // Item Y is relative to its support: floor elevation is added by the viewer,
+            // while a ceiling child already lives in the ceiling's local frame.
+            const minY = node.position[1] + Math.min(cutter.minY * node.scale[1], cutter.maxY * node.scale[1]);
+            const maxY = node.position[1] + Math.max(cutter.minY * node.scale[1], cutter.maxY * node.scale[1]);
+            const bottom = surface.type === 'slab' ? -surface.thickness : 0;
+            if (minY > 1e-5 || maxY < bottom - 1e-5)
+                continue;
+            const cos = Math.cos(node.rotation[1]), sin = Math.sin(node.rotation[1]);
+            holes.push(cutter.polygon.map(([x, z]) => [
+                node.position[0] + x * node.scale[0] * cos + z * node.scale[2] * sin,
+                node.position[2] - x * node.scale[0] * sin + z * node.scale[2] * cos,
+            ]));
+        }
+    }
+    return holes;
+}
+export function withHostedCutterHoles(surface, nodes) {
+    const holes = hostedCutterHoles(surface, nodes);
+    return holes.length ? { ...surface, holes: [...surface.holes, ...holes] } : surface;
+}

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;AAsBrC,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,145 @@
+import { getWallPlaneTop } 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 { resolveWallTop } from '../systems/wall/wall-top.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 = resolveWallTop(wall, getWallPlaneTop(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;;;;;;EAuO1B"}

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, getWallPlaneTop } from '../services/storey.js';
+import { MIN_WALL_HEIGHT, resolveWallTop } 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 = resolveWallTop(old, getWallPlaneTop(old, old.parentId, nodes), wallSupportForNodes(old, nodes).elevation);
+        const support = wallSupportForNodes(current, next).elevation;
+        const newTop = resolveWallTop(current, getWallPlaneTop(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"}