@pascal-app/core 1.0.1 → 1.0.4

package/dist/systems/wall/wall-operations.js

@@ -0,0 +1,146 @@
+import { getWallCurveFrameAt, getWallCurveLength } from './wall-curve.js';
+import { planWallInsertion, planWallSplitAtPoint, uncoveredWallSegments, } from './wall-topology.js';
+export function wallRectangleCorners(a, b) {
+    if (![...a, ...b].every(Number.isFinite) ||
+        Math.abs(a[0] - b[0]) < 0.05 ||
+        Math.abs(a[1] - b[1]) < 0.05)
+        return [];
+    const x = Math.min(a[0], b[0]);
+    const z = Math.min(a[1], b[1]);
+    const right = Math.max(a[0], b[0]);
+    const top = Math.max(a[1], b[1]);
+    return [
+        [x, z],
+        [right, z],
+        [right, top],
+        [x, top],
+    ];
+}
+/** Plan against a scratch graph so four sides commit atomically, including junction splits. */
+export function planWallRectangle(nodes, args) {
+    if (nodes[args.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    const corners = wallRectangleCorners(args.start, args.end);
+    if (!corners.length)
+        throw Error('Both rectangle dimensions must be at least 5 cm.');
+    const virtual = { ...nodes };
+    const added = new Set();
+    for (let i = 0; i < 4; i++) {
+        // A side that runs along existing walls only adds what they don't cover,
+        // so snapping to a wall and dragging past its end reuses it rather than
+        // doubling it.
+        const levelWalls = Object.values(virtual).filter((node) => node.type === 'wall' && node.parentId === args.levelId);
+        for (const [start, end] of uncoveredWallSegments(corners[i], corners[(i + 1) % 4], levelWalls)) {
+            const result = planWallInsertion(virtual, { ...args, start, end, joinRadius: 0 });
+            if (!result.ok)
+                throw Error('The rectangle cannot be drawn here.');
+            for (const id of result.plan.changes.delete)
+                delete virtual[id];
+            for (const { node, parentId } of result.plan.changes.create) {
+                virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) };
+            }
+            for (const wall of result.plan.insertedWalls)
+                added.add(wall.id);
+            for (const { id, data } of result.plan.changes.update) {
+                if (virtual[id])
+                    virtual[id] = { ...virtual[id], ...data };
+            }
+        }
+    }
+    const created = Object.values(virtual).filter((n) => !nodes[n.id]);
+    return {
+        changes: {
+            create: created.map((node) => ({ node, parentId: node.parentId })),
+            update: Object.values(virtual)
+                .filter((n) => nodes[n.id] && n !== nodes[n.id])
+                .map((n) => ({ id: n.id, data: n })),
+            delete: Object.keys(nodes).filter((id) => !virtual[id]),
+        },
+        walls: created.filter((n) => n.type === 'wall' && added.has(n.id)),
+    };
+}
+/** Explicit split keeps the first wall's identity and reuses the junction planner's host migration. */
+export function planWallDivision(nodes, wallId, distance, mintId) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall' || !wall.parentId)
+        throw Error('Select a wall.');
+    const length = getWallCurveLength(wall);
+    if (!Number.isFinite(distance) || distance < 0.05 || distance > length - 0.05)
+        throw Error('Keep at least 5 cm on each side of the split.');
+    const point = getWallCurveFrameAt(wall, distance / length).point;
+    const result = planWallSplitAtPoint(nodes, {
+        levelId: wall.parentId,
+        point: [point.x, point.y],
+        radius: 0.001,
+        mintId,
+        ignoreWallIds: Object.values(nodes)
+            .filter((n) => n.type === 'wall' && n.id !== wallId)
+            .map((n) => n.id),
+    });
+    if (!result.ok || result.plan.changes.create.length !== 2)
+        throw Error('Move the split away from doors, windows and mounted objects.');
+    const [first, second] = result.plan.changes.create;
+    const firstId = first.node.id;
+    const changes = {
+        create: [second],
+        delete: [],
+        update: [
+            {
+                id: wallId,
+                data: { ...first.node, id: wallId, parentId: wall.parentId },
+            },
+            ...result.plan.changes.update.map((op) => ({
+                ...op,
+                data: {
+                    ...op.data,
+                    ...(op.data.parentId === firstId ? { parentId: wallId } : {}),
+                    ...('wallId' in op.data && op.data.wallId === firstId ? { wallId } : {}),
+                },
+            })),
+        ],
+    };
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'zone' &&
+            node.parentId === wall.parentId &&
+            node.boundaryWallIds?.includes(wallId)) {
+            changes.update.push({
+                id: node.id,
+                data: {
+                    boundaryWallIds: node.boundaryWallIds.flatMap((id) => id === wallId ? [wallId, second.node.id] : [id]),
+                },
+            });
+        }
+    }
+    return { changes, point: [point.x, point.y] };
+}
+/**
+ * Several cuts as one edit. Cutting farthest first keeps the first wall's
+ * identity at every step, so the nearer distances stay valid on it.
+ */
+export function planWallDivisions(nodes, wallId, distances) {
+    const virtual = { ...nodes };
+    const points = [];
+    for (const distance of [...distances].sort((a, b) => b - a)) {
+        const plan = planWallDivision(virtual, wallId, distance);
+        for (const { node, parentId } of plan.changes.create) {
+            virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) };
+        }
+        for (const { id, data } of plan.changes.update) {
+            if (virtual[id])
+                virtual[id] = { ...virtual[id], ...data };
+        }
+        points.push(plan.point);
+    }
+    return {
+        changes: {
+            create: Object.values(virtual)
+                .filter((n) => !nodes[n.id])
+                .map((node) => ({ node, parentId: node.parentId })),
+            update: Object.values(virtual)
+                .filter((n) => nodes[n.id] && n !== nodes[n.id])
+                .map((n) => ({ id: n.id, data: n })),
+            delete: [],
+        },
+        points: points.reverse(),
+    };
+}

