@pascal-app/core 1.0.6 → 1.1.0

package/dist/lib/deck-framing.js

@@ -0,0 +1,515 @@
+import { DEFAULT_DECK_BOARDS, deckJoistSpacingLimit } from './deck-boards.js';
+import { floorPlateRoom } from './room-floor-plate.js';
+/**
+ * A wood deck's frame, planned once for the engine, which draws it under the deck's boards, and
+ * for the framing plugin, which books, labels and cites it. Framed to IRC R507:
+ *
+ *   - a LEDGER on the house edge (the deck edge along a house wall), the joist size;
+ *   - JOISTS at the spacing (closer under diagonal boards, Table R507.7), sized from a span table:
+ *     square to the house under boards that run along it or at 45°, along the house under boards
+ *     that run out from it;
+ *   - RIMS on every other edge, set in so the boards overhang them an inch (none at the house);
+ *   - a BEAM under each edge the joists run out to that is no ledger: DROPPED 16 in in under the
+ *     joists (a 4x8, the joists cantilevering past it) where the deck stands high enough for posts
+ *     under it, else FLUSH, a second joist-size board doubled inside the rim, the joists hung on
+ *     it; more beams between where the joists would span past the table. Joists along the house
+ *     bear on beams square to it at both ends, as joists hung off a ledger cannot run that way;
+ *   - 4x4 POSTS under each beam, at both ends and no more than 8 ft apart, down to the ground under
+ *     each, unless posts already standing there to grade carry it (a porch cover's).
+ *
+ * Any outline frames along its edges: an L-shaped deck gets a rim on every edge and a beam under
+ * each outer edge. Everything is level-local metres; a `yaw` is three.js's (local +x → world
+ * (cos θ, −sin θ)), a piece's `dims` its length along its run, its height and its thickness.
+ */
+const IN = 0.0254;
+const FT = 12 * IN;
+const EPS = 1e-9;
+/** A dropped beam sits this far in from the edge it carries (16 in), the joists cantilevering past it. */
+export const DECK_BEAM_INSET = 16 * IN;
+/** Posts at both beam ends (2 in in) and no more than 8 ft apart. */
+export const DECK_POST_SPACING = 96 * IN;
+/** The shortest post worth a post base (Simpson ABU/ABA need it); below this the beam goes flush. */
+export const DECK_MIN_POST_HEIGHT = 6 * IN;
+/** A post's face stands this far in from its beam's end. */
+export const DECK_POST_END_INSET = 2 * IN;
+/** The boards overhang the rim this much on a free edge; at the house they stop at the wall. */
+export const DECK_BOARD_OVERHANG = 1 * IN;
+/** An edge whose midpoint is within this of a wall's face is on the house. */
+const LEDGER_TOLERANCE = 0.3;
+/** A post standing within this of a beam's line carries it. */
+const CARRIER_REACH = 12 * IN;
+const CARRIER_END_REACH = 6 * IN;
+/** The narrowest deck framed. */
+const MIN_DECK = 12 * IN;
+/** A post shorter than this is not drawn: the beam sits on the ground there. */
+const MIN_DRAWN_POST = 0.05;
+/** A hanger's seat: this far along the joist from its end. */
+const HANGER_SEAT = 0.375 * IN;
+/**
+ * The joists a deck takes by the span they reach, first that spans: SPF #2 at 40 psf live, the
+ * floor table's arithmetic (R502.3.1(2); IRC R507.6 governs deck joists), as the framing plugin's
+ * default span table has them.
+ */
+export const DECK_JOIST_SPANS = [
+    { size: '2x8', thickness: 1.5 * IN, depth: 7.25 * IN, span: 12.25 * FT },
+    { size: '2x10', thickness: 1.5 * IN, depth: 9.25 * IN, span: 15 * FT },
+    { size: '2x12', thickness: 1.5 * IN, depth: 11.25 * IN, span: 17.4 * FT },
+];
+/** A dropped beam: a 4x8 (span per Table R507.5(1)). */
+export const DECK_DROPPED_BEAM = { size: '4x8', thickness: 3.5 * IN, depth: 7.25 * IN };
+/** A deck post (Table R507.4). */
+export const DECK_POST = { size: '4x4', thickness: 3.5 * IN, depth: 3.5 * IN };
+/** A deck room's dedicated floor plate, drawn as boards on a frame. */
+export function isDeckSlab(slab, resolve) {
+    return !slab.recessed && floorPlateRoom(slab, resolve)?.roomType === 'deck';
+}
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
+function distanceToWall(p, wall) {
+    const [dx, dz] = sub(wall.end, wall.start);
+    const dd = dx * dx + dz * dz;
+    if (dd < EPS)
+        return Math.hypot(p[0] - wall.start[0], p[1] - wall.start[1]);
+    const t = Math.max(0, Math.min(1, ((p[0] - wall.start[0]) * dx + (p[1] - wall.start[1]) * dz) / dd));
+    return Math.hypot(p[0] - (wall.start[0] + dx * t), p[1] - (wall.start[1] + dz * t));
+}
+/** How near edge `i` lies on a wall (parallel within 15°, its midpoint within the tolerance), or null. */
+function wallDistance(polygon, i, walls) {
+    const a = polygon[i];
+    const b = polygon[(i + 1) % polygon.length];
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (length < EPS)
+        return null;
+    const along = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+    const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    let best = null;
+    for (const wall of walls) {
+        if (wall.curved)
+            continue;
+        const [dx, dz] = sub(wall.end, wall.start);
+        const wallLength = Math.hypot(dx, dz);
+        if (wallLength < EPS)
+            continue;
+        const d = distanceToWall(mid, wall);
+        if (d > LEDGER_TOLERANCE + wall.thickness / 2)
+            continue;
+        if (Math.abs(cross(along, [dx / wallLength, dz / wallLength])) > Math.sin((15 * Math.PI) / 180))
+            continue;
+        if (best === null || d < best)
+            best = d;
+    }
+    return best;
+}
+/** The deck edge that lies on a wall (the nearest such), where the ledger goes; null when none does. */
+export function deckLedgerEdge(polygon, walls) {
+    let best = null;
+    for (let i = 0; i < polygon.length; i++) {
+        const d = wallDistance(polygon, i, walls);
+        if (d !== null && (!best || d < best.d))
+            best = { i, d };
+    }
+    return best ? best.i : null;
+}
+export function deckAxes(polygon, walls) {
+    if (polygon.length < 3)
+        return null;
+    const ledgerEdge = deckLedgerEdge(polygon, walls);
+    let base = ledgerEdge ?? 0;
+    if (ledgerEdge === null) {
+        let longest = 0;
+        for (let i = 0; i < polygon.length; i++) {
+            const [dx, dz] = sub(polygon[(i + 1) % polygon.length], polygon[i]);
+            const length = Math.hypot(dx, dz);
+            if (length > longest) {
+                longest = length;
+                base = i;
+            }
+        }
+    }
+    const a = polygon[base];
+    const [dx, dz] = sub(polygon[(base + 1) % polygon.length], a);
+    const length = Math.hypot(dx, dz);
+    if (length < EPS)
+        return null;
+    const u = [dx / length, dz / length];
+    // the vertex average decides which perpendicular points into the deck
+    let cx = 0;
+    let cz = 0;
+    for (const p of polygon) {
+        cx += p[0];
+        cz += p[1];
+    }
+    cx /= polygon.length;
+    cz /= polygon.length;
+    let v = [-u[1], u[0]];
+    if ((cx - a[0]) * v[0] + (cz - a[1]) * v[1] < 0)
+        v = [u[1], -u[0]];
+    return { ledgerEdge, baseEdge: base, origin: [a[0], a[1]], u, v };
+}
+/** The outline with each edge moved in by its offset (signed area kept), or null when that collapses it. */
+function insetEdges(polygon, offsets) {
+    const n = polygon.length;
+    let twice = 0;
+    for (let i = 0; i < n; i++)
+        twice += cross(polygon[i], polygon[(i + 1) % n]);
+    const sign = twice > 0 ? 1 : -1;
+    const lines = polygon.map((a, i) => {
+        const [dx, dz] = sub(polygon[(i + 1) % n], a);
+        const length = Math.hypot(dx, dz) || 1;
+        const e = [dx / length, dz / length];
+        const inward = sign > 0 ? [-e[1], e[0]] : [e[1], -e[0]];
+        const d = offsets[i] ?? 0;
+        return { p: [a[0] + inward[0] * d, a[1] + inward[1] * d], e };
+    });
+    const inset = polygon.map((_, i) => {
+        const before = lines[(i - 1 + n) % n];
+        const after = lines[i];
+        const turn = cross(before.e, after.e);
+        if (Math.abs(turn) < 1e-9)
+            return after.p;
+        const t = cross(sub(after.p, before.p), after.e) / turn;
+        return [before.p[0] + before.e[0] * t, before.p[1] + before.e[1] * t];
+    });
+    let insetTwice = 0;
+    for (let i = 0; i < n; i++)
+        insetTwice += cross(inset[i], inset[(i + 1) % n]);
+    return insetTwice * sign > 0.5 * Math.abs(twice) ? inset : null;
+}
+/** The outline without repeated corners. */
+function cleanOutline(polygon) {
+    const out = [];
+    for (const p of polygon) {
+        const last = out.at(-1);
+        if (!last || Math.hypot(p[0] - last[0], p[1] - last[1]) > 1e-6)
+            out.push([p[0], p[1]]);
+    }
+    while (out.length > 1 &&
+        Math.hypot(out[0][0] - out.at(-1)[0], out[0][1] - out.at(-1)[1]) <= 1e-6)
+        out.pop();
+    return out;
+}
+export function planDeckFraming(input) {
+    const boards = input.boards ?? DEFAULT_DECK_BOARDS;
+    const asked = input.joistSpacing ?? 16 * IN;
+    const spacing = Math.min(asked, deckJoistSpacingLimit(boards));
+    const joistsAlongHouse = boards.direction === 'perpendicular';
+    const ladder = input.joists?.length ? input.joists : DECK_JOIST_SPANS;
+    const joistTop = input.top - input.decking;
+    const plan = {
+        axes: null,
+        beam: 'unsupported',
+        joist: null,
+        spanPastTable: false,
+        joistSpacing: spacing,
+        spacingForBoards: spacing < asked - EPS,
+        joistsAlongHouse,
+        irregular: false,
+        beamLumber: null,
+        joistTop,
+        beamTop: joistTop,
+        postTop: joistTop,
+        postHeight: 0,
+        stationAxis: null,
+        stations: [],
+        ledger: null,
+        rims: [],
+        joists: [],
+        beams: [],
+        posts: [],
+    };
+    const outline = cleanOutline(input.polygon);
+    if (outline.length < 3)
+        return plan;
+    const axes = deckAxes(outline, input.walls);
+    if (!axes)
+        return plan;
+    plan.axes = axes;
+    const n = outline.length;
+    const ledgerEdge = axes.ledgerEdge;
+    // ---- the frame's outline: the free edges in by the boards' overhang ----
+    const overhang = input.overhang ?? DECK_BOARD_OVERHANG;
+    const offsets = outline.map((_, i) => wallDistance(outline, i, input.walls) === null ? overhang : 0);
+    const frame = insetEdges(outline, offsets) ?? outline;
+    // Frame coordinates: s along the joists' layout (stations), j along the joists.
+    const S = joistsAlongHouse ? axes.v : axes.u;
+    const J = joistsAlongHouse ? axes.u : axes.v;
+    const [ox, oz] = axes.origin;
+    const toFrame = (p) => [
+        (p[0] - ox) * S[0] + (p[1] - oz) * S[1],
+        (p[0] - ox) * J[0] + (p[1] - oz) * J[1],
+    ];
+    const toPlan = (s, j) => [ox + S[0] * s + J[0] * j, oz + S[1] * s + J[1] * j];
+    const yawOf = (s, j) => {
+        const x = S[0] * s + J[0] * j;
+        const z = S[1] * s + J[1] * j;
+        return Math.atan2(-z, x);
+    };
+    const yawS = yawOf(1, 0);
+    const yawJ = yawOf(0, 1);
+    const fq = frame.map(toFrame);
+    let twice = 0;
+    for (let i = 0; i < n; i++)
+        twice += cross(fq[i], fq[(i + 1) % n]);
+    const ccw = twice > 0;
+    const edges = fq.map((a, i) => {
+        const b = fq[(i + 1) % n];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const e = length > EPS ? [(b[0] - a[0]) / length, (b[1] - a[1]) / length] : [1, 0];
+        const inward = ccw ? [-e[1], e[0]] : [e[1], -e[0]];
+        // An 'end' edge runs across the joists: they run out to it. A 'side' edge runs with them.
+        const kind = Math.abs(e[0]) >= Math.abs(e[1]) ? 'end' : 'side';
+        return { a, b, e, inward, length, kind };
+    });
+    let sMin = Number.POSITIVE_INFINITY;
+    let sMax = Number.NEGATIVE_INFINITY;
+    let jMin = Number.POSITIVE_INFINITY;
+    let jMax = Number.NEGATIVE_INFINITY;
+    for (const [s, j] of fq) {
+        sMin = Math.min(sMin, s);
+        sMax = Math.max(sMax, s);
+        jMin = Math.min(jMin, j);
+        jMax = Math.max(jMax, j);
+    }
+    if (sMax - sMin < MIN_DECK || jMax - jMin < MIN_DECK)
+        return plan;
+    plan.irregular =
+        n !== 4 || edges.some((edge) => Math.min(Math.abs(edge.e[0]), Math.abs(edge.e[1])) > 1e-6);
+    // ---- the joists: sized for the span between their supports, beams between past the table ----
+    // A ledger carries the joists' house ends unless they run along it.
+    const hung = ledgerEdge !== null && !joistsAlongHouse;
+    const near = hung ? jMin : jMin + DECK_BEAM_INSET;
+    const far = jMax - DECK_BEAM_INSET;
+    const run = Math.max(far - near, 0);
+    const longest = ladder.at(-1);
+    const bays = Math.max(1, Math.ceil(run / longest.span - 1e-9));
+    const joist = ladder.find((size) => run / bays <= size.span + EPS) ?? longest;
+    plan.joist = joist;
+    plan.spanPastTable = run / bays > longest.span + EPS;
+    const t = joist.thickness;
+    const d = joist.depth;
+    const centerY = joistTop - d / 2;
+    // ---- the beam: dropped where a post fits under a 4x8 under the joists, else flush ----
+    const dropped = joistTop - d - DECK_DROPPED_BEAM.depth - input.gradeY >= DECK_MIN_POST_HEIGHT;
+    const beamLumber = dropped ? DECK_DROPPED_BEAM : joist;
+    const beamTop = dropped ? joistTop - d : joistTop;
+    const postTop = beamTop - beamLumber.depth;
+    const postHeight = postTop - input.gradeY;
+    const canPost = postHeight >= DECK_MIN_POST_HEIGHT;
+    plan.beam = dropped ? 'dropped' : canPost ? 'flush' : 'unsupported';
+    plan.beamLumber = beamLumber;
+    plan.beamTop = beamTop;
+    plan.postTop = postTop;
+    plan.postHeight = postHeight;
+    const pieceAt = (role, size, s, j, y, dims, yaw) => {
+        const [x, z] = toPlan(s, j);
+        return { role, size, position: [x, y, z], dims, yaw };
+    };
+    // A run along an edge direction, its yaw taken along +s or +j, as the frame's own axes are.
+    const runYaw = (e) => {
+        const flip = Math.abs(e[0]) >= Math.abs(e[1]) ? e[0] < 0 : e[1] < 0;
+        return flip ? yawOf(-e[0], -e[1]) : yawOf(e[0], e[1]);
+    };
+    const isConvex = (i) => {
+        const turn = cross(edges[(i - 1 + n) % n].e, edges[i].e);
+        return ccw ? turn > 1e-9 : turn < -1e-9;
+    };
+    const isReflex = (i) => {
+        const turn = cross(edges[(i - 1 + n) % n].e, edges[i].e);
+        return ccw ? turn < -1e-9 : turn > 1e-9;
+    };
+    // ---- the ledger and the rims: one along every edge, a board the joist size inside it ----
+    // Where an end edge meets a side edge, the end's board runs to the corner and the side's stops at
+    // it (at an inside corner the end's runs on past it), so the corners close.
+    for (let i = 0; i < n; i++) {
+        const edge = edges[i];
+        const prev = edges[(i - 1 + n) % n];
+        const next = edges[(i + 1) % n];
+        const startTrim = edge.kind === 'side' && prev.kind === 'end' && isConvex(i)
+            ? t
+            : edge.kind === 'end' && prev.kind === 'side' && isReflex(i)
+                ? -t
+                : 0;
+        const j1 = (i + 1) % n;
+        const endTrim = edge.kind === 'side' && next.kind === 'end' && isConvex(j1)
+            ? t
+            : edge.kind === 'end' && next.kind === 'side' && isReflex(j1)
+                ? -t
+                : 0;
+        const length = edge.length - startTrim - endTrim;
+        if (length < t)
+            continue;
+        const mid = startTrim + length / 2;
+        const s = edge.a[0] + edge.e[0] * mid + edge.inward[0] * (t / 2);
+        const j = edge.a[1] + edge.e[1] * mid + edge.inward[1] * (t / 2);
+        const piece = pieceAt(i === ledgerEdge ? 'ledger' : 'rim', joist.size, s, j, centerY, [length, d, t], runYaw(edge.e));
+        if (i === ledgerEdge)
+            plan.ledger = piece;
+        else
+            plan.rims.push(piece);
+    }
+    const lines = [];
+    const inset = dropped ? DECK_BEAM_INSET : t + t / 2;
+    edges.forEach((edge, i) => {
+        if (edge.kind !== 'end' || i === ledgerEdge)
+            return;
+        const offset = [edge.inward[0] * inset, edge.inward[1] * inset];
+        lines.push({
+            from: [edge.a[0] + offset[0], edge.a[1] + offset[1]],
+            to: [edge.b[0] + offset[0], edge.b[1] + offset[1]],
+            edge: i,
+            yaw: runYaw(edge.e),
+            thickness: dropped ? beamLumber.thickness : t,
+        });
+    });
+    // The beams between: lines across the frame at even spacing, where it lies across them.
+    const middles = [];
+    if (bays > 1) {
+        const first = hung ? jMin : jMin + inset;
+        const last = jMax - inset;
+        for (let k = 1; k < bays; k++)
+            middles.push(first + ((last - first) * k) / bays);
+    }
+    /** Where the frame lies across the line j = `j`: [s0, s1] runs, with the edges they end on. */
+    const across = (j) => {
+        const hits = [];
+        edges.forEach((edge, i) => {
+            const { a, b } = edge;
+            if ((a[1] <= j && j < b[1]) || (b[1] <= j && j < a[1]))
+                hits.push({ s: a[0] + ((j - a[1]) * (b[0] - a[0])) / (b[1] - a[1]), edge: i });
+        });
+        hits.sort((p, q) => p.s - q.s);
+        const runs = [];
+        for (let k = 0; k + 1 < hits.length; k += 2)
+            runs.push([hits[k].s, hits[k + 1].s]);
+        return runs;
+    };
+    for (const j of middles)
+        for (const [s0, s1] of across(j))
+            lines.push({
+                from: [s0, j],
+                to: [s1, j],
+                edge: null,
+                yaw: yawS,
+                thickness: dropped ? beamLumber.thickness : 2 * t,
+            });
+    const carriers = (input.carriers ?? []).map(toFrame);
+    const endInset = dropped ? DECK_POST_END_INSET : t;
+    for (const line of lines) {
+        const dir = sub(line.to, line.from);
+        const full = Math.hypot(dir[0], dir[1]);
+        if (full < EPS)
+            continue;
+        const e = [dir[0] / full, dir[1] / full];
+        const length = full - 2 * endInset;
+        if (length < DECK_POST.thickness)
+            continue;
+        const mid = [(line.from[0] + line.to[0]) / 2, (line.from[1] + line.to[1]) / 2];
+        const carried = carriers.filter((c) => {
+            const along = dot(sub(c, line.from), e);
+            return (Math.abs(cross(e, sub(c, line.from))) <= CARRIER_REACH &&
+                along >= -CARRIER_END_REACH &&
+                along <= full + CARRIER_END_REACH);
+        }).length >= 2;
+        const beam = pieceAt('beam', beamLumber.size, mid[0], mid[1], beamTop - beamLumber.depth / 2, [length, beamLumber.depth, line.thickness], line.yaw);
+        beam.carried = carried;
+        beam.between = line.edge === null;
+        plan.beams.push(beam);
+        if (!canPost || carried)
+            continue;
+        const count = Math.max(2, Math.ceil(length / DECK_POST_SPACING) + 1);
+        const span = length - 2 * DECK_POST_END_INSET;
+        for (let k = 0; k < count; k++) {
+            const along = -length / 2 + DECK_POST_END_INSET + (span * k) / (count - 1);
+            const s = mid[0] + e[0] * along;
+            const j = mid[1] + e[1] * along;
+            const [x, z] = toPlan(s, j);
+            const bottom = input.gradeAt ? input.gradeAt(x, z) : input.gradeY;
+            const height = postTop - bottom;
+            if (!(height >= MIN_DRAWN_POST))
+                continue;
+            plan.posts.push({
+                role: 'post',
+                size: DECK_POST.size,
+                position: [x, postTop - height / 2, z],
+                dims: [DECK_POST.thickness, height, DECK_POST.depth],
+                yaw: line.yaw,
+                bottom,
+            });
+        }
+    }
+    // ---- the joists: at the spacing from one side to the other, each run between its supports ----
+    const flushEdges = new Set(dropped ? [] : lines.flatMap((line) => (line.edge === null ? [] : [line.edge])));
+    const stations = [];
+    for (let k = 0;; k++) {
+        const s = sMin + t / 2 + k * spacing;
+        if (s > sMax - t / 2 + EPS)
+            break;
+        stations.push(s);
+    }
+    if ((stations.at(-1) ?? Number.NEGATIVE_INFINITY) < sMax - t / 2 - EPS)
+        stations.push(sMax - t / 2);
+    plan.stationAxis = [S[0], S[1]];
+    plan.stations = stations;
+    // A station on a side edge's board: the rim (or a ledger along the joists) is that joist.
+    const sideRims = edges.filter((edge) => edge.kind === 'side' && Math.abs(edge.e[0]) < 1e-6);
+    for (const s of stations) {
+        const hits = [];
+        edges.forEach((edge, i) => {
+            const { a, b } = edge;
+            if ((a[0] <= s && s < b[0]) || (b[0] <= s && s < a[0]))
+                hits.push({ j: a[1] + ((s - a[0]) * (b[1] - a[1])) / (b[0] - a[0]), edge: i });
+        });
+        hits.sort((p, q) => p.j - q.j);
+        for (let k = 0; k + 1 < hits.length; k += 2) {
+            const lo = hits[k];
+            const hi = hits[k + 1];
+            // in past the board on the edge each end meets: the rim, the ledger, a flush beam's two
+            const band = (edge) => {
+                const thick = flushEdges.has(edge) ? 2 * t : t;
+                return thick / Math.max(Math.abs(edges[edge].inward[1]), 0.3);
+            };
+            const hangsOn = (edge) => edge === ledgerEdge || flushEdges.has(edge);
+            const segments = [
+                {
+                    j0: lo.j + band(lo.edge),
+                    j1: hi.j - band(hi.edge),
+                    hung0: hangsOn(lo.edge),
+                    hung1: hangsOn(hi.edge),
+                    yaw0: runYaw(edges[lo.edge].e),
+                    yaw1: runYaw(edges[hi.edge].e),
+                },
+            ];
+            // a flush beam between cuts the run: the joists hang on both its faces
+            if (!dropped)
+                for (const j of middles) {
+                    const at = segments.findIndex((seg) => j - t > seg.j0 + EPS && j + t < seg.j1 - EPS);
+                    if (at < 0)
+                        continue;
+                    const seg = segments[at];
+                    segments.splice(at, 1, { ...seg, j1: j - t, hung1: true, yaw1: yawS }, { ...seg, j0: j + t, hung0: true, yaw0: yawS });
+                }
+            const atRim = sideRims.some((edge) => Math.abs(s - edge.a[0]) < t - EPS &&
+                Math.max(edge.a[1], edge.b[1]) > lo.j + EPS &&
+                Math.min(edge.a[1], edge.b[1]) < hi.j - EPS);
+            for (const seg of segments) {
+                const length = seg.j1 - seg.j0;
+                if (length < t)
+                    continue;
+                const piece = pieceAt('joist', joist.size, s, (seg.j0 + seg.j1) / 2, centerY, [length, d, t], yawJ);
+                piece.atRim = atRim;
+                piece.hangers = [];
+                const hanger = (j, yaw) => {
+                    const [x, z] = toPlan(s, j);
+                    piece.hangers.push({ position: [x, centerY, z], yaw });
+                };
+                if (seg.hung0)
+                    hanger(seg.j0 + HANGER_SEAT, seg.yaw0);
+                if (seg.hung1)
+                    hanger(seg.j1 - HANGER_SEAT, seg.yaw1);
+                plan.joists.push(piece);
+            }
+        }
+    }
+    return plan;
+}

