@pascal-app/core 1.0.6 → 1.1.0

package/dist/commands/structure/move-separators.js

@@ -0,0 +1,346 @@
+import { WALL_JUNCTION_TOLERANCE } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { isCurvedWall } from '../../systems/wall/wall-curve.js';
+import { getPlannedLinkedWallUpdates, planAttachedWallUpdates, planWallMoveJunctions, } from '../../systems/wall/wall-move.js';
+import { WALL_MIN_LENGTH } from '../../systems/wall/wall-topology.js';
+import { at, conflict, diffStructure, } from './shared.js';
+/**
+ * How near invisible walls meet: ends this near are one corner and an end this near a line is on
+ * it, as far as the room graph joins them (`WALL_JUNCTION_TOLERANCE`). A move puts such ends
+ * exactly together, so a corner drawn a little open closes.
+ */
+export const SEPARATOR_JOIN_REACH = WALL_JUNCTION_TOLERANCE;
+const JOIN = SEPARATOR_JOIN_REACH;
+const SAME_POINT = 1e-6;
+const WHOLE = 1e-4;
+// Lines within about 1° of each other run alongside: one end can't slide along the other.
+const MIN_SINE = Math.sin(Math.PI / 180);
+// The shortest invisible wall a move may leave, as a wall's (`setWallGeometry`).
+const MIN_LENGTH = 0.05;
+const distance = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+const near = (a, b) => distance(a, b) <= JOIN;
+/** Where `point` sits along `line` (metres from its start) and how far off its line. */
+function station(point, line) {
+    const dx = line.end[0] - line.start[0];
+    const dz = line.end[1] - line.start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return { along: 0, across: distance(point, line.start), length };
+    return {
+        along: ((point[0] - line.start[0]) * dx + (point[1] - line.start[1]) * dz) / length,
+        across: Math.abs((point[1] - line.start[1]) * dx - (point[0] - line.start[0]) * dz) / length,
+        length,
+    };
+}
+/** Whether `point` is on the segment `line`, its ends included. */
+function onLine(point, line) {
+    const { along, across, length } = station(point, line);
+    return length > 1e-9 && across <= JOIN && along >= -JOIN && along <= length + JOIN;
+}
+/** Where the line through `moving` meets the segment `host`, if it does at a real angle. */
+function meetingOn(moving, host) {
+    const r = [moving.end[0] - moving.start[0], moving.end[1] - moving.start[1]];
+    const u = [host.end[0] - host.start[0], host.end[1] - host.start[1]];
+    const hostLength = Math.hypot(u[0], u[1]);
+    const denominator = r[0] * u[1] - r[1] * u[0];
+    if (Math.abs(denominator) <= MIN_SINE * Math.hypot(r[0], r[1]) * hostLength)
+        return null;
+    const qp = [host.start[0] - moving.start[0], host.start[1] - moving.start[1]];
+    const t = (qp[0] * r[1] - qp[1] * r[0]) / denominator;
+    if (t * hostLength < -JOIN || t * hostLength > hostLength + JOIN)
+        return null;
+    return [host.start[0] + u[0] * t, host.start[1] + u[1] * t];
+}
+/** `separator` with its ends at `point` (within the join reach) put exactly on it. */
+function ontoCorner(separator, point) {
+    const start = near(separator.start, point) ? point : separator.start;
+    const end = near(separator.end, point) ? point : separator.end;
+    return start === separator.start && end === separator.end
+        ? separator
+        : { ...separator, start, end };
+}
+/** `separator` with its ends on the body of `line` (clear of its ends) put exactly on it. */
+function ontoBody(separator, line) {
+    let next = separator;
+    for (const end of ['start', 'end']) {
+        const { along, across, length } = station(separator[end], line);
+        if (across > JOIN || along <= JOIN || along >= length - JOIN)
+            continue;
+        next = { ...next, [end]: at(line.start, line.end, along / length) };
+    }
+    return next;
+}
+const touches = (separator, line) => [separator.start, separator.end].some((p) => near(p, line.start) || near(p, line.end));
+/** How far `other` lies off the line through `from` along `move`: 0 when it runs with the move. */
+function offMove(from, move, other) {
+    const length = Math.hypot(move[0], move[1]);
+    if (length < SAME_POINT)
+        return Number.POSITIVE_INFINITY;
+    return Math.abs(move[0] * (other[1] - from[1]) - move[1] * (other[0] - from[0])) / length;
+}
+/**
+ * `separator` (joined at a corner of `line`) as the junction rules should read it: one running
+ * with its corner's move to within the join reach (a side drawn a little out of square, or put
+ * onto the corner by `ontoCorner`) reads as running exactly with it, so it stretches as a square
+ * corner's wall does instead of taking a jog.
+ */
+function squaredForMove(separator, line, next) {
+    let read = { id: separator.id, start: separator.start, end: separator.end };
+    for (const corner of ['start', 'end']) {
+        const from = line[corner];
+        const move = [next[corner][0] - from[0], next[corner][1] - from[1]];
+        for (const end of ['start', 'end']) {
+            if (distance(separator[end], from) > SAME_POINT)
+                continue;
+            const far = end === 'start' ? 'end' : 'start';
+            if (offMove(from, move, separator[far]) > JOIN)
+                continue;
+            const length = Math.hypot(move[0], move[1]);
+            const along = ((separator[far][0] - from[0]) * move[0] + (separator[far][1] - from[1]) * move[1]) / length;
+            read = {
+                ...read,
+                [far]: [from[0] + (move[0] / length) * along, from[1] + (move[1] / length) * along],
+            };
+        }
+    }
+    return read;
+}
+function levelSeparators(nodes, levelId) {
+    return Object.values(nodes).filter((node) => node.type === 'separator' && node.parentId === levelId);
+}
+/** The invisible walls joined at `endpoint` of `separator`: the ones a drag of that end takes. */
+export function joinedSeparatorIds(nodes, separator, endpoint) {
+    const point = separator[endpoint];
+    return levelSeparators(nodes, separator.parentId).flatMap((node) => node.id !== separator.id && (near(node.start, point) || near(node.end, point)) ? [node.id] : []);
+}
+/**
+ * Pushes invisible-wall stretches `offset` as one line: a room's edge of separators, a selected
+ * separator's side arrow. A stretch shorter than its separator is split off first and only it
+ * moves, the rest staying joined to it by a jog. An end that sat on a wall, a railing or another
+ * separator slides along it to where the moved line meets it; one the move carries off its end
+ * leaves a short invisible wall back to where it was, so the room stays closed. Separators joined
+ * to the moving ones end to end follow the junction rules of a wall move, and those T'd into
+ * their bodies stretch along their own lines. One plan, one undo step.
+ */
+export function translateSeparators(nodes, input) {
+    const spans = new Map();
+    for (const span of input.spans) {
+        const t0 = Math.max(0, Math.min(span.t0, span.t1));
+        const t1 = Math.min(1, Math.max(span.t0, span.t1));
+        const held = spans.get(span.separatorId);
+        spans.set(span.separatorId, {
+            t0: Math.min(t0, held?.t0 ?? t0),
+            t1: Math.max(t1, held?.t1 ?? t1),
+        });
+    }
+    const first = nodes[input.spans[0]?.separatorId ?? ''];
+    if (first?.type !== 'separator' ||
+        [...spans.keys()].some((id) => nodes[id]?.type !== 'separator' || nodes[id]?.parentId !== first.parentId))
+        throw Error('Select an invisible wall.');
+    const [dx, dz] = input.offset;
+    if (!(Number.isFinite(dx) && Number.isFinite(dz)))
+        throw Error('Invalid move.');
+    if (Math.hypot(dx, dz) < 1e-9)
+        return { changes: [] };
+    const levelId = first.parentId;
+    const shift = ([x, z]) => [x + dx, z + dz];
+    const scratch = { ...nodes };
+    // The stretches that move, cut out of their separators.
+    const rest = new Map();
+    for (const [id, { t0, t1 }] of spans) {
+        if (t1 - t0 < WHOLE)
+            continue;
+        const separator = scratch[id];
+        const point = (t) => at(separator.start, separator.end, t);
+        for (const [from, to] of [
+            [0, t0],
+            [t1, 1],
+        ])
+            if (to - from > WHOLE) {
+                const remainder = SeparatorNode.parse({
+                    ...separator,
+                    id: input.mintId('separator'),
+                    start: point(from),
+                    end: point(to),
+                });
+                scratch[remainder.id] = remainder;
+            }
+        const piece = { start: point(t0), end: point(t1) };
+        scratch[id] = { ...separator, ...piece };
+        rest.set(id, piece);
+    }
+    if (!rest.size)
+        return { changes: [] };
+    const still = Object.values(scratch).filter((node) => node.parentId === levelId &&
+        !rest.has(node.id) &&
+        (node.type === 'separator' || (node.type === 'wall' && !isCurvedWall(node))));
+    const bridges = [];
+    const moved = new Map();
+    for (const [id, line] of rest) {
+        const shifted = { start: shift(line.start), end: shift(line.end) };
+        const next = { ...shifted };
+        for (const end of ['start', 'end']) {
+            const point = line[end];
+            // A joint inside the moving line moves with it.
+            if ([...rest].some(([other, piece]) => other !== id && (near(piece.start, point) || near(piece.end, point))))
+                continue;
+            // Separators joined here end to end follow the move instead.
+            const hosts = still.filter((node) => !(node.type === 'separator' && (near(node.start, point) || near(node.end, point))) &&
+                onLine(point, node));
+            if (!hosts.length)
+                continue;
+            let slid = null;
+            for (const host of hosts) {
+                const meeting = meetingOn(shifted, host);
+                if (meeting && (!slid || distance(meeting, shifted[end]) < distance(slid, shifted[end])))
+                    slid = meeting;
+            }
+            if (slid)
+                next[end] = slid;
+            else if (!still.some((node) => onLine(shifted[end], node)))
+                bridges.push({ start: point, end: shifted[end] });
+        }
+        if (distance(next.start, next.end) < MIN_LENGTH)
+            return conflict('invalid-geometry', [id], 'The invisible wall would be too short there.');
+        moved.set(id, next);
+    }
+    const deleted = new Set();
+    for (const [id, line] of rest) {
+        const next = moved.get(id);
+        const others = levelSeparators(scratch, levelId).filter((node) => !rest.has(node.id) && !deleted.has(node.id));
+        // Joined end to end: put on the corner exactly, so the junction rules move them.
+        const joined = others
+            .filter((node) => touches(node, line))
+            .map((node) => ontoCorner(ontoCorner(node, line.start), line.end));
+        // T'd into its body: read before the joined ones move, so a moved end never reads as one.
+        const attached = planAttachedWallUpdates(others.filter((node) => !touches(node, line)).map((node) => ontoBody(node, line)), line.start, line.end, next.start, next.end);
+        const read = joined.map((node) => squaredForMove(node, line, next));
+        const junctions = planWallMoveJunctions(read, line.start, line.end, next.start, next.end);
+        // The rules move the joined ends; each separator keeps its own far end.
+        const linked = getPlannedLinkedWallUpdates(junctions, line.start, line.end, next.start, next.end).map((update) => {
+            const proxy = read.find((entry) => entry.id === update.id);
+            const own = joined.find((entry) => entry.id === update.id);
+            return {
+                id: update.id,
+                start: update.start === proxy.start ? own.start : update.start,
+                end: update.end === proxy.end ? own.end : update.end,
+            };
+        });
+        for (const update of [...linked, ...attached]) {
+            if (distance(update.start, update.end) < WALL_MIN_LENGTH) {
+                delete scratch[update.id];
+                deleted.add(update.id);
+            }
+            else
+                scratch[update.id] = {
+                    ...scratch[update.id],
+                    start: update.start,
+                    end: update.end,
+                };
+        }
+        for (const separator of junctions.wallsToDelete) {
+            delete scratch[separator.id];
+            deleted.add(separator.id);
+        }
+        for (const bridge of junctions.bridgePlans)
+            bridges.push({
+                start: bridge.originalPoint,
+                end: bridge.movedEndpoint === 'start' ? next.start : next.end,
+            });
+        scratch[id] = { ...scratch[id], start: next.start, end: next.end };
+    }
+    const made = [];
+    for (const bridge of bridges) {
+        if (distance(bridge.start, bridge.end) < WALL_MIN_LENGTH)
+            continue;
+        const same = (a, b) => distance(a, b) <= SAME_POINT;
+        if (made.some((line) => (same(line.start, bridge.start) && same(line.end, bridge.end)) ||
+            (same(line.start, bridge.end) && same(line.end, bridge.start))))
+            continue;
+        made.push(bridge);
+        const separator = SeparatorNode.parse({
+            id: input.mintId('separator'),
+            parentId: levelId,
+            start: bridge.start,
+            end: bridge.end,
+        });
+        scratch[separator.id] = separator;
+    }
+    return { changes: diffStructure(nodes, scratch) };
+}
+/**
+ * Moves one end of an invisible wall to `point`, as a wall's end drag does: the separators joined
+ * at that end follow it, stretching and turning about their far ends, and those T'd into its
+ * body slide along their own lines to stay on it. `detach` (Alt) leaves them where they are.
+ */
+export function setSeparatorEnd(nodes, input) {
+    const separator = nodes[input.separatorId];
+    if (separator?.type !== 'separator')
+        throw Error('Select an invisible wall.');
+    if (!input.point.every(Number.isFinite))
+        throw Error('Invalid point.');
+    const line = { start: separator.start, end: separator.end };
+    const next = { ...line, [input.endpoint]: input.point };
+    if (distance(next.start, next.end) < MIN_LENGTH)
+        return conflict('invalid-geometry', [separator.id], 'The invisible wall would be too short.');
+    const scratch = { ...nodes };
+    scratch[separator.id] = { ...separator, start: next.start, end: next.end };
+    if (!input.detach) {
+        const from = line[input.endpoint];
+        const others = levelSeparators(nodes, separator.parentId).filter((node) => node.id !== separator.id);
+        const updates = [
+            ...others.flatMap((other) => {
+                const start = near(other.start, from) ? input.point : other.start;
+                const end = near(other.end, from) ? input.point : other.end;
+                return start === other.start && end === other.end ? [] : [{ id: other.id, start, end }];
+            }),
+            ...planAttachedWallUpdates(others.filter((other) => !touches(other, line)).map((other) => ontoBody(other, line)), line.start, line.end, next.start, next.end),
+        ];
+        for (const update of updates) {
+            if (distance(update.start, update.end) < WALL_MIN_LENGTH)
+                delete scratch[update.id];
+            else
+                scratch[update.id] = {
+                    ...scratch[update.id],
+                    start: update.start,
+                    end: update.end,
+                };
+        }
+    }
+    return { changes: diffStructure(nodes, scratch) };
+}
+/**
+ * The invisible walls a moving wall carries along, so the rooms they close stay closed: one T'd
+ * into its body slides along its own line onto the moved line, as a wall T'd into it does, and
+ * one joined at a moving end follows that end while the end moves along the separator's own line
+ * (a corner pushed square). A corner the move turns leaves its separators where they are, on the
+ * wall it stretched; an end the move would carry off the wall lets go.
+ */
+export function planAttachedSeparatorUpdates(separators, originalStart, originalEnd, nextStart, nextEnd) {
+    const line = { start: originalStart, end: originalEnd };
+    const updates = planAttachedWallUpdates(separators.filter((separator) => !touches(separator, line)).map((s) => ontoBody(s, line)), originalStart, originalEnd, nextStart, nextEnd);
+    const corners = [
+        [originalStart, nextStart],
+        [originalEnd, nextEnd],
+    ];
+    for (const separator of separators) {
+        if (!touches(separator, line))
+            continue;
+        let next = null;
+        for (const end of ['start', 'end']) {
+            const corner = corners.find(([from]) => near(separator[end], from));
+            if (!corner)
+                continue;
+            const [from, to] = corner;
+            const other = separator[end === 'start' ? 'end' : 'start'];
+            if (distance(other, from) < SAME_POINT)
+                continue;
+            if (offMove(from, [to[0] - from[0], to[1] - from[1]], other) > JOIN)
+                continue;
+            next = { ...(next ?? { start: separator.start, end: separator.end }), [end]: to };
+        }
+        if (next && distance(next.start, next.end) >= WALL_MIN_LENGTH)
+            updates.push({ id: separator.id, start: next.start, end: next.end });
+    }
+    return updates;
+}

