@pascal-app/core 1.0.3 → 1.0.5

package/dist/systems/stair/stair-sweep-edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-sweep-edit.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-sweep-edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,gGAAgG;AAChG,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,GAAG,UAAU,CAAC,EACjD,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,OAAO,GAAG,KAAK;;;EAOrB"}

package/dist/systems/stair/stair-sweep-edit.js

@@ -0,0 +1,8 @@
+/** Keep the opposite arrival/entry edge fixed, and preserve winding at the zero-sweep limit. */
+export function planStairSweepEdit(stair, delta, end) {
+    const sign = Math.sign(stair.sweepAngle) || 1;
+    const target = stair.sweepAngle + (end === 'end' ? delta : -delta);
+    const sweepAngle = sign * Math.max(0.0001, sign * target);
+    const change = sweepAngle - stair.sweepAngle;
+    return { sweepAngle, rotation: stair.rotation + (end === 'end' ? -change / 2 : change / 2) };
+}

package/dist/systems/stair/stair-walking-line.d.ts

@@ -0,0 +1,5 @@
+import type { StairNode, StairSegmentNode } from '../../schema/index.js';
+export type StairWalkingPoint = [number, number, number];
+/** Ideal ascent line in stair-local coordinates; hidden segments break the displayed path. */
+export declare function resolveStairWalkingPaths(stair: StairNode, segments: readonly StairSegmentNode[], totalRise: number): StairWalkingPoint[][];
+//# sourceMappingURL=stair-walking-line.d.ts.map

package/dist/systems/stair/stair-walking-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-walking-line.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-walking-line.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAK/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAExD,8FAA8F;AAC9F,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,SAAS,EAAE,MAAM,GAChB,iBAAiB,EAAE,EAAE,CA4FvB"}

package/dist/systems/stair/stair-walking-line.js

@@ -0,0 +1,91 @@
+import { computeSegmentTransforms, rotateXZ } from './stair-footprint.js';
+import { resolveStairArcDimensions } from './stair-layout.js';
+import { resolveStairWinder } from './stair-winder.js';
+/** Ideal ascent line in stair-local coordinates; hidden segments break the displayed path. */
+export function resolveStairWalkingPaths(stair, segments, totalRise) {
+    if (stair.visible === false)
+        return [];
+    if (stair.stairType !== 'straight') {
+        const layout = resolveStairArcDimensions(stair, totalRise);
+        if (!Number.isFinite(layout.sweepAngle))
+            return [];
+        // A presentation budget coarsens exceptionally long arcs without truncating their sweep.
+        const samples = Math.max(2, Math.min(10_000, Math.ceil(Math.abs(layout.sweepAngle) / (Math.PI / 60))));
+        const points = Array.from({ length: samples + 1 }, (_, index) => {
+            const t = index / samples;
+            const angle = -layout.sweepAngle / 2 + t * layout.sweepAngle;
+            return [
+                Math.cos(angle) * layout.walkingRadius,
+                t * totalRise,
+                Math.sin(angle) * layout.walkingRadius,
+            ];
+        });
+        if (layout.landingSweep) {
+            const landingSamples = Math.max(2, Math.ceil(Math.abs(layout.landingSweep) / (Math.PI / 60)));
+            for (let index = 1; index <= landingSamples; index++) {
+                const angle = layout.sweepAngle / 2 + (layout.landingSweep * index) / landingSamples;
+                points.push([
+                    Math.cos(angle) * layout.walkingRadius,
+                    totalRise,
+                    Math.sin(angle) * layout.walkingRadius,
+                ]);
+            }
+        }
+        return [points];
+    }
+    const chain = segments.length
+        ? segments
+        : [
+            {
+                width: stair.width,
+                length: 3,
+                height: totalRise,
+                attachmentSide: 'front',
+                segmentType: 'stair',
+                visible: true,
+            },
+        ];
+    const transforms = computeSegmentTransforms(chain);
+    const paths = [];
+    let current = [];
+    const flush = () => {
+        if (current.length > 1)
+            paths.push(current);
+        current = [];
+    };
+    for (const [index, segment] of chain.entries()) {
+        if (segment.visible === false) {
+            flush();
+            continue;
+        }
+        const transform = transforms[index];
+        const point = (x, y, z) => {
+            const [dx, dz] = rotateXZ(x, z, transform.rotation);
+            return [transform.position[0] + dx, transform.position[1] + y, transform.position[2] + dz];
+        };
+        const winder = 'winder' in segment ? resolveStairWinder(segment) : null;
+        if (winder) {
+            const points = winder.walkingLine.map(([x, y, z]) => point(x, y, z));
+            const first = points[0];
+            if (current.length && Math.hypot(...first.map((v, i) => v - current.at(-1)[i])) > 1e-8)
+                flush();
+            current.push(...points);
+            continue;
+        }
+        const start = point(0, segment.segmentType === 'landing' ? segment.height : 0, 0);
+        if (!current.length ||
+            Math.hypot(...start.map((value, axis) => value - current.at(-1)[axis])) > 1e-8) {
+            flush();
+            current.push(start);
+        }
+        if (segment.segmentType === 'landing') {
+            current.push(point(0, segment.height, segment.length / 2));
+            const nextSide = chain[index + 1]?.attachmentSide ?? 'front';
+            current.push(point(nextSide === 'left' ? segment.width / 2 : nextSide === 'right' ? -segment.width / 2 : 0, segment.height, nextSide === 'front' ? segment.length : segment.length / 2));
+        }
+        else
+            current.push(point(0, segment.height, segment.length));
+    }
+    flush();
+    return paths;
+}