package/dist/systems/wall/wall-paint-plan.d.ts

@@ -0,0 +1,30 @@
+import type { AnyNode } from '../../schema/index.js';
+import type { WallFace, WallNode } from '../../schema/nodes/wall.js';
+import { type WallPaintRole } from './wall-finish.js';
+/**
+ * What one wall paint click changes, as plain node updates — the commit writes
+ * it and the hover preview draws it, so the preview is the commit.
+ *
+ * Painting writes the one finish the role names: a region, a face inside a
+ * room (the room's override for that face), the room's wall finish (every face
+ * turned to the room takes it, so the room's overrides go), or a slot.
+ * Erasing clears everything that makes the surface look painted, on the side
+ * that faces the room and nothing across it:
+ *   - a face in a room: that room's override, the face's own paint and the
+ *     paint regions over the room's part of the face — and, when the room has
+ *     a wall finish, an override back to the face's own look;
+ *   - a room: its wall finish, every override, and on each face turned to it
+ *     the face's own paint and the regions over the room's part of the face.
+ */
+type Nodes = Readonly<Record<string, AnyNode | undefined>>;
+/** The zone whose part of `face` holds station `u` (m), if any. */
+export declare function wallZoneAt(wall: WallNode, face: WallFace, u: number, nodes: Nodes): string | null;
+/**
+ * The node updates one wall paint makes. `ref` is the finish written (a
+ * material ref); undefined erases. Returns only the nodes that change.
+ */
+export declare function planWallPaint(nodes: Nodes, wall: WallNode, role: WallPaintRole, ref: string | undefined): Record<string, AnyNode>;
+/** The walls whose look a plan changes: every wall it writes, and every wall of a room it writes. */
+export declare function plannedWallIds(nodes: Nodes, plan: Record<string, AnyNode>): string[];
+export {};
+//# sourceMappingURL=wall-paint-plan.d.ts.map

package/dist/systems/wall/wall-paint-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-paint-plan.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-paint-plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAkB,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEjF,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,eAAe,CAAA;AAEtB;;;;;;;;;;;;;;GAcG;AAEH,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;AA8B1D,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CASjG;AAyBD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA+FzB;AAED,qGAAqG;AACrG,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE,CAapF"}

package/dist/systems/wall/wall-paint-plan.js