package/dist/lib/deepest-drawn.d.ts

@@ -6,12 +6,9 @@ type Nodes = Record<AnyNodeId, AnyNode>;
  */
 export declare function lowestGroundY(nodes: Nodes): number;
 /**
- * The world Y of the deepest thing the scene draws: the bottom of the footing under the lowest floor
- * slab (its underside less a footing's thickness; never above the walls' base, as the footing
- * itself is). A recessed slab (a basin) is drawn down to its own underside, with no footing under
- * it. Site flatwork (a lawn, a driveway) is not a floor of the house and counts for nothing. A
- * footing under a floor at or over grade sits about as deep, and never nearer the dive's own floor,
- * so the floors alone decide. `null` for a scene with no floor.
+ * The world Y of the deepest thing the scene draws: the underside of the lowest floor slab. A
+ * recessed slab (a basin) is drawn down to its own underside. Site flatwork (a lawn, a driveway)
+ * is not a floor of the house and counts for nothing. `null` for a scene with no floor.
  */
 export declare function deepestDrawnY(nodes: Nodes): number | null;
 export {};

package/dist/lib/deepest-drawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepest-drawn.d.ts","sourceRoot":"","sources":["../../src/lib/deepest-drawn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAQnD,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAIvC;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAclD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAsBzD"}
+{"version":3,"file":"deepest-drawn.d.ts","sourceRoot":"","sources":["../../src/lib/deepest-drawn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAOnD,KAAK,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AAIvC;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAclD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,CAsBzD"}

package/dist/lib/deepest-drawn.js

@@ -1,5 +1,4 @@
 import { getLevelElevations } from '../services/storey.js';
-import { FOUNDATION_STANDARD } from './foundation-standard.js';
 import { isSiteFlatwork } from './site-flatwork.js';
 import { FLAT_GROUND_Y } from './site-ground-height.js';
 import { heightAtSample } from './terrain-field.js';
@@ -27,12 +26,9 @@ export function lowestGroundY(nodes) {
     return lowest;
 }
 /**
- * The world Y of the deepest thing the scene draws: the bottom of the footing under the lowest floor
- * slab (its underside less a footing's thickness; never above the walls' base, as the footing
- * itself is). A recessed slab (a basin) is drawn down to its own underside, with no footing under
- * it. Site flatwork (a lawn, a driveway) is not a floor of the house and counts for nothing. A
- * footing under a floor at or over grade sits about as deep, and never nearer the dive's own floor,
- * so the floors alone decide. `null` for a scene with no floor.
+ * The world Y of the deepest thing the scene draws: the underside of the lowest floor slab. A
+ * recessed slab (a basin) is drawn down to its own underside. Site flatwork (a lawn, a driveway)
+ * is not a floor of the house and counts for nothing. `null` for a scene with no floor.
  */
 export function deepestDrawnY(nodes) {
     const elevations = getLevelElevations(nodes);
@@ -57,7 +53,7 @@ export function deepestDrawnY(nodes) {
             else
                 floorUnderside = Math.min(floorUnderside, underside);
         }
-        const bottom = Math.min(floorUnderside - FOUNDATION_STANDARD.footingThickness, basinUnderside);
+        const bottom = Math.min(floorUnderside, basinUnderside);
         if (deepest === null || bottom < deepest)
             deepest = bottom;
     }

package/dist/lib/door-interaction.d.ts

@@ -0,0 +1,14 @@
+import type { AnyNodeId } from '../schema/types.js';
+import { type DoorInteractiveState } from '../store/use-interactive.js';
+import { isOperationDoorType } from './door-operation.js';
+export declare const DOOR_SWING_OPEN_ANGLE: number;
+export declare const DOOR_TOGGLE_ANIMATION_MS = 520;
+export { isOperationDoorType };
+type DoorOpenAnimationOptions = {
+    persist?: boolean;
+};
+export declare function getDisplayedDoorValue(doorId: AnyNodeId, field: keyof DoorInteractiveState, nodeValue: number | undefined): number;
+export declare function toggleDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions): void;
+export declare function closeDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions): void;
+export declare function openDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions): void;
+//# sourceMappingURL=door-interaction.d.ts.map