package/dist/systems/stair/stair-winder.d.ts

@@ -0,0 +1,36 @@
+import type { StairNode, StairSegmentNode } from '../../schema/index.js';
+export type StairWinderPoint = [number, number];
+export type StairWinderLayout = {
+    treads: {
+        polygon: StairWinderPoint[];
+        elevation: number;
+        startStation: number;
+        endStation: number;
+        startAngle: number;
+        endAngle: number;
+    }[];
+    footprint: StairWinderPoint[];
+    walkingLine: [number, number, number][];
+    innerBoundary: [number, number, number][];
+    outerBoundary: [number, number, number][];
+    exit: {
+        position: [number, number, number];
+        rotation: number;
+    };
+    going: number;
+    narrowEndGoing: number;
+};
+/** A square-ring quarter turn: tread rays meet square rims, including their corner. */
+export declare function resolveStairWinder(segment: Pick<StairSegmentNode, 'width' | 'height' | 'stepCount' | 'winder'>): StairWinderLayout | null;
+export type StairWinderConstructionPiece = {
+    role: 'tread' | 'body';
+    walkingTop: boolean;
+    index: number;
+    polygon: StairWinderPoint[];
+    bottom: number[];
+    top: number;
+};
+/** Polygon prisms share the exact walking footprint; structure stays below its finished top. */
+export declare function resolveWinderStairConstruction(segment: StairSegmentNode, absoluteHeight?: number, parent?: StairNode): StairWinderConstructionPiece[] | null;
+export declare function resolveStairWinderFootprint(segment: StairSegmentNode, parent?: StairNode): StairWinderPoint[] | null;
+//# sourceMappingURL=stair-winder.d.ts.map

package/dist/systems/stair/stair-winder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-winder.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-winder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC/C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE;QACN,OAAO,EAAE,gBAAgB,EAAE,CAAA;QAC3B,SAAS,EAAE,MAAM,CAAA;QACjB,YAAY,EAAE,MAAM,CAAA;QACpB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;KACjB,EAAE,CAAA;IACH,SAAS,EAAE,gBAAgB,EAAE,CAAA;IAC7B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IACvC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IACzC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IACzC,IAAI,EAAE;QAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9D,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,uFAAuF;AACvF,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC,GAC3E,iBAAiB,GAAG,IAAI,CAqF1B;AAED,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,gBAAgB,EAAE,CAAA;IAC3B,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,gGAAgG;AAChG,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,gBAAgB,EACzB,cAAc,SAAI,EAClB,MAAM,CAAC,EAAE,SAAS,GACjB,4BAA4B,EAAE,GAAG,IAAI,CA6HvC;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,gBAAgB,EACzB,MAAM,CAAC,EAAE,SAAS,GACjB,gBAAgB,EAAE,GAAG,IAAI,CAW3B"}

package/dist/systems/stair/stair-winder.js

