@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,314 @@
+import { measureStairDetail, STAIR_DETAIL_SURFACE_BUDGET, stairSegmentDetailError, } from './stair-detail-budget.js';
+import { resolveStairArcDimensions } from './stair-layout.js';
+import { resolveStairWinder } from './stair-winder.js';
+export function resolveStairConstruction(node, parent) {
+    return node.construction ?? parent?.construction ?? null;
+}
+export function stairConstructionError(stair, segments) {
+    if (stair.stairType !== 'straight') {
+        if (!stair.construction)
+            return null;
+        const dimensions = resolveStairArcDimensions(stair, 0);
+        if (!(dimensions.going > 0))
+            return 'Explicit arc construction requires a positive going.';
+        if (Math.abs(dimensions.stepSweep) > Math.PI * 2)
+            return 'One tread spans more than one turn; add risers or reduce the sweep.';
+        return stairSegmentConstructionError({
+            segmentType: 'stair',
+            construction: stair.construction,
+            width: dimensions.width,
+            length: dimensions.going * dimensions.stepCount,
+            stepCount: dimensions.stepCount,
+        });
+    }
+    const flights = segments.length
+        ? segments
+        : [
+            {
+                segmentType: 'stair',
+                width: stair.width,
+                length: 3,
+                stepCount: Math.max(2, Math.round(stair.stepCount)),
+                construction: undefined,
+            },
+        ];
+    for (const segment of flights) {
+        const error = stairSegmentConstructionError(segment, stair);
+        if (error)
+            return error;
+    }
+    return null;
+}
+export function stairSegmentConstructionError(segment, parent) {
+    let winder = null;
+    try {
+        winder = segment.winder ? resolveStairWinder({ ...segment, height: segment.height ?? 1 }) : null;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    const construction = resolveStairConstruction(segment, parent);
+    if (winder &&
+        2 * straightStairConstructionDetailCost(segment, parent) > STAIR_DETAIL_SURFACE_BUDGET)
+        return 'Detailed winder construction exceeds the 10,000-surface computation budget. The authored values are preserved.';
+    if (!construction || segment.segmentType === 'landing')
+        return null;
+    if (construction.mode !== 'solid' &&
+        construction.mode !== 'waist' &&
+        construction.closedRisers &&
+        construction.riserThickness > (winder?.going ?? segment.length / segment.stepCount))
+        return 'Riser panels must fit within their treads.';
+    if ((construction.mode === 'side-stringers' && construction.stringerWidth * 2 > segment.width) ||
+        (construction.mode === 'center-stringer' && construction.stringerWidth > segment.width))
+        return 'Stringers must fit within the flight width.';
+    if (winder &&
+        construction.mode === 'center-stringer' &&
+        (segment.winder.walkingLineOffset < construction.stringerWidth / 2 ||
+            segment.winder.walkingLineOffset + construction.stringerWidth / 2 > segment.width))
+        return 'The center stringer must fit around the walking line within the winder width.';
+    if (winder && construction.nosing >= segment.winder.innerGap + segment.winder.walkingLineOffset)
+        return 'Winder nosing must be smaller than the walking-line radius.';
+    return null;
+}
+/** Bodies and finishes sit below the finished walking heights; nosing projects toward the approach. */
+export function resolveStraightStairConstruction(segment, absoluteHeight = 0, parent) {
+    const construction = resolveStairConstruction(segment, parent);
+    if (!construction)
+        return null;
+    const error = stairSegmentDetailError(segment) ?? stairSegmentConstructionError(segment, parent);
+    if (error)
+        throw new RangeError(error);
+    if (straightStairConstructionDetailCost(segment, parent) > STAIR_DETAIL_SURFACE_BUDGET)
+        throw new RangeError('Detailed stair construction exceeds the 10,000-surface computation budget. The authored values are preserved.');
+    const { mode, treadThickness, finishThickness, nosing, riserThickness, closedRisers } = construction;
+    const landing = segment.segmentType === 'landing';
+    const count = landing ? 1 : segment.stepCount;
+    const going = segment.length / count;
+    const riser = landing ? 0 : segment.height / count;
+    const slope = landing ? 0 : segment.height / segment.length;
+    const firstStructureTop = (landing ? 0 : riser) - finishThickness;
+    const solidBase = firstStructureTop > -absoluteHeight
+        ? -absoluteHeight
+        : firstStructureTop - construction.waistThickness;
+    const waistOffset = construction.waistThickness * Math.sqrt(1 + slope * slope) + finishThickness;
+    const pieces = [];
+    const box = (role, index, x0, x1, z0, z1, bottom, top) => {
+        if (!(top > bottom && x1 > x0 && z1 > z0))
+            return;
+        pieces.push({
+            role,
+            index,
+            x0,
+            x1,
+            z0,
+            z1,
+            underside: [0, bottom],
+            top,
+            profile: [
+                [z0, bottom],
+                [z1, bottom],
+                [z1, top],
+                [z0, top],
+            ],
+        });
+    };
+    const x0 = -segment.width / 2, x1 = segment.width / 2;
+    for (let index = 0; index < count; index++) {
+        const z0 = index * going, z1 = (index + 1) * going;
+        const top = landing ? 0 : (index + 1) * riser;
+        const structureTop = top - finishThickness;
+        const projection = landing ? 0 : nosing;
+        if (mode === 'solid' || mode === 'waist') {
+            const underside = mode === 'solid'
+                ? [
+                    0,
+                    landing
+                        ? -Math.max(absoluteHeight, construction.waistThickness + finishThickness)
+                        : solidBase,
+                ]
+                : [slope, -waistOffset];
+            const lower = (z) => underside[0] * z + underside[1];
+            const profile = [
+                [z0, structureTop],
+                [z1, structureTop],
+                [z1, lower(z1)],
+                [z0, lower(z0)],
+            ];
+            pieces.push({
+                role: 'body',
+                walkingTop: finishThickness === 0,
+                index,
+                x0,
+                x1,
+                z0,
+                z1,
+                underside,
+                top: structureTop,
+                profile,
+            });
+            if (projection > 0)
+                box('tread', index, x0, x1, z0 - projection, z0, structureTop - treadThickness, structureTop);
+        }
+        else {
+            box('tread', index, x0, x1, z0 - projection, z1, structureTop - treadThickness, structureTop);
+            if (closedRisers && !landing)
+                box('body', index, x0, x1, z0, Math.min(z1, z0 + riserThickness), top - riser - finishThickness, structureTop);
+        }
+        if (finishThickness > 0)
+            box('tread', index, x0, x1, z0 - projection, z1, structureTop, top);
+    }
+    if (!landing && (mode === 'side-stringers' || mode === 'center-stringer')) {
+        const width = construction.stringerWidth;
+        const bands = mode === 'side-stringers'
+            ? [
+                [x0, x0 + width],
+                [x1 - width, x1],
+            ]
+            : [[-width / 2, width / 2]];
+        const upperOffset = treadThickness + finishThickness;
+        const lowerOffset = upperOffset + construction.stringerDepth;
+        for (const [left, right] of bands)
+            for (let index = 0; index < count; index++) {
+                const z0 = index * going, z1 = (index + 1) * going;
+                const top = (index + 1) * riser - upperOffset;
+                pieces.push({
+                    role: 'body',
+                    index,
+                    x0: left,
+                    x1: right,
+                    z0,
+                    z1,
+                    underside: [slope, -lowerOffset],
+                    top,
+                    profile: [
+                        [z0, top],
+                        [z1, top],
+                        [z1, slope * z1 - lowerOffset],
+                        [z0, slope * z0 - lowerOffset],
+                    ],
+                });
+            }
+    }
+    return pieces;
+}
+/** One flat tread projects onto at most one circle, even if its authored travel wraps farther. */
+export function stairArcSliceCount(innerRadius, outerRadius, sweep) {
+    return Math.max(4, Math.min(24, Math.ceil(Math.min(Math.abs(sweep), Math.PI * 2) / (Math.PI / 18) +
+        Math.max(0, (outerRadius - innerRadius) * 3))));
+}
+export function resolveArcStairConstruction(stair, totalRise) {
+    const construction = stair.construction;
+    if (!construction)
+        return null;
+    const error = measureStairDetail(stair, []).error;
+    if (error)
+        throw new RangeError(error);
+    const dimensions = resolveStairArcDimensions(stair, totalRise);
+    const { innerRadius, outerRadius, walkingRadius, stepCount, stepSweep, sweepAngle, riserHeight, landingSweep, } = dimensions;
+    const { mode, treadThickness, finishThickness, nosing, riserThickness, closedRisers } = construction;
+    const direction = Math.sign(stepSweep) || 1;
+    const slope = totalRise / Math.max(Math.abs(sweepAngle) * walkingRadius, Number.EPSILON);
+    const waistOffset = construction.waistThickness * Math.sqrt(1 + slope * slope) + finishThickness;
+    const solidBase = riserHeight - finishThickness > 0
+        ? 0
+        : riserHeight - finishThickness - construction.waistThickness;
+    const pieces = [];
+    const piece = (role, index, inner, outer, start, end, bottomStart, bottomEnd, top) => {
+        if (!(outer > inner && top > Math.max(bottomStart, bottomEnd) && Math.abs(end - start) > 0))
+            return;
+        pieces.push({
+            role,
+            index,
+            innerRadius: inner,
+            outerRadius: outer,
+            startAngle: start,
+            endAngle: end,
+            bottomStart,
+            bottomEnd,
+            top,
+        });
+    };
+    for (let index = 0; index < stepCount; index++) {
+        const start = -sweepAngle / 2 + index * stepSweep, end = start + stepSweep;
+        const top = (index + 1) * riserHeight, structureTop = top - finishThickness;
+        const approach = start - (direction * nosing) / walkingRadius;
+        if (mode === 'solid' || mode === 'waist') {
+            piece(finishThickness ? 'body' : 'mixed', index, innerRadius, outerRadius, start, end, mode === 'solid' ? solidBase : index * riserHeight - waistOffset, mode === 'solid' ? solidBase : top - waistOffset, structureTop);
+            if (nosing > 0)
+                piece('tread', index, innerRadius, outerRadius, approach, start, structureTop - treadThickness, structureTop - treadThickness, structureTop);
+        }
+        else {
+            piece('tread', index, innerRadius, outerRadius, approach, end, structureTop - treadThickness, structureTop - treadThickness, structureTop);
+            if (closedRisers)
+                piece('body', index, innerRadius, outerRadius, start, start + (direction * riserThickness) / walkingRadius, top - riserHeight - finishThickness, top - riserHeight - finishThickness, structureTop);
+        }
+        if (finishThickness > 0)
+            piece('tread', index, innerRadius, outerRadius, approach, end, structureTop, structureTop, top);
+        if (mode === 'side-stringers' || mode === 'center-stringer') {
+            const width = construction.stringerWidth;
+            const bands = mode === 'side-stringers'
+                ? [
+                    [innerRadius, innerRadius + width],
+                    [outerRadius - width, outerRadius],
+                ]
+                : [[walkingRadius - width / 2, walkingRadius + width / 2]];
+            const upperOffset = treadThickness + finishThickness;
+            const lowerOffset = upperOffset + construction.stringerDepth;
+            for (const [inner, outer] of bands)
+                piece('body', index, inner, outer, start, end, index * riserHeight - lowerOffset, top - lowerOffset, top - upperOffset);
+        }
+    }
+    if (landingSweep) {
+        const top = totalRise, structureTop = top - finishThickness;
+        const thickness = mode === 'solid' || mode === 'waist' ? construction.waistThickness : treadThickness;
+        piece(finishThickness ? 'body' : mode === 'solid' || mode === 'waist' ? 'mixed' : 'tread', stepCount, innerRadius, outerRadius, sweepAngle / 2, sweepAngle / 2 + landingSweep, structureTop - thickness, structureTop - thickness, structureTop);
+        if (finishThickness > 0)
+            piece('tread', stepCount, innerRadius, outerRadius, sweepAngle / 2, sweepAngle / 2 + landingSweep, structureTop, structureTop, top);
+    }
+    return pieces;
+}
+export function straightStairConstructionDetailCost(segment, parent) {
+    const construction = resolveStairConstruction(segment, parent);
+    const count = segment.segmentType === 'landing' ? 1 : segment.stepCount;
+    if (!construction)
+        return count;
+    if (segment.segmentType === 'landing')
+        return 1 + Number(construction.finishThickness > 0);
+    const closed = construction.mode === 'solid' || construction.mode === 'waist';
+    const parts = 1 +
+        Number(closed && construction.nosing > 0) +
+        Number(construction.finishThickness > 0) +
+        Number(!closed && construction.closedRisers) +
+        (construction.mode === 'side-stringers' ? 2 : construction.mode === 'center-stringer' ? 1 : 0);
+    return count * parts;
+}
+export function arcStairConstructionDetailCost(stair) {
+    const dimensions = resolveStairArcDimensions(stair, 0);
+    const { stepCount, innerRadius, outerRadius, walkingRadius, stepSweep, landingSweep } = dimensions;
+    const construction = stair.construction;
+    if (!construction)
+        return stepCount + Number(landingSweep !== 0);
+    const { mode, nosing, finishThickness, closedRisers, riserThickness, stringerWidth } = construction;
+    const slices = (inner, outer, sweep) => 2 * stairArcSliceCount(inner, outer, sweep);
+    const closed = mode === 'solid' || mode === 'waist';
+    let parts = slices(innerRadius, outerRadius, stepSweep + (Math.sign(stepSweep || 1) * nosing) / walkingRadius);
+    if (closed) {
+        parts = slices(innerRadius, outerRadius, stepSweep);
+        if (nosing > 0)
+            parts += slices(innerRadius, outerRadius, nosing / walkingRadius);
+    }
+    else if (closedRisers)
+        parts += slices(innerRadius, outerRadius, riserThickness / walkingRadius);
+    if (finishThickness > 0)
+        parts += slices(innerRadius, outerRadius, stepSweep + (Math.sign(stepSweep || 1) * nosing) / walkingRadius);
+    if (mode === 'side-stringers')
+        parts +=
+            slices(innerRadius, innerRadius + stringerWidth, stepSweep) +
+                slices(outerRadius - stringerWidth, outerRadius, stepSweep);
+    else if (mode === 'center-stringer')
+        parts += slices(walkingRadius - stringerWidth / 2, walkingRadius + stringerWidth / 2, stepSweep);
+    return (stepCount * parts +
+        (landingSweep
+            ? slices(innerRadius, outerRadius, landingSweep) * (1 + Number(finishThickness > 0))
+            : 0));
+}

package/dist/systems/stair/stair-detail-budget.d.ts

@@ -0,0 +1,13 @@
+import type { StairNode, StairSegmentNode } from '../../schema/index.js';
+export declare const STAIR_DETAIL_SURFACE_BUDGET = 10000;
+export declare function stairSegmentDetailError(segment: Pick<StairSegmentNode, 'segmentType' | 'stepCount'>): string | null;
+export declare function measureStairDetail(stair: StairNode, segments: readonly StairSegmentNode[]): {
+    status: 'unresolved';
+    error: string;
+    budget: number;
+} | {
+    status: 'evaluated';
+    error: null;
+    budget: number;
+};
+//# sourceMappingURL=stair-detail-budget.d.ts.map

package/dist/systems/stair/stair-detail-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-detail-budget.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-detail-budget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAQ/D,eAAO,MAAM,2BAA2B,QAAS,CAAA;AAEjD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,aAAa,GAAG,WAAW,CAAC,GAC3D,MAAM,GAAG,IAAI,CAOf;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,gBAAgB,EAAE;YAwB5E,YAAY;;;;YAqCP,WAAW;;;EAC7B"}

package/dist/systems/stair/stair-detail-budget.js

@@ -0,0 +1,64 @@
+import { arcStairConstructionDetailCost, stairConstructionError, straightStairConstructionDetailCost, } from './stair-construction.js';
+import { stairRailComplexity } from './stair-rail-budget.js';
+export const STAIR_DETAIL_SURFACE_BUDGET = 10_000;
+export function stairSegmentDetailError(segment) {
+    if (segment.segmentType === 'landing')
+        return null;
+    if (!Number.isSafeInteger(segment.stepCount) || segment.stepCount < 1)
+        return 'Detailed stair geometry requires a positive whole riser count.';
+    if (segment.stepCount > STAIR_DETAIL_SURFACE_BUDGET)
+        return `Detailed stair geometry exceeds the ${STAIR_DETAIL_SURFACE_BUDGET.toLocaleString('en-US')}-surface computation budget. The authored count is preserved.`;
+    return null;
+}
+export function measureStairDetail(stair, segments) {
+    const railWidth = stair.stairType === 'straight' && segments.length
+        ? Math.min(...segments
+            .filter((segment) => segment.visible !== false)
+            .map((segment) => segment.width))
+        : stair.width;
+    const railError = stair.handrail &&
+        stair.handrail.mode !== 'none' &&
+        stair.handrail.offset + stair.handrail.diameter / 2 > railWidth
+        ? 'The handrail inset and radius must fit within the stair width.'
+        : (stair.railingPath === 'continuous' ||
+            stair.railingStyle === 'glass' ||
+            stair.railingStyle === 'metal') &&
+            stair.railingMode !== 'none' &&
+            !(stair.railingHeight > 0)
+            ? 'Guard height must be positive.'
+            : null;
+    const constructionError = railError ?? stairConstructionError(stair, segments);
+    if (constructionError)
+        return {
+            status: 'unresolved',
+            error: constructionError,
+            budget: STAIR_DETAIL_SURFACE_BUDGET,
+        };
+    const counts = stair.stairType !== 'straight' || !segments.length
+        ? [{ segmentType: 'stair', stepCount: stair.stepCount, construction: undefined }]
+        : segments;
+    for (const segment of counts) {
+        const error = stairSegmentDetailError(segment);
+        if (error)
+            return { status: 'unresolved', error, budget: STAIR_DETAIL_SURFACE_BUDGET };
+    }
+    const surfaces = stair.stairType !== 'straight'
+        ? arcStairConstructionDetailCost(stair)
+        : counts.reduce((sum, segment) => sum +
+            straightStairConstructionDetailCost(segment, stair) *
+                ('winder' in segment && segment.winder ? 2 : 1), 0);
+    if (surfaces > STAIR_DETAIL_SURFACE_BUDGET)
+        return {
+            status: 'unresolved',
+            error: `Detailed stair geometry exceeds the ${STAIR_DETAIL_SURFACE_BUDGET.toLocaleString('en-US')}-surface computation budget. The authored counts are preserved.`,
+            budget: STAIR_DETAIL_SURFACE_BUDGET,
+        };
+    const railWork = stairRailComplexity(stair, segments);
+    if (!Number.isFinite(railWork) || railWork > STAIR_DETAIL_SURFACE_BUDGET)
+        return {
+            status: 'unresolved',
+            error: 'Detailed stair rails exceed the 10,000-unit computation budget. The authored dimensions are preserved.',
+            budget: STAIR_DETAIL_SURFACE_BUDGET,
+        };
+    return { status: 'evaluated', error: null, budget: STAIR_DETAIL_SURFACE_BUDGET };
+}

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

@@ -1,6 +1,6 @@
 import type { AnyNode, StairNode } from '../../schema/index.js';
-import { StairSegmentNode } from '../../schema/index.js';
-export type StairFlightOverrides = Partial<Pick<StairSegmentNode, 'width' | 'length' | 'height' | 'stepCount' | 'attachmentSide' | 'fillToFloor' | 'thickness'>>;
+import { StairSegmentNode } from '../../schema/nodes/stair-segment.js';
+export type StairFlightOverrides = Partial<Pick<StairSegmentNode, 'width' | 'length' | 'height' | 'stepCount' | 'attachmentSide' | 'fillToFloor' | 'thickness' | 'construction'>>;
 /**
  * The single definition of a default straight flight. Anything left out falls
  * through to the `StairSegmentNode` schema defaults (length 3 m, 10 steps,

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

@@ -1 +1 @@
-{"version":3,"file":"stair-flight.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-flight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAM/C,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,IAAI,CACF,gBAAgB,EAChB,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,gBAAgB,GAAG,aAAa,GAAG,WAAW,CAC7F,CACF,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,GAAE,oBAAyB,GAAG,gBAAgB,CAEhG;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,gBAAgB,CAQlB"}
+{"version":3,"file":"stair-flight.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-flight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAMnE,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,IAAI,CACF,gBAAgB,EACd,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,gBAAgB,GAChB,aAAa,GACb,WAAW,GACX,cAAc,CACjB,CACF,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,GAAE,oBAAyB,GAAG,gBAAgB,CAEhG;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,gBAAgB,CASlB"}

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

@@ -1,6 +1,6 @@
-import { StairSegmentNode } from '../../schema/index.js';
-import { resolveStairTotalRise } from './stair-rise.js';
-const MIN_STAIR_FLIGHT_RISE = 0.1;
+import { StairSegmentNode } from '../../schema/nodes/stair-segment.js';
+import { resolveStairTotalRise } from './stair-rise-query.js';
+const MIN_STAIR_FLIGHT_RISE = 0.001;
 const MIN_STAIR_FLIGHT_STEP_COUNT = 2;
 /**
  * The single definition of a default straight flight. Anything left out falls
@@ -23,5 +23,6 @@ export function createStairFlightFromStair(stair, nodes) {
         stepCount: Math.max(MIN_STAIR_FLIGHT_STEP_COUNT, Math.round(stair.stepCount ?? 10)),
         thickness: stair.thickness,
         fillToFloor: stair.fillToFloor,
+        construction: stair.construction,
     });
 }

package/dist/systems/stair/stair-floor-footprints.d.ts

@@ -0,0 +1,7 @@
+import type { FloorPlacedFootprint } from '../../registry/types.js';
+import type { AnyNode, AnyNodeId, StairNode, StairSegmentNode } from '../../schema/index.js';
+import { computeSegmentTransforms } from './stair-footprint.js';
+export declare function getStairFloorPlacedFootprints(stair: StairNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): FloorPlacedFootprint[];
+export declare function getStairSegmentFloorPlacedFootprints(stair: StairNode, segments: readonly StairSegmentNode[]): FloorPlacedFootprint[];
+export declare const computeStairSegmentFloorStackTransforms: typeof computeSegmentTransforms;
+//# sourceMappingURL=stair-floor-footprints.d.ts.map

package/dist/systems/stair/stair-floor-footprints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-floor-footprints.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-floor-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEnF,OAAO,EAAE,wBAAwB,EAAY,MAAM,mBAAmB,CAAA;AAItE,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,oBAAoB,EAAE,CAUxB;AA6DD,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,oBAAoB,EAAE,CA2ExB;AAED,eAAO,MAAM,uCAAuC,iCAA2B,CAAA"}

package/dist/systems/stair/stair-floor-footprints.js

@@ -0,0 +1,113 @@
+import { resolveStairConstruction } from './stair-construction.js';
+import { computeSegmentTransforms, rotateXZ } from './stair-footprint.js';
+import { resolveStairArcDimensions } from './stair-layout.js';
+import { resolveStairWinder } from './stair-winder.js';
+export function getStairFloorPlacedFootprints(stair, nodes) {
+    if ((stair.stairType ?? 'straight') !== 'straight') {
+        return getArcStairFloorPlacedFootprints(stair);
+    }
+    const segments = (stair.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((node) => node?.type === 'stair-segment');
+    return getStairSegmentFloorPlacedFootprints(stair, segments);
+}
+const MAX_ARC_FOOTPRINT_SWEEP = Math.PI / 12;
+function getArcStairFloorPlacedFootprints(stair) {
+    const isSpiral = stair.stairType === 'spiral';
+    const layout = resolveStairArcDimensions(stair, 0);
+    const { innerRadius, outerRadius } = layout;
+    const sweepAngle = Math.sign(layout.sweepAngle || 1) *
+        Math.min(Math.abs(layout.sweepAngle + layout.nosingSweep), Math.PI * 2);
+    const footprints = [];
+    const ranges = [
+        { start: -layout.sweepAngle / 2 - layout.nosingSweep, sweep: sweepAngle },
+        ...(layout.landingSweep ? [{ start: layout.sweepAngle / 2, sweep: layout.landingSweep }] : []),
+    ];
+    for (const range of ranges) {
+        const sliceCount = Math.max(1, Math.ceil(Math.abs(range.sweep) / MAX_ARC_FOOTPRINT_SWEEP));
+        for (let index = 0; index < sliceCount; index += 1) {
+            const startAngle = range.start + (range.sweep * index) / sliceCount;
+            const endAngle = range.start + (range.sweep * (index + 1)) / sliceCount;
+            const midAngle = (startAngle + endAngle) / 2;
+            const halfSweep = Math.abs(endAngle - startAngle) / 2;
+            const projectedInnerRadius = innerRadius * Math.cos(halfSweep);
+            const radialSize = outerRadius - projectedInnerRadius;
+            const tangentialSize = 2 * outerRadius * Math.sin(halfSweep);
+            const centerRadius = (outerRadius + projectedInnerRadius) / 2;
+            const [offsetX, offsetZ] = rotateXZ(Math.cos(midAngle) * centerRadius, Math.sin(midAngle) * centerRadius, stair.rotation ?? 0);
+            footprints.push({
+                position: [stair.position[0] + offsetX, stair.position[1], stair.position[2] + offsetZ],
+                dimensions: [
+                    Math.max(radialSize, Number.EPSILON),
+                    0.01,
+                    Math.max(tangentialSize, Number.EPSILON),
+                ],
+                rotation: [0, midAngle - (stair.rotation ?? 0), 0],
+            });
+        }
+    }
+    if (isSpiral && (stair.showCenterColumn ?? true)) {
+        const columnRadius = Math.min(innerRadius * 0.72, Math.max(innerRadius - 0.03, innerRadius * 0.5));
+        footprints.push({
+            position: stair.position,
+            dimensions: [columnRadius * 2, 0.01, columnRadius * 2],
+            rotation: [0, 0, 0],
+        });
+    }
+    return footprints;
+}
+export function getStairSegmentFloorPlacedFootprints(stair, segments) {
+    const transforms = computeStairSegmentFloorStackTransforms(segments);
+    return segments.flatMap((segment, index) => {
+        const transform = transforms[index];
+        const winder = resolveStairWinder(segment);
+        if (winder) {
+            // Two rectangular legs exactly cover the square ring without filling its inner gap.
+            const gap = segment.winder.innerGap, width = segment.width, sign = segment.winder.turn === 'left' ? -1 : 1;
+            const pivot = sign * (gap + width / 2);
+            const nose = ((resolveStairConstruction(segment, stair)?.nosing ?? 0) * (gap + width)) /
+                (gap + segment.winder.walkingLineOffset);
+            return [
+                [pivot - sign * (gap + width / 2), (gap + width - nose) / 2, width, gap + width + nose],
+                [pivot - (sign * gap) / 2, gap + width / 2, gap, width],
+            ]
+                .filter((rect) => rect[2] > 0)
+                .map(([x, z, w, d]) => {
+                const [sx, sz] = rotateXZ(x, z, transform.rotation);
+                const [wx, wz] = rotateXZ(transform.position[0] + sx, transform.position[2] + sz, stair.rotation);
+                return {
+                    position: [
+                        stair.position[0] + wx,
+                        stair.position[1] + transform.position[1],
+                        stair.position[2] + wz,
+                    ],
+                    dimensions: [w, Math.max(segment.height, segment.thickness, 0.01), d],
+                    rotation: [0, stair.rotation + transform.rotation, 0],
+                };
+            });
+        }
+        const nose = segment.segmentType === 'landing'
+            ? 0
+            : (resolveStairConstruction(segment, stair)?.nosing ?? 0);
+        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, (segment.length - nose) / 2, transform.rotation);
+        const centerInGroupX = transform.position[0] + centerOffsetX;
+        const centerInGroupZ = transform.position[2] + centerOffsetZ;
+        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stair.rotation ?? 0);
+        return [
+            {
+                position: [
+                    stair.position[0] + centerOffsetWorldX,
+                    stair.position[1] + transform.position[1],
+                    stair.position[2] + centerOffsetWorldZ,
+                ],
+                dimensions: [
+                    segment.width,
+                    Math.max(segment.height, segment.thickness, 0.01),
+                    segment.length + nose,
+                ],
+                rotation: [0, (stair.rotation ?? 0) + transform.rotation, 0],
+            },
+        ];
+    });
+}
+export const computeStairSegmentFloorStackTransforms = computeSegmentTransforms;

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

@@ -32,7 +32,13 @@ export declare function rotateXZ(x: number, z: number, angle: number): [number,
  * the chain ±90° (left / right) or continues straight (front). Positions are in
  * the stair's local frame (before the stair's own `position` / `rotation`).
  */
-export declare function computeSegmentTransforms(segments: StairSegmentNode[]): SegmentTransform[];
+export declare function computeSegmentTransforms(segments: readonly (Pick<StairSegmentNode, 'width' | 'length' | 'height' | 'attachmentSide'> & Partial<Pick<StairSegmentNode, 'stepCount' | 'winder'>>)[]): SegmentTransform[];
+/**
+ * The plan outline of each visible segment of a straight stair's chain (a flight with its nosing, a
+ * landing, a winder's own outline), in the stair's level frame: an L or U stair covers these, not
+ * its bounding box.
+ */
+export declare function stairSegmentFootprints(stair: StairNode, nodes: Readonly<Record<string, AnyNode>>): [number, number][][];
 /**
  * XZ bounding box of a stair's plan footprint, or null when it can't be
  * determined (a straight stair whose segment children aren't in `nodes`).
@@ -40,5 +46,7 @@ export declare function computeSegmentTransforms(segments: StairSegmentNode[]):
  * stairs are derived from the parent alone, so `nodes` is optional for them.
  */
 export declare function stairFootprintAABB(stair: StairNode, nodes?: Readonly<Record<string, AnyNode>>): StairFootprintAABB | null;
+export declare function stairArrivalOpening(stair: StairNode, nodes: Readonly<Record<string, AnyNode>>): [number, number][];
+export declare function stairDeckLevelId(nodes: Readonly<Record<string, AnyNode>>, node?: AnyNode): string | undefined;
 export {};
 //# sourceMappingURL=stair-footprint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stair-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEnF;;;;;;;;;GASG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3F,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI9E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,CAkDzF;AAwHD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,kBAAkB,GAAG,IAAI,CAK3B"}
+{"version":3,"file":"stair-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAKnF;;;;;;;;;GASG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3F,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI9E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,CAAC,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,gBAAgB,CAAC,GAC1F,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,GAC3D,gBAAgB,EAAE,CA0DpB;AA6BD;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,CAiCtB;AAqDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,kBAAkB,GAAG,IAAI,CAK3B;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CA4CpB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,CAAC,EAAE,OAAO,GACb,MAAM,GAAG,SAAS,CAKpB"}