package/dist/commands/structure/set-floor-foundation.d.ts

@@ -39,6 +39,11 @@ export declare const FloorFoundationPatch: z.ZodObject<{
                 url: z.ZodString;
                 repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
                 scale: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                normalMap: z.ZodOptional<z.ZodString>;
+                normalScale: z.ZodOptional<z.ZodNumber>;
+                bumpMap: z.ZodOptional<z.ZodString>;
+                bumpScale: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>]>>;
     }, z.core.$strip>>;

package/dist/commands/structure/set-floor-foundation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-floor-foundation.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-floor-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiC/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,+FAA+F;AAC/F,eAAO,MAAM,2BAA2B,2BAA2B,CAAA;AAEnE,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAoD5C,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,EAAE,oBAAoB,CAAA;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GACA,aAAa,CA2Ff"}
+{"version":3,"file":"set-floor-foundation.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-floor-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiC/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,+FAA+F;AAC/F,eAAO,MAAM,2BAA2B,2BAA2B,CAAA;AAEnE,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAoD5C,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,EAAE,oBAAoB,CAAA;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GACA,aAAa,CA2Ff"}

package/dist/commands/structure/set-wall-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-wall-geometry.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-wall-geometry.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,GAAG,CAAC,EAAE,KAAK,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;IAChC,MAAM,EAAE,eAAe,CAAA;CACxB,GACA,aAAa,CA6Df"}
+{"version":3,"file":"set-wall-geometry.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-wall-geometry.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAGjB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,GAAG,CAAC,EAAE,KAAK,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;IAChC,MAAM,EAAE,eAAe,CAAA;CACxB,GACA,aAAa,CAoGf"}