@@ -0,0 +1,167 @@
+import { getWallLevelZones, getWallZoneSpans, resolveWallFaceChain, } from './wall-finish.js';
+function zoneNode(nodes, zoneId) {
+    const node = nodes[zoneId];
+    return node?.type === 'zone' ? node : null;
+}
+function wallLength(wall) {
+    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+}
+/** The part of each face of `wall` turned to `zone`, in metres along the wall. */
+function roomSpans(wall, zone) {
+    const length = wallLength(wall);
+    return getWallZoneSpans(wall, [zone]).map((span) => ({
+        wallId: wall.id,
+        face: span.face,
+        u0: span.t0 * length,
+        u1: span.t1 * length,
+    }));
+}
+function regionOverlaps(region, span, length) {
+    if (region.face !== span.face)
+        return false;
+    const low = Math.max(region.u0 ?? 0, span.u0);
+    const high = Math.min(region.u1 ?? length, span.u1);
+    return high - low > 1e-6;
+}
+/** The zone whose part of `face` holds station `u` (m), if any. */
+export function wallZoneAt(wall, face, u, nodes) {
+    const length = wallLength(wall);
+    if (length < 1e-9)
+        return null;
+    const t = u / length;
+    return (getWallZoneSpans(wall, getWallLevelZones(wall, nodes)).find((span) => span.face === face && t >= span.t0 - 1e-6 && t <= span.t1 + 1e-6)?.zoneId ?? null);
+}
+/** Clears a wall face's own paint and the regions over `spans` of it. */
+function clearFaces(wall, spans) {
+    const length = wallLength(wall);
+    const faces = new Set(spans.map((span) => span.face));
+    const regions = (wall.faceRegions ?? []).filter((region) => !spans.some((span) => regionOverlaps(region, span, length)));
+    const slots = { ...wall.slots };
+    for (const face of faces)
+        delete slots[face];
+    const next = { ...wall, slots };
+    if (regions.length)
+        next.faceRegions = regions;
+    else
+        delete next.faceRegions;
+    if (!Object.keys(slots).length)
+        delete next.slots;
+    return next;
+}
+function withOverrides(zone, overrides) {
+    const next = { ...zone };
+    if (overrides?.length)
+        next.wallOverrides = overrides;
+    else
+        delete next.wallOverrides;
+    return next;
+}
+/**
+ * The node updates one wall paint makes. `ref` is the finish written (a
+ * material ref); undefined erases. Returns only the nodes that change.
+ */
+export function planWallPaint(nodes, wall, role, ref) {
+    const out = {};
+    const current = (id) => (out[id] ?? nodes[id]);
+    if (role.kind === 'slot') {
+        const slotId = role.slotId;
+        const face = slotId === 'a' || slotId === 'b' ? slotId : null;
+        if (ref || !face) {
+            const slots = { ...wall.slots };
+            if (ref)
+                slots[slotId] = ref;
+            else
+                delete slots[slotId];
+            out[wall.id] = { ...wall, slots };
+            return out;
+        }
+        // Erasing a face no room owns: its own paint and every region on it.
+        out[wall.id] = clearFaces(wall, [
+            { wallId: wall.id, face, u0: Number.NEGATIVE_INFINITY, u1: Number.POSITIVE_INFINITY },
+        ]);
+        return out;
+    }
+    if (role.kind === 'region') {
+        const region = wall.faceRegions?.find((entry) => entry.id === role.regionId);
+        if (!region)
+            return out;
+        if (ref) {
+            out[wall.id] = {
+                ...wall,
+                faceRegions: wall.faceRegions.map((entry) => entry.id === region.id ? { ...entry, finish: ref } : entry),
+            };
+            return out;
+        }
+        // Erasing a painted part clears the face it sits on, inside its room.
+        const length = wallLength(wall);
+        const middle = ((region.u0 ?? 0) + (region.u1 ?? length)) / 2;
+        const zoneId = wallZoneAt(wall, region.face, middle, nodes);
+        return planWallPaint(nodes, wall, zoneId
+            ? { kind: 'room-face', zoneId, face: region.face }
+            : { kind: 'slot', slotId: region.face }, undefined);
+    }
+    const zone = zoneNode(nodes, role.zoneId);
+    if (!zone)
+        return out;
+    if (role.kind === 'room-face') {
+        const others = (zone.wallOverrides ?? []).filter((entry) => !(entry.wallId === wall.id && entry.face === role.face));
+        if (ref) {
+            out[zone.id] = withOverrides(zone, [
+                ...others,
+                { wallId: wall.id, face: role.face, finish: ref },
+            ]);
+            return out;
+        }
+        const spans = roomSpans(wall, zone).filter((span) => span.face === role.face);
+        const cleared = clearFaces(wall, spans);
+        out[wall.id] = cleared;
+        // The room's own finish would still show here: hold the face to its own look.
+        const chain = resolveWallFaceChain(cleared, role.face);
+        const own = chain.kind === 'legacy' ? null : chain.ref;
+        out[zone.id] = withOverrides(zone, zone.wallMaterial !== undefined && own
+            ? [...others, { wallId: wall.id, face: role.face, finish: own }]
+            : others);
+        return out;
+    }
+    // The room's walls: every face turned to the room takes the finish, so the
+    // room's per-face overrides give way (painted parts stay on top).
+    if (ref) {
+        out[zone.id] = withOverrides({ ...zone, wallMaterial: ref }, undefined);
+        return out;
+    }
+    const next = withOverrides({ ...zone }, undefined);
+    delete next.wallMaterial;
+    out[zone.id] = next;
+    const wallIds = new Set([wall.id, ...zone.boundaryWallIds]);
+    for (const id of wallIds) {
+        const target = current(id);
+        if (target?.type !== 'wall')
+            continue;
+        const spans = roomSpans(target, zone);
+        if (!spans.length)
+            continue;
+        const cleared = clearFaces(target, spans);
+        if (JSON.stringify(cleared) !== JSON.stringify(target))
+            out[target.id] = cleared;
+    }
+    return out;
+}
+/** The walls whose look a plan changes: every wall it writes, and every wall of a room it writes. */
+export function plannedWallIds(nodes, plan) {
+    const ids = new Set();
+    for (const node of Object.values(plan)) {
+        if (node.type === 'wall')
+            ids.add(node.id);
+        if (node.type === 'zone') {
+            for (const id of node.boundaryWallIds)
+                ids.add(id);
+            for (const entry of node.wallOverrides ?? [])
+                ids.add(entry.wallId);
+            const before = nodes[node.id];
+            if (before?.type === 'zone')
+                for (const entry of before.wallOverrides ?? [])
+                    ids.add(entry.wallId);
+        }
+    }
+    return [...ids];
+}