@@ -0,0 +1,173 @@
+/** A square-ring quarter turn: tread rays meet square rims, including their corner. */
+export function resolveStairWinder(segment) {
+    if (!segment.winder)
+        return null;
+    const { innerGap: gap, walkingLineOffset: offset, turn, division } = segment.winder;
+    const { width, height, stepCount: count } = segment;
+    if (!(Number.isFinite(width) &&
+        width > 0 &&
+        Number.isFinite(height) &&
+        height > 0 &&
+        Number.isInteger(count) &&
+        count > 0 &&
+        count <= 10000))
+        throw new RangeError('Winders require positive dimensions and 1–10,000 whole risers.');
+    if (!(Number.isFinite(gap) && gap >= 0 && Number.isFinite(offset) && offset > 0 && offset <= width))
+        throw new RangeError('The winder walking line must lie within the flight width.');
+    const radius = gap + offset;
+    const outer = gap + width;
+    const sign = turn === 'left' ? -1 : 1;
+    // Pivot lies beside the entry. Travel starts along +Z and ends toward the turn.
+    const point = (r, angle) => {
+        const scale = r / Math.max(Math.cos(angle), Math.sin(angle));
+        return [sign * (gap + width / 2 - scale * Math.cos(angle)), scale * Math.sin(angle)];
+    };
+    const stationAngle = (station) => station <= radius ? Math.atan2(station, radius) : Math.atan2(radius, 2 * radius - station);
+    const angleStation = (angle) => angle <= Math.PI / 4 ? radius * Math.tan(angle) : 2 * radius - radius / Math.tan(angle);
+    const angles = Array.from({ length: count + 1 }, (_, index) => division === 'equal-angle'
+        ? ((index / count) * Math.PI) / 2
+        : stationAngle((index / count) * 2 * radius));
+    const rim = (r, start, end) => [
+        point(r, start),
+        ...(start < Math.PI / 4 && end > Math.PI / 4 ? [point(r, Math.PI / 4)] : []),
+        point(r, end),
+    ];
+    const treads = Array.from({ length: count }, (_, index) => {
+        const start = angles[index], end = angles[index + 1];
+        const polygon = [...rim(outer, start, end), ...rim(gap, start, end).reverse()];
+        return {
+            polygon,
+            elevation: ((index + 1) * height) / count,
+            startStation: angleStation(start),
+            endStation: angleStation(end),
+            startAngle: start,
+            endAngle: end,
+        };
+    });
+    const boundary = (r) => {
+        const samples = [...angles, Math.PI / 4].sort((a, b) => a - b);
+        let treadIndex = 0;
+        return samples
+            .filter((angle, index) => !index || Math.abs(angle - samples[index - 1]) > 1e-10)
+            .map((angle) => {
+            const [x, z] = point(r, angle);
+            while (treadIndex < count - 1 && angles[treadIndex + 1] < angle)
+                treadIndex++;
+            const index = treadIndex;
+            const startStation = angleStation(angles[index]), endStation = angleStation(angles[index + 1]);
+            const progress = (angleStation(angle) - startStation) / (endStation - startStation);
+            return [x, ((index + progress) * height) / count, z];
+        });
+    };
+    const walkingLine = boundary(radius);
+    return {
+        treads,
+        footprint: [...rim(outer, 0, Math.PI / 2), ...rim(gap, 0, Math.PI / 2).reverse()],
+        walkingLine,
+        innerBoundary: boundary(gap),
+        outerBoundary: boundary(outer),
+        exit: {
+            position: [sign * (gap + width / 2), height, gap + width / 2],
+            rotation: (sign * Math.PI) / 2,
+        },
+        going: Math.min(...treads.map((tread) => tread.endStation - tread.startStation)),
+        narrowEndGoing: (gap / radius) * Math.min(...treads.map((tread) => tread.endStation - tread.startStation)),
+    };
+}
+/** Polygon prisms share the exact walking footprint; structure stays below its finished top. */
+export function resolveWinderStairConstruction(segment, absoluteHeight = 0, parent) {
+    const layout = resolveStairWinder(segment);
+    if (!layout)
+        return null;
+    const c = segment.construction ?? parent?.construction;
+    const mode = c?.mode ?? (segment.fillToFloor ? 'solid' : 'waist');
+    const finish = c?.finishThickness ?? 0, treadThickness = c?.treadThickness ?? segment.thickness;
+    const gap = segment.winder.innerGap, width = segment.width, radius = gap + segment.winder.walkingLineOffset;
+    const sign = segment.winder.turn === 'left' ? -1 : 1, pivot = sign * (gap + width / 2);
+    const rise = segment.height / segment.stepCount, slope = segment.height / (2 * radius);
+    const waist = (c?.waistThickness ?? segment.thickness) * Math.sqrt(1 + slope * slope) + finish;
+    const parts = 1 +
+        Number(finish > 0) +
+        Number((mode === 'solid' || mode === 'waist') && (c?.nosing ?? 0) > 0) +
+        Number(mode !== 'solid' && mode !== 'waist' && c?.closedRisers) +
+        (mode === 'side-stringers' ? 2 : mode === 'center-stringer' ? 1 : 0);
+    if (segment.stepCount * parts * 2 > 10000)
+        throw new RangeError('Detailed winder construction exceeds the 10,000-surface computation budget. The authored values are preserved.');
+    const pieces = [];
+    const angle = ([x, z]) => Math.atan2(z, sign * (pivot - x));
+    const station = (a) => a <= Math.PI / 4 ? radius * Math.tan(a) : 2 * radius - radius / Math.tan(a);
+    const point = (r, a) => {
+        const scale = r / Math.max(Math.cos(a), Math.sin(a));
+        return [pivot - sign * scale * Math.cos(a), scale * Math.sin(a)];
+    };
+    const polygon = (inner, outer, start, end) => {
+        const rim = (r) => [
+            point(r, start),
+            ...(start < Math.PI / 4 && end > Math.PI / 4 ? [point(r, Math.PI / 4)] : []),
+            point(r, end),
+        ];
+        return [...rim(outer), ...rim(inner).reverse()];
+    };
+    const emit = (role, index, poly, top, bottom, walkingTop = false) => {
+        const n = poly.length / 2;
+        for (let i = 0; i < n - 1; i++) {
+            const ids = [i, i + 1, poly.length - 2 - i, poly.length - 1 - i];
+            const polygon = ids.map((j) => poly[j]);
+            const bottomValues = ids.map((j, k) => typeof bottom === 'number'
+                ? bottom
+                : bottom(poly[j][0] === pivot && poly[j][1] === 0
+                    ? poly[ids[k === 2 ? 1 : k === 3 ? 0 : k]]
+                    : poly[j]));
+            pieces.push({ role, index, polygon, top, bottom: bottomValues, walkingTop });
+        }
+    };
+    for (const [index, tread] of layout.treads.entries()) {
+        const start = tread.startAngle, end = tread.endAngle;
+        const top = tread.elevation - finish;
+        const nosing = c?.nosing ?? 0;
+        const approach = start - Math.atan2(nosing, radius);
+        const full = polygon(gap, gap + width, approach, end);
+        const walkingHeight = (p) => (index + (station(angle(p)) - tread.startStation) / (tread.endStation - tread.startStation)) *
+            rise;
+        const underside = (p) => Math.min(top - 1e-8, walkingHeight(p) - waist);
+        if (mode === 'solid' || mode === 'waist') {
+            emit('body', index, tread.polygon, top, mode === 'solid'
+                ? Math.min(-absoluteHeight, top - (c?.waistThickness ?? segment.thickness))
+                : underside, finish === 0);
+            if (nosing > 0)
+                emit('tread', index, polygon(gap, gap + width, approach, start), top, top - treadThickness);
+        }
+        else {
+            emit('tread', index, full, top, top - treadThickness, finish === 0);
+            if (c?.closedRisers)
+                emit('body', index, polygon(gap, gap + width, start, Math.min(end, start + Math.atan2(c.riserThickness, radius))), top, top - rise);
+        }
+        if (finish > 0)
+            emit('tread', index, full, tread.elevation, top, true);
+        if (mode === 'side-stringers' || mode === 'center-stringer') {
+            const band = c.stringerWidth;
+            const bands = mode === 'side-stringers'
+                ? [
+                    [gap, gap + band],
+                    [gap + width - band, gap + width],
+                ]
+                : [[radius - band / 2, radius + band / 2]];
+            for (const [inner, outer] of bands)
+                emit('body', index, polygon(inner, outer, start, end), top - treadThickness, (p) => Math.min(top - treadThickness - 1e-8, walkingHeight(p) - treadThickness - finish - c.stringerDepth));
+        }
+    }
+    return pieces;
+}
+export function resolveStairWinderFootprint(segment, parent) {
+    const layout = resolveStairWinder(segment);
+    if (!layout)
+        return null;
+    const polygon = layout.footprint.map((point) => [...point]);
+    const nose = (segment.construction ?? parent?.construction)?.nosing ?? 0;
+    if (nose) {
+        const radius = segment.winder.innerGap + segment.winder.walkingLineOffset;
+        polygon[0][1] = (-(segment.winder.innerGap + segment.width) * nose) / radius;
+        polygon[polygon.length - 1][1] = (-segment.winder.innerGap * nose) / radius;
+    }
+    return polygon;
+}

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