package/dist/commands/structure/set-wall-geometry.js

@@ -1,7 +1,10 @@
 import { WallNode } from '../../schema/index.js';
 import { planWallJustification } from '../../systems/wall/wall-frame.js';
 import { getPlannedLinkedWallUpdates, planWallMoveJunctions } from '../../systems/wall/wall-move.js';
+import { WALL_MIN_LENGTH } from '../../systems/wall/wall-topology.js';
+import { planAttachedWallChanges } from './attached-walls.js';
 import { applyToScratch, conflict, diffStructure, } from './shared.js';
+import { retypeOutlineBridges, trimWallOverlaps } from './wall-overlap.js';
 export function setWallGeometry(nodes, input) {
     const original = nodes[input.wallId];
     if (original?.type !== 'wall')
@@ -32,20 +35,50 @@ export function setWallGeometry(nodes, input) {
         const hosted = Object.values(scratch).filter((n) => consumed.includes(n.parentId));
         if (hosted.length)
             return conflict('hosted-openings', hosted.map((n) => n.id), 'Moving this junction would remove a wall with hosted objects.');
+        const linkedUpdates = getPlannedLinkedWallUpdates(plan, wall.start, wall.end, start, end);
+        // A jog shorter than a wall can be (the wall landed on the line it left)
+        // is no wall: the walls already meet there.
+        const bridges = plan.bridgePlans.flatMap((bridge) => {
+            const to = bridge.movedEndpoint === 'start' ? start : end;
+            return Math.hypot(to[0] - bridge.originalPoint[0], to[1] - bridge.originalPoint[1]) <
+                WALL_MIN_LENGTH
+                ? []
+                : [
+                    {
+                        node: WallNode.parse({
+                            ...bridge.wall,
+                            id: input.mintId('wall'),
+                            children: [],
+                            start: bridge.originalPoint,
+                            end: to,
+                        }),
+                        parentId: wall.parentId,
+                    },
+                ];
+        });
         scratch = applyToScratch(scratch, {
-            update: getPlannedLinkedWallUpdates(plan, wall.start, wall.end, start, end).map(({ id, ...data }) => ({ id, data })),
+            update: linkedUpdates.map(({ id, ...data }) => ({ id, data })),
             delete: consumed,
-            create: plan.bridgePlans.map((bridge) => ({
-                node: WallNode.parse({
-                    ...bridge.wall,
-                    id: input.mintId('wall'),
-                    children: [],
-                    start: bridge.originalPoint,
-                    end: bridge.movedEndpoint === 'start' ? start : end,
-                }),
-                parentId: wall.parentId,
-            })),
+            create: bridges,
         });
+        scratch[wall.id] = next;
+        // Walls T'd into it stay on it, stretched along their own line.
+        const attached = planAttachedWallChanges(scratch, wall.id, wall.start, wall.end, start, end, new Set([...consumed, ...linkedUpdates.map(({ id }) => id)]));
+        scratch = applyToScratch(scratch, { update: attached, delete: [], create: [] });
+        // The moved wall, the walls it stretched and its jogs take over any
+        // stretch of a parallel wall they now run along; jogs left on the outline
+        // are outside walls.
+        const bridgeIds = bridges.map(({ node }) => node.id);
+        retypeOutlineBridges(scratch, wall.id, bridgeIds);
+        const blocked = trimWallOverlaps(scratch, [
+            wall.id,
+            ...linkedUpdates.map(({ id }) => id).filter((id) => scratch[id]),
+            ...attached.flatMap(({ id }) => (scratch[id]?.type === 'wall' ? [id] : [])),
+            ...bridgeIds,
+        ], () => input.mintId('wall'));
+        if (blocked)
+            return conflict(blocked.code, blocked.nodeIds, blocked.message);
+        return { changes: diffStructure(nodes, scratch) };
     }
     scratch[wall.id] = next;
     return { changes: diffStructure(nodes, scratch) };

package/dist/commands/structure/set-zone-intent.d.ts

@@ -12,6 +12,32 @@ export declare const ZoneIntentPatch: z.ZodObject<{
             polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
             finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
         }, z.core.$strip>>>>;
+        drop: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>>;
+    roomType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        deck: "deck";
+        patio: "patio";
+        porch: "porch";
+    }>>>;
+    porchFraming: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        auto: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        postSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        postSpacing: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        beamSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+    decking: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        boardSize: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            "2x4": "2x4";
+            "2x6": "2x6";
+            "5/4x6": "5/4x6";
+            composite: "composite";
+        }>>>;
+        gap: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        direction: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            diagonal: "diagonal";
+            parallel: "parallel";
+            perpendicular: "perpendicular";
+        }>>>;
     }, z.core.$strict>>>;
     ceiling: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{

package/dist/commands/structure/set-zone-intent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-zone-intent.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-zone-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,OAAO,EAAe,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAI/E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+B1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,GAChD,aAAa,CAkGf"}
+{"version":3,"file":"set-zone-intent.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-zone-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAcvB,OAAO,EAAe,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAK/E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuD1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AA4C7D,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,GAChD,aAAa,CAuIf"}

package/dist/commands/structure/set-zone-intent.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { floorIntentConflicts } from '../../lib/floor-intent-changes.js';
 import { floorScriptPaintRefusal } from '../../lib/floor-plate-paint.js';
+import { isOutdoorRoomDefaultName, isOutdoorRoomType, nextOutdoorRoomName, OUTDOOR_ROOM_DEFAULTS, } from '../../lib/outdoor-room.js';
 import { ownFloorIntentChanges } from '../../lib/own-floor-intent.js';
 import { drawnFloorElevationConflict } from '../../lib/room-drawn-floor.js';
 import { roundFloorElevation } from '../../lib/room-floor-feasibility.js';
@@ -9,6 +10,7 @@ import { mezzanineElevationConflict } from './mezzanine-content.js';
 import { requireZone } from './shared.js';
 const floor = ZoneNode.shape.floor.unwrap();
 const ceiling = ZoneNode.shape.ceiling.unwrap();
+const decking = ZoneNode.shape.decking.unwrap();
 export const ZoneIntentPatch = z.strictObject({
     name: z.string().nullable().optional(),
     floor: z
@@ -18,6 +20,30 @@ export const ZoneIntentPatch = z.strictObject({
         elevation: floor.shape.elevation.unwrap().nullable().optional(),
         finish: floor.shape.finish.unwrap().nullable().optional(),
         regions: floor.shape.regions.unwrap().nullable().optional(),
+        drop: floor.shape.drop.unwrap().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    roomType: ZoneNode.shape.roomType.unwrap().nullable().optional(),
+    // A porch's posts and beam (`lib/porch-framing`), a deck's or patio's once switched on (`auto`
+    // true). Choosing a size or the spacing rebuilds them from the settings, automatic again,
+    // unless the patch says otherwise.
+    porchFraming: z
+        .strictObject({
+        auto: z.boolean().nullable().optional(),
+        postSize: z.string().nullable().optional(),
+        postSpacing: z.number().positive().nullable().optional(),
+        beamSize: z.string().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    // A deck's boards (`lib/deck-boards`): the stock, the gap and the way they run; null clears one
+    // back to its default, a null `decking` all three.
+    decking: z
+        .strictObject({
+        boardSize: decking.shape.boardSize.unwrap().nullable().optional(),
+        gap: decking.shape.gap.unwrap().nullable().optional(),
+        direction: decking.shape.direction.unwrap().nullable().optional(),
     })
         .nullable()
         .optional(),
@@ -41,9 +67,45 @@ export const ZoneIntentPatch = z.strictObject({
         .nullable()
         .optional(),
 });
+/**
+ * The patch with what a change of room type brings (`lib/outdoor-room`): a porch, deck or patio
+ * steps its floor down from the house's, takes its floor finish, a ceiling or none, and its name
+ * while the room still has a default one; back to an ordinary room drops them again. What the
+ * patch sets itself wins.
+ */
+function withRoomType(nodes, zone, patch) {
+    const asked = patch.roomType;
+    if (asked === undefined || (asked ?? undefined) === zone.roomType)
+        return patch;
+    const previous = isOutdoorRoomType(zone.roomType) ? OUTDOOR_ROOM_DEFAULTS[zone.roomType] : null;
+    const next = isOutdoorRoomType(asked) ? OUTDOOR_ROOM_DEFAULTS[asked] : null;
+    // A finish the old type gave the room goes with it; one the user picked stays.
+    const finish = zone.floor?.finish;
+    const typeFinish = finish === undefined || finish === previous?.finish;
+    const defaultName = /^Room \d+$/.test(zone.name) || isOutdoorRoomDefaultName(zone.name);
+    const names = Object.values(nodes).flatMap((node) => node.type === 'zone' && node.parentId === zone.parentId && node.id !== zone.id
+        ? [node.name]
+        : []);
+    return {
+        ...patch,
+        ...(patch.name === undefined && next && defaultName
+            ? { name: nextOutdoorRoomName(asked, names) }
+            : {}),
+        ...(patch.hasCeiling === undefined ? { hasCeiling: next ? next.covered : true } : {}),
+        floor: {
+            ...patch.floor,
+            ...(patch.floor?.drop === undefined && patch.floor?.elevation === undefined
+                ? { drop: next ? next.drop : null }
+                : {}),
+            ...(patch.floor?.finish === undefined && typeFinish
+                ? { finish: next ? next.finish : null }
+                : {}),
+        },
+    };
+}
 export function setZoneIntent(nodes, input) {
     const zone = requireZone(nodes, input.zoneId);
-    const patch = ZoneIntentPatch.parse(input.patch);
+    const patch = withRoomType(nodes, zone, ZoneIntentPatch.parse(input.patch));
     const painted = zone.floor?.script && (patch.floor?.finish ?? patch.floor?.regions);
     const scripted = painted ? floorScriptPaintRefusal(zone) : undefined;
     if (scripted)
@@ -78,6 +140,42 @@ export function setZoneIntent(nodes, input) {
             : undefined;
     if (patch.name !== undefined)
         data.name = patch.name ?? '';
+    if (patch.roomType !== undefined)
+        data.roomType = patch.roomType ?? undefined;
+    if (patch.porchFraming !== undefined) {
+        const asked = patch.porchFraming;
+        const framing = asked === null ? {} : { ...zone.porchFraming };
+        if (asked)
+            for (const key of ['auto', 'postSize', 'postSpacing', 'beamSize']) {
+                if (asked[key] === null)
+                    delete framing[key];
+                else if (asked[key] !== undefined)
+                    framing[key] = asked[key];
+            }
+        const resized = asked && ['postSize', 'postSpacing', 'beamSize'].some((key) => key in asked);
+        if (resized && asked.auto === undefined)
+            framing.auto = true;
+        // A porch's are automatic by default, stored only when off; a deck's or patio's are off by
+        // default, stored when switched on.
+        const roomType = patch.roomType !== undefined ? (patch.roomType ?? undefined) : zone.roomType;
+        if (roomType === 'porch' && framing.auto === true)
+            delete framing.auto;
+        data.porchFraming = Object.keys(framing).length
+            ? framing
+            : undefined;
+    }
+    if (patch.decking !== undefined) {
+        const asked = patch.decking;
+        const boards = asked === null ? {} : { ...zone.decking };
+        if (asked)
+            for (const key of ['boardSize', 'gap', 'direction']) {
+                if (asked[key] === null)
+                    delete boards[key];
+                else if (asked[key] !== undefined)
+                    boards[key] = asked[key];
+            }
+        data.decking = Object.keys(boards).length ? boards : undefined;
+    }
     if (patch.wallMaterial !== undefined)
         data.wallMaterial = patch.wallMaterial ?? undefined;
     for (const key of ['hasFloor', 'hasCeiling'])
@@ -90,7 +188,14 @@ export function setZoneIntent(nodes, input) {
     if (patch.floor !== undefined) {
         data.floor = patch.floor === null ? undefined : { ...zone.floor };
         if (patch.floor)
-            for (const key of ['elevation', 'finish', 'regions', 'thickness', 'footprint']) {
+            for (const key of [
+                'elevation',
+                'finish',
+                'regions',
+                'thickness',
+                'footprint',
+                'drop',
+            ]) {
                 const value = patch.floor[key];
                 if (value === null)
                     delete data.floor[key];