package/dist/systems/wall/wall-room-sides.d.ts

@@ -0,0 +1,6 @@
+import type { SceneNodes } from '../../lib/structure-kernel.js';
+export declare function roomSideFaces(nodes: SceneNodes, wallId: string): {
+    inside: 'a' | 'b' | null;
+    outside: 'a' | 'b' | null;
+};
+//# sourceMappingURL=wall-room-sides.d.ts.map

package/dist/systems/wall/wall-room-sides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-room-sides.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-room-sides.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AAE5D,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,GACb;IAAE,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IAAC,OAAO,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;CAAE,CAiBzD"}

package/dist/systems/wall/wall-room-sides.js

@@ -0,0 +1,14 @@
+import { extractRooms } from '../../lib/room-graph.js';
+export function roomSideFaces(nodes, wallId) {
+    const wall = nodes[wallId];
+    if (wall?.type !== 'wall')
+        throw Error('Select a wall.');
+    const boundaries = Object.values(nodes).filter((node) => node.parentId === wall.parentId && (node.type === 'wall' || node.type === 'separator'));
+    const sides = new Set(extractRooms(boundaries).flatMap((room) => room.spans
+        .filter((span) => span.boundaryId === wallId && span.t1 > span.t0)
+        .map((span) => span.face)));
+    if (sides.size !== 1)
+        return { inside: null, outside: null };
+    const inside = [...sides][0];
+    return { inside, outside: inside === 'a' ? 'b' : 'a' };
+}

package/dist/systems/wall/wall-step-openings.d.ts

@@ -0,0 +1,17 @@
+import type { WallNode } from '../../schema/index.js';
+import type { WallSlabSupportSegment } from '../slab/slab-support.js';
+export declare function wallDoorStepRuns(wall: WallNode, opening: {
+    type: string;
+    width?: number;
+    height?: number;
+    position?: [number, number, number];
+}, faceBase: {
+    a: readonly WallSlabSupportSegment[];
+    b: readonly WallSlabSupportSegment[];
+}, elevation: number): Array<{
+    start: number;
+    end: number;
+    bottom: number;
+    top: number;
+}>;
+//# sourceMappingURL=wall-step-openings.d.ts.map

package/dist/systems/wall/wall-step-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-step-openings.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-step-openings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAGlE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,EAC/F,QAAQ,EAAE;IAAE,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAAC,CAAC,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAE,EACxF,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAoCpE"}

package/dist/systems/wall/wall-step-openings.js