@@ -0,0 +1,245 @@
+/**
+ * Wall assemblies — real layered stacks with true thicknesses, plus the
+ * offset-miter geometry that lets the layer boundaries be drawn on the 2D plan
+ * with clean corners.
+ *
+ * ## Where the numbers come from
+ *
+ * Every thickness below is keyed to the 2021 IRC (ASTM C90 for the CMU unit
+ * depth), and each constant carries its citation. Anything not covered by a
+ * standard we can name is marked `unverified` on the preset and surfaced in
+ * the inspector — we do not invent thicknesses.
+ *
+ * This is a drafting aid, not engineering. Values are typical/approximate — verify with the AHJ.
+ *
+ * ## Stack order
+ *
+ * Outside → inside: exterior finish, [air space], sheathing, framing, interior
+ * finish (2021 IRC R703.1 / R703.2 / R703.3).
+ *
+ * The weather-resistive barrier (IRC R703.2) is deliberately NOT a layer: at
+ * about 0.01 in it has no drawable thickness at plan scale, and adding a
+ * symbolic one would make `wall.thickness` disagree with reality. Same for the
+ * vapour retarder.
+ *
+ * ## Which side is exterior
+ *
+ * `wall.frontSide` / `wall.backSide` (schema `wall.ts`). `frontSide` is the
+ * +normal side, where `normal = perp(end - start) = (-dy, dx)/L` — this is the
+ * same convention `resolveWallSurfaceSides` writes with
+ * (`packages/core/src/lib/space-detection.ts:825-872`) and the same "left" side
+ * the miter code offsets by +halfThickness.
+ *
+ *   frontSide === 'exterior' && backSide !== 'exterior'  ->  exterior = +1
+ *   backSide  === 'exterior' && frontSide !== 'exterior' ->  exterior = -1
+ *   otherwise (both interior, both exterior, or unknown) ->  null
+ *
+ * Fallback when it is `null`: the stack is still drawn at its true total
+ * thickness (thickness must never change because a room was not detected), the
+ * exterior face is pinned to the -normal side (face b, the legacy exterior
+ * slot the 3D materials already use), and `exteriorSideResolved` reports the
+ * fallback so callers can say so. A wall with both sides interior
+ * is a PARTITION and should carry a partition assembly — one with neither
+ * `exterior` nor `sheathing`, whose interior finish is then applied to BOTH
+ * faces and no cladding or sheathing is drawn (see `resolveWallAssembly`).
+ */
+import type { WallNode } from '../../schema/index.js';
+import type { Assembly } from '../../schema/assembly.js';
+import { WallAssembly } from '../../schema/nodes/wall.js';
+import { type Point2D, type WallMiterData } from './wall-mitering.js';
+/** 1/2 in gypsum board. 2021 IRC R702.3.5 + Table R702.3.5. */
+export declare const GYPSUM_HALF: number;
+/** 5/8 in gypsum board. 2021 IRC Table R702.3.5. */
+export declare const GYPSUM_FIVE_EIGHTHS: number;
+/** 7/16 in wood structural panel, field default. 2021 IRC Table R602.3(3). */
+export declare const WSP_SHEATHING: number;
+/** 1/2 in glass-mat gypsum sheathing. 2021 IRC R702.3.5 + Table R703.3(1). */
+export declare const GYPSUM_SHEATHING: number;
+/** 2x4 stud, actual 3-1/2 in. 2021 IRC R602.3 / Table R602.3(5). */
+export declare const STUD_2X4: number;
+/** 2x6 stud, actual 5-1/2 in. Same source as STUD_2X4. */
+export declare const STUD_2X6: number;
+/** Vinyl / wood lap siding bounding depth, 3/4 in. 2021 IRC R703.11 / R703.5 + Table R703.3(1). */
+export declare const SIDING_LAP: number;
+/** Fiber cement lap board, 5/16 in board. 2021 IRC R703.10.2 + Table R703.3(1). */
+export declare const FIBER_CEMENT: number;
+/** 3-coat cement plaster, 7/8 in. 2021 IRC R703.7 + Table R702.1(1). */
+export declare const STUCCO_3_COAT: number;
+/** Anchored brick wythe, nominal 4 in = 3-5/8 actual. 2021 IRC R703.8 + Table R703.3(1). */
+export declare const BRICK_VENEER: number;
+/** Nominal 1 in air space behind brick. 2021 IRC Table R703.8.4(1) + R703.8.4.2. */
+export declare const BRICK_AIR_SPACE: number;
+/** Actual depth of a nominal 8 in CMU unit, 7-5/8 in. ASTM C90. */
+export declare const CMU_8_ACTUAL: number;
+/**
+ * 1x3 furring strip laid flat, 3/4 in. UNVERIFIED as an assembly thickness:
+ * the code names 3/4 in vertical furring only as a cladding attachment over
+ * foam (R703.15), not as a CMU furring layer. 3/4 in is the actual thickness
+ * of nominal 1x lumber.
+ */
+export declare const FURRING_1X: number;
+/**
+ * Adhered stone veneer, 2-5/8 in. UNVERIFIED: 2-5/8 in is the maximum unit
+ * thickness for adhered masonry veneer, not a cited assembly value, so any
+ * preset using it is flagged.
+ */
+export declare const STONE_VENEER_UNVERIFIED: number;
+export type WallAssemblyLayerRole = 'exterior-finish' | 'air-gap' | 'sheathing' | 'framing' | 'interior-finish';
+export type WallAssemblyLayer = {
+    role: WallAssemblyLayerRole;
+    /** Human-readable material, used verbatim in the inspector and in poché keys. */
+    material: string;
+    thickness: number;
+    /**
+     * Distance from the EXTERIOR face of the whole stack to this layer's OUTER
+     * boundary. The first layer is always 0; the last layer's
+     * `offsetFromExteriorFace + thickness === total`.
+     */
+    offsetFromExteriorFace: number;
+};
+export type ResolvedWallAssembly = {
+    layers: WallAssemblyLayer[];
+    total: number;
+    /** 'envelope' has cladding/sheathing, 'partition' does not, 'unspecified' = no assembly. */
+    kind: 'envelope' | 'partition' | 'unspecified';
+    /** +1 = exterior on the +normal (front) side, -1 = -normal (back), null = undetermined. */
+    exteriorSide: 1 | -1 | null;
+    /** `exteriorSide` with the -normal (face b) fallback applied. Always a usable sign. */
+    exteriorSideResolved: 1 | -1;
+};
+export type WallAssemblySideSource = Pick<WallNode, 'frontSide' | 'backSide'>;
+/**
+ * Which geometric side of the wall faces outdoors. See the module header for
+ * the rule; `null` means "undetermined", not "interior".
+ */
+export declare function resolveWallExteriorSide(wall: WallAssemblySideSource): 1 | -1 | null;
+/** Whether a stored value is a WS5 `WallAssembly` (the shape #937 wrote) rather than F2. */
+export declare function isLegacyWallAssembly(value: unknown): value is WallAssembly;
+/**
+ * A WS5 `WallAssembly` as F2 layers: exterior →
+ * `finish`, sheathing → `sheathing`, framing → the `core` structure layer,
+ * interior → `lining`, listed from the exterior face (`face: 'exterior'`) so the
+ * stack keeps following the outside when rooms are re-detected. A brick
+ * exterior thicker than one wythe splits into the veneer and its air space,
+ * and a partition carries its interior finish on both faces, as WS5 drew them.
+ * `'none'` slots are dropped; zero-thickness ones are kept (they draw nothing).
+ * The layer sum is the WS5 total, so the wall's `thickness` does not change.
+ */
+export declare function wallAssemblyFromLegacy(legacy: WallAssembly): Assembly;
+/**
+ * The WS5 view of an F2 stack that has one (what `wallAssemblyFromLegacy`
+ * produces), for the inspector's cladding / sheathing / framing / interior
+ * editor and for plugins written against WS5; `null` for any other stack.
+ * Round-trips with `wallAssemblyFromLegacy` without loss.
+ */
+export declare function wallAssemblyToLegacy(assembly: Assembly): WallAssembly | null;
+/** Total thickness of a stack, in metres: THE value `wall.thickness` holds. */
+export declare function assemblyThickness(assembly: Assembly): number;
+/**
+ * Resolve a wall into its ordered layer stack, outside → inside.
+ *
+ * `layers` always sums exactly to `total`, and `total` is what
+ * `wall.thickness` must hold. A wall with no `assembly` resolves to a single
+ * `framing` layer of `wall.thickness` so callers have one code path.
+ */
+export declare function resolveWallAssembly(wall: Pick<WallNode, 'thickness' | 'assembly' | 'frontSide' | 'backSide'>): ResolvedWallAssembly;
+/**
+ * The patch to apply when any layer changes: the assembly plus the re-derived
+ * TOTAL thickness. Callers must never write one without the other.
+ */
+export declare function wallAssemblyPatch(assembly: Assembly): {
+    assembly: Assembly;
+    thickness: number;
+};
+type LegacyWallAssemblyPreset = {
+    id: string;
+    label: string;
+    category: 'exterior' | 'interior' | 'masonry';
+    assembly: WallAssembly;
+    /**
+     * Present when at least one thickness in this preset could not be cited to
+     * a named standard. The inspector shows this verbatim.
+     */
+    unverified?: string;
+};
+export type WallAssemblyPreset = Omit<LegacyWallAssemblyPreset, 'assembly'> & {
+    /** The stack as F2 layers, listed from the exterior face. */
+    assembly: Assembly;
+};
+/** WS5's cited presets, as F2 stacks (`wallAssemblyFromLegacy`). */
+export declare const WALL_ASSEMBLY_PRESETS: readonly WallAssemblyPreset[];
+/**
+ * The catalog material the 3D exterior face is skinned with for each
+ * assembly cladding, when the wall has no painted exterior slot of its own.
+ * This is what makes a wall that SAYS "lap siding" in its assembly LOOK like
+ * lap siding in the viewer, the elevation and the section alike. Stone has
+ * no catalog finish yet and 'none' is bare — both return null (drawn with the
+ * plain wall default). Only `library:` refs, never an invented colour.
+ */
+export declare const WALL_FINISH_LIBRARY_REF: Record<string, string | null>;
+/** The material kind of the wall's outermost cladding (`siding`, `stucco`, …), if it declares one. */
+export declare function wallAssemblyExteriorFinish(wall: Pick<WallNode, 'assembly' | 'frontSide' | 'backSide'>): string | undefined;
+/** The wall's structural core: its depth and framing kind (`wood`, `lgs`, `cmu`, `icf`), if declared. */
+export declare function wallAssemblyFraming(wall: Pick<WallNode, 'assembly'>): {
+    depth: number;
+    kind?: string;
+} | undefined;
+/** `library:` ref for the wall's assembly cladding, or null when it has none. */
+export declare function wallAssemblyFinishRef(wall: Pick<WallNode, 'assembly' | 'frontSide' | 'backSide'>): string | null;
+/** The structural cores that are left bare where nothing covers them: block and cast concrete. */
+export type ExposedStructure = 'cmu' | 'concrete';
+/**
+ * What the wall's exterior face shows when its assembly declares no cladding and no lining over
+ * the core and the core is masonry or concrete: the structure itself, exposed. A foundation wall's
+ * block or cast concrete above grade, and from under the ground, is what it is. `null` for a wall
+ * with a cladding (`wallAssemblyFinishRef` speaks for it), a lining outside the core (a
+ * partition), a framed or foam core (`wood`, `lgs`, `icf`), and a wall whose exterior side is not
+ * yet resolved. The viewer draws it as the generic foundation draws the same structure.
+ */
+export declare function wallAssemblyExposedStructure(wall: Pick<WallNode, 'assembly' | 'frontSide' | 'backSide'>): ExposedStructure | null;
+export declare function getWallAssemblyPreset(id: string | undefined): WallAssemblyPreset | undefined;
+/** True when the wall's assembly came from a preset we could not fully cite. */
+export declare function wallAssemblyUnverifiedNote(wall: Pick<WallNode, 'assembly'>): string | undefined;
+/**
+ * Signed offsets from the wall CENTRELINE of every layer boundary, ordered from
+ * the +normal face inward to the -normal face. Always `layers.length + 1`
+ * entries; the first is `+total/2` and the last is `-total/2`.
+ *
+ * `drawnThickness` lets the 2D plan exaggerate thin walls (the editor scales
+ * wall bodies for legibility) without the layers drifting out of the drawn
+ * footprint: the whole stack is scaled by `drawnThickness / total`.
+ */
+export declare function wallLayerBoundaryOffsets(wall: Pick<WallNode, 'thickness' | 'assembly' | 'frontSide' | 'backSide'>, drawnThickness?: number): number[];
+/** Per-wall, per-junction resolved boundary points, indexed from the +normal face. */
+export type WallLayerMiterData = {
+    /** `wallId -> junctionKey -> points`, indexed from the wall's +normal face. */
+    byWall: Map<string, Map<string, (Point2D | null)[]>>;
+};
+/**
+ * Compute mitered layer-boundary points for every wall on a level.
+ *
+ * `walls` and `miterData` must be the same pair used for the footprint (the
+ * floor plan exaggerates thin walls, so it passes the exaggerated list).
+ * `getOffsets` returns each wall's boundary offsets from its centreline,
+ * descending from +normal — i.e. `wallLayerBoundaryOffsets`.
+ */
+export declare function calculateLevelLayerMiters(walls: readonly WallNode[], miterData: WallMiterData, getOffsets: (wall: WallNode) => number[]): WallLayerMiterData;
+export type WallLayerPolyline = {
+    role: WallAssemblyLayerRole | 'face';
+    /** Index from the +normal face; 0 and `count - 1` are the two outer faces. */
+    index: number;
+    offset: number;
+    start: Point2D;
+    end: Point2D;
+};
+/**
+ * The drawn layer boundary lines for one wall, already mitered at both ends.
+ * Index 0 and the last index are the outer faces (already drawn by the
+ * footprint polygon); callers normally skip them and draw the interior ones.
+ *
+ * `role` names the layer OUTSIDE the boundary (the one nearer the +normal face
+ * for a front-exterior wall), so a boundary can be styled by what it separates.
+ */
+export declare function getWallLayerPolylines(wall: WallNode, layerMiters: WallLayerMiterData, offsets: number[]): WallLayerPolyline[];
+export {};
+//# sourceMappingURL=wall-assembly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-assembly.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-assembly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAiB,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEtD,OAAO,EAAE,KAAK,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAc9E,+DAA+D;AAC/D,eAAO,MAAM,WAAW,QAAc,CAAA;AACtC,oDAAoD;AACpD,eAAO,MAAM,mBAAmB,QAAgB,CAAA;AAChD,8EAA8E;AAC9E,eAAO,MAAM,aAAa,QAAiB,CAAA;AAC3C,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,QAAc,CAAA;AAC3C,oEAAoE;AACpE,eAAO,MAAM,QAAQ,QAAc,CAAA;AACnC,0DAA0D;AAC1D,eAAO,MAAM,QAAQ,QAAc,CAAA;AACnC,mGAAmG;AACnG,eAAO,MAAM,UAAU,QAAe,CAAA;AACtC,mFAAmF;AACnF,eAAO,MAAM,YAAY,QAAiB,CAAA;AAC1C,wEAAwE;AACxE,eAAO,MAAM,aAAa,QAAgB,CAAA;AAC1C,4FAA4F;AAC5F,eAAO,MAAM,YAAY,QAAgB,CAAA;AACzC,oFAAoF;AACpF,eAAO,MAAM,eAAe,QAAc,CAAA;AAC1C,mEAAmE;AACnE,eAAO,MAAM,YAAY,QAAgB,CAAA;AACzC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,QAAe,CAAA;AACtC;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAAgB,CAAA;AAMpD,MAAM,MAAM,qBAAqB,GAC7B,iBAAiB,GACjB,SAAS,GACT,WAAW,GACX,SAAS,GACT,iBAAiB,CAAA;AAErB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,qBAAqB,CAAA;IAC3B,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,4FAA4F;IAC5F,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,aAAa,CAAA;IAC9C,2FAA2F;IAC3F,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAA;IAC3B,uFAAuF;IACvF,oBAAoB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,UAAU,CAAC,CAAA;AAE7E;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,sBAAsB,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAMnF;AAoBD,4FAA4F;AAC5F,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAI1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,GAAG,QAAQ,CAqDrE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,IAAI,CA4E5E;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE5D;AA4ED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC,GACxE,oBAAoB,CAuCtB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG;IACrD,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB,CAEA;AAMD,KAAK,wBAAwB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC7C,QAAQ,EAAE,YAAY,CAAA;IACtB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAiHD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,wBAAwB,EAAE,UAAU,CAAC,GAAG;IAC5E,6DAA6D;IAC7D,QAAQ,EAAE,QAAQ,CAAA;CACnB,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,EAAE,SAAS,kBAAkB,EAI1D,CAAA;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAOjE,CAAA;AAED,sGAAsG;AACtG,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC,GAC1D,MAAM,GAAG,SAAS,CAEpB;AAED,yGAAyG;AACzG,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAC/B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAI9C;AAED,iFAAiF;AACjF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC,GAC1D,MAAM,GAAG,IAAI,CAIf;AAED,kGAAkG;AAClG,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,UAAU,CAAA;AAEjD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC,GAC1D,gBAAgB,GAAG,IAAI,CAUzB;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,kBAAkB,GAAG,SAAS,CAG5F;AAED,gFAAgF;AAChF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAAG,MAAM,GAAG,SAAS,CAE/F;AAMD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,CAAC,EACzE,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,EAAE,CAcV;AA6DD,sFAAsF;AACtF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+EAA+E;IAC/E,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;CACrD,CAAA;AAcD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,MAAM,EAAE,GACvC,kBAAkB,CAgKpB;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAAA;IACpC,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,OAAO,CAAA;IACd,GAAG,EAAE,OAAO,CAAA;CACb,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,WAAW,EAAE,kBAAkB,EAC/B,OAAO,EAAE,MAAM,EAAE,GAChB,iBAAiB,EAAE,CAmCrB"}