package/dist/lib/door-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"door-interaction.d.ts","sourceRoot":"","sources":["../../src/lib/door-interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,EAAE,KAAK,oBAAoB,EAAkB,MAAM,0BAA0B,CAAA;AAEpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAEtD,eAAO,MAAM,qBAAqB,QAAc,CAAA;AAChD,eAAO,MAAM,wBAAwB,MAAM,CAAA;AAE3C,OAAO,EAAE,mBAAmB,EAAE,CAAA;AAE9B,KAAK,wBAAwB,GAAG;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,oBAAoB,EACjC,SAAS,EAAE,MAAM,GAAG,SAAS,UAU9B;AAmBD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,wBAAwB,QAwBxF;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,wBAAwB,QAYvF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,wBAAwB,QAYtF"}

package/dist/lib/door-interaction.js

@@ -0,0 +1,62 @@
+import { useInteractive } from '../store/use-interactive.js';
+import useScene from '../store/use-scene.js';
+import { isOperationDoorType } from './door-operation.js';
+export const DOOR_SWING_OPEN_ANGLE = Math.PI / 2;
+export const DOOR_TOGGLE_ANIMATION_MS = 520;
+export { isOperationDoorType };
+export function getDisplayedDoorValue(doorId, field, nodeValue) {
+    const interactive = useInteractive.getState();
+    const runtimeValue = interactive.doors[doorId]?.[field];
+    if (runtimeValue !== undefined)
+        return runtimeValue;
+    const queuedValue = interactive.doorAnimations[doorId]?.from;
+    if (queuedValue !== undefined)
+        return queuedValue;
+    return nodeValue ?? 0;
+}
+function startDoorOpenAnimation(doorId, field, from, to, options) {
+    useInteractive.getState().startDoorAnimation(doorId, {
+        field,
+        from,
+        to,
+        startedAt: null,
+        durationMs: DOOR_TOGGLE_ANIMATION_MS,
+        persist: options?.persist ?? true,
+    });
+}
+export function toggleDoorOpenState(doorId, options) {
+    const node = useScene.getState().nodes[doorId];
+    if (node?.type !== 'door' || node.openingKind === 'opening')
+        return;
+    if (isOperationDoorType(node.doorType)) {
+        const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState);
+        startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, currentOpenAmount >= 0.5 ? 0 : 1, options);
+        return;
+    }
+    const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle);
+    startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, currentSwingAngle >= DOOR_SWING_OPEN_ANGLE / 2 ? 0 : DOOR_SWING_OPEN_ANGLE, options);
+}
+export function closeDoorOpenState(doorId, options) {
+    const node = useScene.getState().nodes[doorId];
+    if (node?.type !== 'door' || node.openingKind === 'opening')
+        return;
+    if (isOperationDoorType(node.doorType)) {
+        const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState);
+        startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, 0, options);
+        return;
+    }
+    const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle);
+    startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, 0, options);
+}
+export function openDoorOpenState(doorId, options) {
+    const node = useScene.getState().nodes[doorId];
+    if (node?.type !== 'door' || node.openingKind === 'opening')
+        return;
+    if (isOperationDoorType(node.doorType)) {
+        const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState);
+        startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, 1, options);
+        return;
+    }
+    const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle);
+    startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, DOOR_SWING_OPEN_ANGLE, options);
+}

package/dist/lib/door-opening.d.ts

@@ -0,0 +1,19 @@
+import type { DoorNode } from '../schema/index.js';
+/** Leaf centre relative to the full opening centre, in the door's own frame (metres). */
+export declare function getDoorOpeningSize(door: {
+    width: number;
+    height: number;
+    doorType?: string;
+    openingKind?: string;
+    source?: unknown;
+    sidelightLeft?: number;
+    sidelightRight?: number;
+    transomHeight?: number;
+}): {
+    width: number;
+    height: number;
+    leafOffsetX: number;
+};
+/** Keep the host cutout fixed when the leaf's facing changes. */
+export declare function doorPositionForFacing(door: Pick<DoorNode, 'position' | 'rotation'> & Parameters<typeof getDoorOpeningSize>[0], nextRotation: DoorNode['rotation']): DoorNode['position'];
+//# sourceMappingURL=door-opening.d.ts.map