@@ -0,0 +1,32 @@
+import { getWallCurveFrameAt } from './wall-curve.js';
+export function wallDoorStepRuns(wall, opening, faceBase, elevation) {
+    if ((opening.type !== 'door' && opening.type !== 'window') || !opening.position)
+        return [];
+    const sill = opening.position[1] - (opening.height ?? 0) / 2;
+    if (sill > 0.01)
+        return [];
+    const dx = wall.end[0] - wall.start[0];
+    const dy = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 1e-9)
+        return [];
+    const station = (t) => {
+        const { point } = getWallCurveFrameAt(wall, t);
+        return ((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dy) / length;
+    };
+    const runs = [];
+    for (const a of faceBase.a)
+        for (const b of faceBase.b) {
+            const from = Math.max(a.start, b.start);
+            const to = Math.min(a.end, b.end);
+            const low = Math.min(a.elevation, a.endElevation ?? a.elevation, b.elevation, b.endElevation ?? b.elevation);
+            const high = Math.max(a.elevation, a.endElevation ?? a.elevation, b.elevation, b.endElevation ?? b.elevation);
+            if (to <= from || high - low < 1e-6)
+                continue;
+            const start = Math.max(station(from), opening.position[0] - (opening.width ?? 0) / 2);
+            const end = Math.min(station(to), opening.position[0] + (opening.width ?? 0) / 2);
+            if (end > start)
+                runs.push({ start, end, bottom: low - elevation, top: Math.max(sill, high - elevation) });
+        }
+    return runs;
+}

package/dist/systems/wall/wall-top.d.ts

@@ -12,12 +12,8 @@ export declare const MIN_WALL_HEIGHT = 0.5;
  * `height` is plane-bound — its top sits at the storey plane (level-local
  * Y = the level's stored height), so a slab lifting the wall's base makes
  * the wall shorter, never taller, and no gap can open at the top of a
- * level. A wall WITH `height` is an explicit exception (half wall,
- * parapet) and keeps the legacy semantics: the top rides a raised elected
- * base (`electedBase + height`), while a zero or sunken slab base leaves
- * the top at `height` (the legacy negative-slab constraint). Explicit
- * ground-hosted walls are the terrain exception: `height` is always body
- * height, including below datum, so sculpting cannot stretch the wall.
+ * level. Explicit walls stand on their elected support; room floor datums do not
+ * change their tops. Ground-hosted walls retain their authored body height.
  *
  * Returns the top in level-local Y (same frame as `electedBase`).
  */

package/dist/systems/wall/wall-top.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-top.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-top.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAElC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAIR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER"}
+{"version":3,"file":"wall-top.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-top.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAElC;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAGR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER"}

package/dist/systems/wall/wall-top.js

@@ -11,21 +11,15 @@ export const MIN_WALL_HEIGHT = 0.5;
  * `height` is plane-bound — its top sits at the storey plane (level-local
  * Y = the level's stored height), so a slab lifting the wall's base makes
  * the wall shorter, never taller, and no gap can open at the top of a
- * level. A wall WITH `height` is an explicit exception (half wall,
- * parapet) and keeps the legacy semantics: the top rides a raised elected
- * base (`electedBase + height`), while a zero or sunken slab base leaves
- * the top at `height` (the legacy negative-slab constraint). Explicit
- * ground-hosted walls are the terrain exception: `height` is always body
- * height, including below datum, so sculpting cannot stretch the wall.
+ * level. Explicit walls stand on their elected support; room floor datums do not
+ * change their tops. Ground-hosted walls retain their authored body height.
  *
  * Returns the top in level-local Y (same frame as `electedBase`).
  */
 export function resolveWallTop(wall, storeyHeight, electedBase) {
     if (wall.height == null)
         return storeyHeight;
-    if (wall.supportSlabId === 'ground')
-        return electedBase + wall.height;
-    return electedBase > 0 ? electedBase + wall.height : wall.height;
+    return electedBase + wall.height;
 }
 /**
  * Extruded height of the wall body: {@link resolveWallTop} minus the

package/dist/systems/wall/wall-topology.d.ts

@@ -1,5 +1,7 @@
+import { type OpenWallEnd } from '../../lib/room-graph.js';
 import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema/index.js';
 import type { WallPlanPoint } from './wall-move.js';
+export declare const WALL_MIN_LENGTH = 0.01;
 export type WallTopologyChanges = {
     create: Array<{
         node: AnyNode;
@@ -37,11 +39,26 @@ export type WallPointSplitResult = {
     ok: false;
     reason: 'no-host';
 };
+export type WallJoinResult = {
+    ok: true;
+    plan: WallInsertionPlan;
+} | {
+    ok: false;
+    reason: WallTopologyRejection['reason'] | 'stale-end' | 'no-target' | 'attachment-outside-wall' | 'attachment-straddles-junction';
+};
+/**
+ * The parts of `start→end` that no straight wall already runs along, in order.
+ * A side drawn along an existing wall and past its end yields the overhang
+ * only, so the existing wall is reused instead of doubled. Gaps too short to
+ * be a wall are treated as covered.
+ */
+export declare function uncoveredWallSegments(start: WallPlanPoint, end: WallPlanPoint, walls: WallNode[]): Array<[WallPlanPoint, WallPlanPoint]>;
 export declare function planWallSplitAtPoint(nodes: Record<AnyNodeId, AnyNode>, args: {
     levelId: AnyNodeId | null;
     point: WallPlanPoint;
     radius: number;
     ignoreWallIds?: readonly string[];
+    mintId?: () => string;
 }): WallPointSplitResult;
 export declare function planWallInsertion(nodes: Record<AnyNodeId, AnyNode>, args: {
     levelId: AnyNodeId;
@@ -49,5 +66,16 @@ export declare function planWallInsertion(nodes: Record<AnyNodeId, AnyNode>, arg
     end: WallPlanPoint;
     joinRadius: number;
     wallDefaults?: Partial<WallNode>;
+    mintId?: () => string;
 }): WallInsertionResult;
+/** Repair one reference endpoint, including host splits and opening rehosting, in one scene batch. */
+export declare function planJoinOpenWallEnd(nodes: Readonly<Record<string, AnyNode>>, openEnd: OpenWallEnd): WallJoinResult;
+/**
+ * The level's open wall ends, each candidate moved to where Join walls will put the end, so a
+ * preview draws the join it makes. `nodes` must hold what the walls host: an opening can turn
+ * a squared corner back into a straight join. Room detection (room-graph) stays planner-free.
+ */
+export declare function findOpenWallEnds(nodes: Readonly<Record<string, AnyNode>>, levelId: string): OpenWallEnd[];
+/** Fold drop-time connections into the move's atomic batch, including linked moved walls. */
+export declare function planWallEndRejoins(nodes: Readonly<Record<string, AnyNode>>, wallIds: readonly string[], radius: number, changes: WallTopologyChanges): WallTopologyChanges;
 //# sourceMappingURL=wall-topology.d.ts.map

package/dist/systems/wall/wall-topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-topology.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-topology.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,QAAQ,EAGd,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAMhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACtD,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,CAAA;IACxD,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC9B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,KAAK,CAAA;IACT,MAAM,EAAE,uBAAuB,GAAG,mBAAmB,CAAA;CACtD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAAG,qBAAqB,CAAA;AAE/F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,KAAK,EAAE,aAAa,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GACtC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AA8GpC,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC,GACA,oBAAoB,CAqCtB;AA4OD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjC,GACA,mBAAmB,CAiGrB"}
+{"version":3,"file":"wall-topology.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-topology.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,WAAW,EAAyB,MAAM,sBAAsB,CAAA;AAElG,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,QAAQ,EAGd,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhD,eAAO,MAAM,eAAe,OAAO,CAAA;AAQnC,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACtD,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,CAAA;IACxD,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC9B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,KAAK,CAAA;IACT,MAAM,EAAE,uBAAuB,GAAG,mBAAmB,CAAA;CACtD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAAG,qBAAqB,CAAA;AAE/F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,KAAK,EAAE,aAAa,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GACtC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAEpC,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GACrC;IACE,EAAE,EAAE,KAAK,CAAA;IACT,MAAM,EACF,qBAAqB,CAAC,QAAQ,CAAC,GAC/B,WAAW,GACX,WAAW,GACX,yBAAyB,GACzB,+BAA+B,CAAA;CACpC,CAAA;AAkEL;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,QAAQ,EAAE,GAChB,KAAK,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC,CAiBvC;AAwDD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAA;CACtB,GACA,oBAAoB,CAqCtB;AA8OD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;IAChC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAA;CACtB,GACA,mBAAmB,CAqHrB;AAySD,sGAAsG;AACtG,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,WAAW,GACnB,cAAc,CAmEhB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,WAAW,EAAE,CAQf;AAED,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,mBAAmB,GAC3B,mBAAmB,CAiDrB"}