@pascal-app/core 1.0.5 → 1.0.7

package/dist/lib/absorb-wall-separators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"absorb-wall-separators.d.ts","sourceRoot":"","sources":["../../src/lib/absorb-wall-separators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmE5F"}
+{"version":3,"file":"absorb-wall-separators.d.ts","sourceRoot":"","sources":["../../src/lib/absorb-wall-separators.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAE/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmE5F"}

package/dist/lib/beam.d.ts

@@ -0,0 +1,137 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import { type BeamMaterial, BeamNode, type BeamPlacement, type BeamSizePreset, type BeamSizePresetId } from '../schema/nodes/beam.js';
+type Nodes = Record<AnyNodeId, AnyNode>;
+type P = [number, number];
+/**
+ * The stock size with this id or label (`BEAM_SIZE_PRESETS`): '(2)2x10' and '(2) 2x10' are both
+ * the two-ply 2x10.
+ */
+export declare function beamSizePreset(idOrLabel: string): BeamSizePreset | undefined;
+/**
+ * The stock size a beam is, if it is one: as many plies of the same nominal size (when it names
+ * one), the same section, and a material that size comes in.
+ */
+export declare function matchBeamSizePreset(beam: Pick<BeamNode, 'width' | 'depth' | 'plies' | 'material'> & {
+    size?: string;
+}): BeamSizePreset | null;
+/**
+ * A length in inches and sixteenths, as a framing size prints it: 3.5 in reads "3-1/2", 0.75 in
+ * "3/4", 9 in "9".
+ */
+export declare function inchFractionLabel(metres: number, denominator?: number): string;
+/** What each material is called in a list or a panel. */
+export declare const BEAM_MATERIAL_LABELS: Record<BeamMaterial, string>;
+/**
+ * How each material looks, from the material library: fir for sawn lumber, a weathered grey-brown
+ * for treated, the pale veneer of an LVL, the warm laminations of a glulam, steel.
+ */
+export declare const BEAM_MATERIAL_LIBRARY_REFS: Record<BeamMaterial, string>;
+/**
+ * A beam's size as a framing plan prints it: "6x8", "(2) 2x10", "6x8 PT", "1-3/4x11-7/8 LVL",
+ * "W8x10"; a section that is no stock size by its actual inches ("3-1/2x9-1/4").
+ */
+export declare function beamSizeLabel(beam: Pick<BeamNode, 'width' | 'depth' | 'plies' | 'material'> & {
+    size?: string;
+}): string;
+/**
+ * The fields that make a beam a stock size. Sawn sizes keep a treated beam treated; any other
+ * size brings its own material.
+ */
+export declare function beamSizePresetPatch(beam: Pick<BeamNode, 'material'>, presetId: string): Partial<BeamNode>;
+/** What `createBeam` builds a beam from. */
+export type BeamInput = {
+    /** The centreline, level-local plan points `[x, z]`. */
+    start: readonly [number, number];
+    end: readonly [number, number];
+    /**
+     * A stock size by id or label (`BEAM_SIZE_PRESETS`), a 6x8 by default (an unknown one too).
+     * Ignored when `width` and `depth` are given.
+     */
+    preset?: BeamSizePresetId | (string & {});
+    /** A custom section, metres (every ply together across), in place of a stock size. */
+    width?: number;
+    depth?: number;
+    /** How many plies a custom section is nailed up from (a stock size brings its own). */
+    plies?: number;
+    /** What it is made of; else what the stock size is (sawn lumber for a custom section). */
+    material?: BeamMaterial;
+    placement?: BeamPlacement;
+    /** Its top, level-local metres; absent = the level's ceiling plane over it. */
+    topElevation?: number;
+    /** The level it goes on: its `parentId`. */
+    levelId?: string;
+    /** The slab it belongs to, if any (a porch's or a deck's). */
+    supportSlabId?: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * A beam node from a centreline and a size, ready for `createNode` on its level: what the beam
+ * tool draws, and what code that frames a porch or a deck makes.
+ */
+export declare function createBeam(input: BeamInput): BeamNode;
+/** A beam's plan, level-local: its centreline, run, the way it runs and across it. */
+export type BeamPlan = {
+    start: P;
+    end: P;
+    length: number;
+    /** Unit vector start → end. */
+    direction: P;
+    /** Unit vector to the left of the run (the wall convention's +normal). */
+    normal: P;
+    width: number;
+};
+export declare function beamPlan(beam: Pick<BeamNode, 'start' | 'end' | 'width'>): BeamPlan;
+/** The beam's outline in plan, level-local: four corners, start's left first. */
+export declare function beamOutline(beam: Pick<BeamNode, 'start' | 'end' | 'width'>): P[];
+/**
+ * The ceiling plane over a beam, level-local: the top of the level's walls there, the storey's
+ * height or the underside of a slab of the level above that covers the beam (`getWallPlaneTop`
+ * over the beam's width, as for a wall).
+ */
+export declare function beamCeilingPlane(nodes: Nodes, beam: Pick<BeamNode, 'start' | 'end' | 'width' | 'parentId'>): number;
+/**
+ * Where a beam's top is, level-local. A stored `topElevation` stands; without one the beam
+ * follows the ceiling plane over it: a dropped beam hangs under it, the joists bearing on its
+ * top, and a flush one sits in the ceiling framing with its underside on it.
+ */
+export declare function beamTopElevation(nodes: Nodes, beam: Pick<BeamNode, 'start' | 'end' | 'width' | 'depth' | 'parentId' | 'placement' | 'topElevation'>): number;
+/** Where a beam's underside is, level-local: what a post under it stands up to. */
+export declare function beamBottomElevation(nodes: Nodes, beam: Pick<BeamNode, 'start' | 'end' | 'width' | 'depth' | 'parentId' | 'placement' | 'topElevation'>): number;
+/** The floor at a plan point of a level, level-local: the highest floor slab there, its top and underside. */
+export type LevelFloorAt = {
+    top: number;
+    underside: number;
+    slabId: string | null;
+};
+/**
+ * The floor a level stands on at a plan point: the highest of its floor slabs there (not a pit,
+ * not the site's paving), its top and the underside of its body; the level's own plane, 0, where
+ * none is.
+ */
+export declare function levelFloorAt(nodes: Nodes, levelId: string, point: readonly [number, number]): LevelFloorAt;
+/**
+ * Where a beam's top is set from, as the panel lists them: under the ceiling plane (a dropped
+ * beam, the default) or flush in the ceiling framing, both following the plane; flush with the
+ * floor (its top the floor's) or under the floor's framing (a girder in a crawl space, a deck's
+ * beam under its joists), both measured at the beam's middle.
+ */
+export type BeamTopReference = 'ceiling-dropped' | 'ceiling-flush' | 'floor-flush' | 'floor-under';
+export declare const BEAM_TOP_REFERENCES: readonly BeamTopReference[];
+export declare const BEAM_TOP_REFERENCE_LABELS: Record<BeamTopReference, string>;
+/** The fields that put a beam's top at `reference`. */
+export declare function beamTopReferencePatch(nodes: Nodes, beam: Pick<BeamNode, 'start' | 'end' | 'parentId'>, reference: BeamTopReference): Pick<BeamNode, 'topElevation' | 'placement'>;
+/** Which of the references a beam's top is set from now, or null for a top typed in by hand. */
+export declare function beamTopReferenceOf(nodes: Nodes, beam: Pick<BeamNode, 'start' | 'end' | 'parentId' | 'placement' | 'topElevation'>): BeamTopReference | null;
+/**
+ * The beams of a level over a plan point, the lowest underside first: those whose outline,
+ * grown by `margin` all round, holds the point. What a post set there stands up to.
+ */
+export declare function beamsOverPoint(nodes: Nodes, levelId: string, point: readonly [number, number], margin?: number): BeamNode[];
+/**
+ * Where posts stand under a beam run: at both ends and evenly between, no two further apart than
+ * `maxSpacing`. A porch's open edge gets its posts this way.
+ */
+export declare function postStationsAlong(start: readonly [number, number], end: readonly [number, number], maxSpacing: number): P[];
+export {};
+//# sourceMappingURL=beam.d.ts.map

package/dist/lib/beam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beam.d.ts","sourceRoot":"","sources":["../../src/lib/beam.ts"],"names":[],"mappings":"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"}

package/dist/lib/beam.js

@@ -0,0 +1,297 @@
+import { BEAM_SIZE_PRESETS, BeamNode, DEFAULT_BEAM_SIZE_PRESET_ID, } from '../schema/nodes/beam.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
+import { getWallPlaneTop } from '../services/storey.js';
+import { pointInPolygon, pointOnPolygonBoundary } from '../systems/slab/slab-support.js';
+import { isSiteFlatwork } from './site-flatwork.js';
+const INCH = 0.0254;
+/** Two sections within this of each other are one size (a 32nd of an inch). */
+const SIZE_TOLERANCE = INCH / 32;
+/**
+ * The stock size with this id or label (`BEAM_SIZE_PRESETS`): '(2)2x10' and '(2) 2x10' are both
+ * the two-ply 2x10.
+ */
+export function beamSizePreset(idOrLabel) {
+    return BEAM_SIZE_PRESETS.find((preset) => preset.id === idOrLabel || preset.label === idOrLabel);
+}
+/** Whether a beam of `material` can be a preset of `presetMaterial`: sawn stock comes treated too. */
+function materialFits(material, presetMaterial) {
+    if (presetMaterial === 'sawn')
+        return material === 'sawn' || material === 'pressure-treated';
+    return material === presetMaterial;
+}
+/**
+ * The stock size a beam is, if it is one: as many plies of the same nominal size (when it names
+ * one), the same section, and a material that size comes in.
+ */
+export function matchBeamSizePreset(beam) {
+    for (const preset of BEAM_SIZE_PRESETS) {
+        if (preset.plies !== beam.plies)
+            continue;
+        if (beam.size !== undefined && beam.size !== preset.size)
+            continue;
+        if (!materialFits(beam.material, preset.material))
+            continue;
+        if (Math.abs(preset.width - beam.width) > SIZE_TOLERANCE)
+            continue;
+        if (Math.abs(preset.depth - beam.depth) > SIZE_TOLERANCE)
+            continue;
+        return preset;
+    }
+    return null;
+}
+/**
+ * A length in inches and sixteenths, as a framing size prints it: 3.5 in reads "3-1/2", 0.75 in
+ * "3/4", 9 in "9".
+ */
+export function inchFractionLabel(metres, denominator = 16) {
+    const total = Math.round((Math.abs(metres) / INCH) * denominator);
+    const whole = Math.floor(total / denominator);
+    let numerator = total % denominator;
+    let over = denominator;
+    while (numerator > 0 && numerator % 2 === 0) {
+        numerator /= 2;
+        over /= 2;
+    }
+    if (numerator === 0)
+        return `${whole}`;
+    return whole > 0 ? `${whole}-${numerator}/${over}` : `${numerator}/${over}`;
+}
+/** What a plan adds after the size to say what a beam is made of; a W shape is steel by its name. */
+const MATERIAL_SUFFIX = {
+    sawn: '',
+    'pressure-treated': ' PT',
+    lvl: ' LVL',
+    glulam: ' GLB',
+    steel: '',
+};
+/** What each material is called in a list or a panel. */
+export const BEAM_MATERIAL_LABELS = {
+    sawn: 'Sawn lumber',
+    'pressure-treated': 'Pressure-treated',
+    lvl: 'LVL',
+    glulam: 'Glulam',
+    steel: 'Steel',
+};
+/**
+ * How each material looks, from the material library: fir for sawn lumber, a weathered grey-brown
+ * for treated, the pale veneer of an LVL, the warm laminations of a glulam, steel.
+ */
+export const BEAM_MATERIAL_LIBRARY_REFS = {
+    sawn: 'library:wood-woodfine2',
+    'pressure-treated': 'library:wood-woodplank19',
+    lvl: 'library:wood-woodfine22',
+    glulam: 'library:wood-woodfine13',
+    steel: 'library:metal-steel',
+};
+/**
+ * A beam's size as a framing plan prints it: "6x8", "(2) 2x10", "6x8 PT", "1-3/4x11-7/8 LVL",
+ * "W8x10"; a section that is no stock size by its actual inches ("3-1/2x9-1/4").
+ */
+export function beamSizeLabel(beam) {
+    const suffix = MATERIAL_SUFFIX[beam.material];
+    const size = beam.size ?? matchBeamSizePreset(beam)?.size;
+    if (size)
+        return `${beam.plies > 1 ? `(${beam.plies}) ` : ''}${size}${suffix}`;
+    return `${inchFractionLabel(beam.width)}x${inchFractionLabel(beam.depth)}${suffix}`;
+}
+/**
+ * The fields that make a beam a stock size. Sawn sizes keep a treated beam treated; any other
+ * size brings its own material.
+ */
+export function beamSizePresetPatch(beam, presetId) {
+    const preset = beamSizePreset(presetId);
+    if (!preset)
+        return {};
+    return {
+        size: preset.size,
+        plies: preset.plies,
+        width: preset.width,
+        depth: preset.depth,
+        material: materialFits(beam.material, preset.material) ? beam.material : preset.material,
+    };
+}
+/**
+ * A beam node from a centreline and a size, ready for `createNode` on its level: what the beam
+ * tool draws, and what code that frames a porch or a deck makes.
+ */
+export function createBeam(input) {
+    const custom = input.width !== undefined && input.depth !== undefined;
+    const preset = custom
+        ? undefined
+        : (beamSizePreset(input.preset ?? DEFAULT_BEAM_SIZE_PRESET_ID) ??
+            beamSizePreset(DEFAULT_BEAM_SIZE_PRESET_ID));
+    return BeamNode.parse({
+        start: [input.start[0], input.start[1]],
+        end: [input.end[0], input.end[1]],
+        width: custom ? input.width : preset?.width,
+        depth: custom ? input.depth : preset?.depth,
+        size: preset?.size,
+        plies: custom ? (input.plies ?? 1) : preset?.plies,
+        material: input.material ?? preset?.material ?? 'sawn',
+        placement: input.placement ?? 'dropped',
+        ...(input.topElevation !== undefined ? { topElevation: input.topElevation } : {}),
+        ...(input.levelId ? { parentId: input.levelId } : {}),
+        ...(input.supportSlabId ? { supportSlabId: input.supportSlabId } : {}),
+        ...(input.name ? { name: input.name } : {}),
+        ...(input.metadata ? { metadata: input.metadata } : {}),
+    });
+}
+export function beamPlan(beam) {
+    const dx = beam.end[0] - beam.start[0];
+    const dz = beam.end[1] - beam.start[1];
+    const length = Math.hypot(dx, dz);
+    const direction = length > 1e-9 ? [dx / length, dz / length] : [1, 0];
+    return {
+        start: [beam.start[0], beam.start[1]],
+        end: [beam.end[0], beam.end[1]],
+        length,
+        direction,
+        normal: [-direction[1], direction[0]],
+        width: beam.width,
+    };
+}
+/** The beam's outline in plan, level-local: four corners, start's left first. */
+export function beamOutline(beam) {
+    const { start, end, normal, width } = beamPlan(beam);
+    const [nx, nz] = [normal[0] * (width / 2), normal[1] * (width / 2)];
+    return [
+        [start[0] + nx, start[1] + nz],
+        [end[0] + nx, end[1] + nz],
+        [end[0] - nx, end[1] - nz],
+        [start[0] - nx, start[1] - nz],
+    ];
+}
+/**
+ * The ceiling plane over a beam, level-local: the top of the level's walls there, the storey's
+ * height or the underside of a slab of the level above that covers the beam (`getWallPlaneTop`
+ * over the beam's width, as for a wall).
+ */
+export function beamCeilingPlane(nodes, beam) {
+    if (!beam.parentId)
+        return DEFAULT_LEVEL_HEIGHT;
+    return getWallPlaneTop({ start: beam.start, end: beam.end, thickness: beam.width }, beam.parentId, nodes);
+}
+/**
+ * Where a beam's top is, level-local. A stored `topElevation` stands; without one the beam
+ * follows the ceiling plane over it: a dropped beam hangs under it, the joists bearing on its
+ * top, and a flush one sits in the ceiling framing with its underside on it.
+ */
+export function beamTopElevation(nodes, beam) {
+    if (beam.topElevation !== undefined)
+        return beam.topElevation;
+    const plane = beamCeilingPlane(nodes, beam);
+    return beam.placement === 'flush' ? plane + beam.depth : plane;
+}
+/** Where a beam's underside is, level-local: what a post under it stands up to. */
+export function beamBottomElevation(nodes, beam) {
+    return beamTopElevation(nodes, beam) - beam.depth;
+}
+function slabHolds(slab, [x, z]) {
+    if (!(pointInPolygon(x, z, slab.polygon) || pointOnPolygonBoundary(x, z, slab.polygon)))
+        return false;
+    for (const hole of slab.holes ?? []) {
+        if (hole.length >= 3 && pointInPolygon(x, z, hole))
+            return false;
+    }
+    return true;
+}
+/**
+ * The floor a level stands on at a plan point: the highest of its floor slabs there (not a pit,
+ * not the site's paving), its top and the underside of its body; the level's own plane, 0, where
+ * none is.
+ */
+export function levelFloorAt(nodes, levelId, point) {
+    const level = nodes[levelId];
+    let floor = { top: 0, underside: 0, slabId: null };
+    if (level?.type !== 'level')
+        return floor;
+    let best = null;
+    for (const childId of level.children) {
+        const child = nodes[childId];
+        if (child?.type !== 'slab' || child.visible === false)
+            continue;
+        if (child.recessed === true || isSiteFlatwork(child) || child.polygon.length < 3)
+            continue;
+        if (!slabHolds(child, [point[0], point[1]]))
+            continue;
+        if (!best || child.elevation > best.elevation)
+            best = child;
+    }
+    if (best)
+        floor = { top: best.elevation, underside: best.elevation - best.thickness, slabId: best.id };
+    return floor;
+}
+export const BEAM_TOP_REFERENCES = [
+    'ceiling-dropped',
+    'ceiling-flush',
+    'floor-flush',
+    'floor-under',
+];
+export const BEAM_TOP_REFERENCE_LABELS = {
+    'ceiling-dropped': 'Under ceiling plane',
+    'ceiling-flush': 'Flush in ceiling',
+    'floor-flush': 'Flush with floor',
+    'floor-under': 'Under floor',
+};
+function beamFloor(nodes, beam) {
+    if (!beam.parentId)
+        return { top: 0, underside: 0, slabId: null };
+    const middle = [(beam.start[0] + beam.end[0]) / 2, (beam.start[1] + beam.end[1]) / 2];
+    return levelFloorAt(nodes, beam.parentId, middle);
+}
+/** The fields that put a beam's top at `reference`. */
+export function beamTopReferencePatch(nodes, beam, reference) {
+    if (reference === 'ceiling-dropped')
+        return { topElevation: undefined, placement: 'dropped' };
+    if (reference === 'ceiling-flush')
+        return { topElevation: undefined, placement: 'flush' };
+    const floor = beamFloor(nodes, beam);
+    return reference === 'floor-flush'
+        ? { topElevation: floor.top, placement: 'flush' }
+        : { topElevation: floor.underside, placement: 'dropped' };
+}
+/** Which of the references a beam's top is set from now, or null for a top typed in by hand. */
+export function beamTopReferenceOf(nodes, beam) {
+    if (beam.topElevation === undefined)
+        return beam.placement === 'flush' ? 'ceiling-flush' : 'ceiling-dropped';
+    const floor = beamFloor(nodes, beam);
+    if (beam.placement === 'flush' && Math.abs(beam.topElevation - floor.top) < 1e-6)
+        return 'floor-flush';
+    if (beam.placement === 'dropped' && Math.abs(beam.topElevation - floor.underside) < 1e-6)
+        return 'floor-under';
+    return null;
+}
+/**
+ * The beams of a level over a plan point, the lowest underside first: those whose outline,
+ * grown by `margin` all round, holds the point. What a post set there stands up to.
+ */
+export function beamsOverPoint(nodes, levelId, point, margin = 0.01) {
+    const found = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'beam' || node.parentId !== levelId || node.visible === false)
+            continue;
+        const { start, length, direction, normal, width } = beamPlan(node);
+        const rx = point[0] - start[0];
+        const rz = point[1] - start[1];
+        const along = rx * direction[0] + rz * direction[1];
+        const across = rx * normal[0] + rz * normal[1];
+        if (along < -margin || along > length + margin)
+            continue;
+        if (Math.abs(across) > width / 2 + margin)
+            continue;
+        found.push({ beam: node, bottom: beamBottomElevation(nodes, node) });
+    }
+    return found.sort((a, b) => a.bottom - b.bottom).map(({ beam }) => beam);
+}
+/**
+ * Where posts stand under a beam run: at both ends and evenly between, no two further apart than
+ * `maxSpacing`. A porch's open edge gets its posts this way.
+ */
+export function postStationsAlong(start, end, maxSpacing) {
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const spans = maxSpacing > 0 ? Math.max(1, Math.ceil(length / maxSpacing - 1e-9)) : 1;
+    return Array.from({ length: spans + 1 }, (_, index) => {
+        const t = index / spans;
+        return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
+    });
+}

package/dist/lib/below-grade-footprints.d.ts

@@ -4,8 +4,7 @@ import { type Point2D } from './polygon-union.js';
  * Where the ground meets the levels below grade, in the site's plan: each such level's floor slabs
  * placed where its building stands and joined into outlines, the levels' together as one set (a
  * deeper level wider than the one over it, or under part of it, gives one outline, not overlapping
- * ones). The 3D view cuts its hole in the ground and draws its grade ring along them while the
- * ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
+ * ones). The 3D view cuts its hole in the ground over them while the ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
  * wall inside the outer faces. A level only partly below grade (a walk-out on a hillside) gives
  * the part of its floor the ground stands over by more than {@link BELOW_GRADE_TOLERANCE}, the
  * edge following the slope; fully buried levels give their whole floor.
@@ -36,6 +35,16 @@ export declare function belowGradeFootprints(nodes: Record<AnyNodeId, AnyNode>,
  * cannot be cut around an island of itself, and closed is the safe side.
  */
 export declare function coveredBelowGradeFootprints(nodes: Record<AnyNodeId, AnyNode>): Point2D[][];
+/**
+ * The part of every floor plate the rendered terrain stands over, in the site's plan: each visible
+ * level's floor slabs (not a recessed pit, not site flatwork), cut where the ground (the triangle
+ * plane the terrain draws) is higher than that slab's own top. Inside a storey's floor the ground
+ * is never seen over it: the terrain is cut open there, whatever the level's grade standing. Unlike
+ * the below-grade outlines this takes no {@link BELOW_GRADE_TOLERANCE}: a slope interpolated a few
+ * centimetres to 0.3 m over a walk-out's floor near where the ground rises is cut too. Rings only,
+ * as the cover: an outline with an inner outline is left out. Empty on a site with no terrain.
+ */
+export declare function terrainOverFloors(nodes: Record<AnyNodeId, AnyNode>): Point2D[][];
 /**
  * How deep the pit under the hole goes: the world Y of the top of the lowest floor of the level
  * shown (the sunken room of a split level, not its raised part), the deepest of the levels the hole
@@ -46,9 +55,8 @@ export declare function belowGradeFloorY(nodes: Record<AnyNodeId, AnyNode>, show
 /** How far under the top of the floor plate the pit hangs its own floor: the default plate's thickness. */
 export declare const GROUND_PIT_FLOOR_DROP = 0.05;
 /**
- * How far the pit's floor keeps from the plane of the plate's underside. The foundation under the
- * level tops out on that plane (`genericFoundation`), and seen through the hole it has to stand
- * on the pit's floor, not share its plane: two faces on one plane flicker. 2 cm is what a 24-bit
+ * How far the pit's floor keeps from the plane of the plate's underside: two faces on one plane
+ * flicker. 2 cm is what a 24-bit
  * depth buffer with the viewer's 0.3 m near plane tells apart out to about 300 m, further than
  * the hole is ever looked into from.
  */

package/dist/lib/below-grade-footprints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"below-grade-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/below-grade-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAgBnD,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,iBAAiB,CAAA;AAoE7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,EAAE,EAAE,CAUb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,EAAE,CA8B1F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAGf;AAED,2GAA2G;AAC3G,eAAO,MAAM,qBAAqB,OAAO,CAAA;AACzC;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAE9C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAQf"}
+{"version":3,"file":"below-grade-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/below-grade-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAiBnD,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,iBAAiB,CAAA;AAqE7D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,OAAO,EAAE,EAAE,CAUb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,EAAE,CA8B1F;AAMD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,EAAE,CA0BhF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAGf;AAED,2GAA2G;AAC3G,eAAO,MAAM,qBAAqB,OAAO,CAAA;AACzC;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAA;AAE9C;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,GAAG,IAAI,CAQf"}

package/dist/lib/below-grade-footprints.js

@@ -1,5 +1,5 @@
 import { BELOW_GRADE_TOLERANCE, getLevelElevations, levelLowestFloorWorldY, levelPlaneWorldY, levelPlateUndersideWorldY, } from '../services/storey.js';
-import { floorBuriedOnFlatSite, levelGradeStanding, terrainFieldOverLevel, } from './grade-standing.js';
+import { floorBuriedOnFlatSite, levelGradeStanding, slabGradeElevation, terrainFieldOverLevel, } from './grade-standing.js';
 import { groundOverPart } from './ground-over-part.js';
 import { difference, intersection, union } from './polygon-boolean.js';
 import { unionPolygons } from './polygon-union.js';
@@ -37,11 +37,12 @@ function levelPlates(nodes) {
             plates.push(plate);
             if (standing === 'at-grade')
                 continue;
-            if (field && plane !== null)
-                buried.push(...groundOverPart(plate, field, plane + slab.elevation + BELOW_GRADE_TOLERANCE));
-            else if (plane !== null) {
+            const floorY = plane === null ? null : plane + slabGradeElevation(nodes, level, slab);
+            if (field && floorY !== null)
+                buried.push(...groundOverPart(plate, field, floorY + BELOW_GRADE_TOLERANCE));
+            else if (floorY !== null) {
                 // A flat site, a level of floors at different heights: a floor is buried or it is not.
-                if (floorBuriedOnFlatSite(plane + slab.elevation))
+                if (floorBuriedOnFlatSite(floorY))
                     buried.push(plate);
             }
             else
@@ -63,8 +64,7 @@ function levelPlates(nodes) {
  * Where the ground meets the levels below grade, in the site's plan: each such level's floor slabs
  * placed where its building stands and joined into outlines, the levels' together as one set (a
  * deeper level wider than the one over it, or under part of it, gives one outline, not overlapping
- * ones). The 3D view cuts its hole in the ground and draws its grade ring along them while the
- * ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
+ * ones). The 3D view cuts its hole in the ground over them while the ground is veiled. An automatic floor follows the walls' centrelines, so an outline runs half a
  * wall inside the outer faces. A level only partly below grade (a walk-out on a hillside) gives
  * the part of its floor the ground stands over by more than {@link BELOW_GRADE_TOLERANCE}, the
  * edge following the slope; fully buried levels give their whole floor.
@@ -140,6 +140,50 @@ export function coveredBelowGradeFootprints(nodes) {
     coveredMemo.set(nodes, rings);
     return rings;
 }
+/** Ground this little over a floor counts as level with it, not over it: the terrain's centimetre steps. */
+const OVER_FLOOR_EPSILON = 0.005;
+const overFloorsMemo = new WeakMap();
+/**
+ * The part of every floor plate the rendered terrain stands over, in the site's plan: each visible
+ * level's floor slabs (not a recessed pit, not site flatwork), cut where the ground (the triangle
+ * plane the terrain draws) is higher than that slab's own top. Inside a storey's floor the ground
+ * is never seen over it: the terrain is cut open there, whatever the level's grade standing. Unlike
+ * the below-grade outlines this takes no {@link BELOW_GRADE_TOLERANCE}: a slope interpolated a few
+ * centimetres to 0.3 m over a walk-out's floor near where the ground rises is cut too. Rings only,
+ * as the cover: an outline with an inner outline is left out. Empty on a site with no terrain.
+ */
+export function terrainOverFloors(nodes) {
+    const hit = overFloorsMemo.get(nodes);
+    if (hit)
+        return hit;
+    const elevations = getLevelElevations(nodes);
+    const pieces = [];
+    for (const level of Object.values(nodes)) {
+        if (level.type !== 'level' || level.visible === false)
+            continue;
+        const field = terrainFieldOverLevel(nodes, level);
+        const plane = field ? levelPlaneWorldY(nodes, level.id) : null;
+        if (!field || plane === null)
+            continue;
+        const buildingId = elevations.get(level.id)?.buildingId;
+        const building = buildingId ? nodes[buildingId] : undefined;
+        const placed = building?.type === 'building' ? building : null;
+        for (const childId of level.children) {
+            const slab = nodes[childId];
+            if (slab?.type !== 'slab' || slab.recessed === true || isSiteFlatwork(slab))
+                continue;
+            if (slab.visible === false)
+                continue;
+            const plate = slab.polygon.map(([x, z]) => levelLocalToWorldXZ(placed, x, z));
+            pieces.push(...groundOverPart(plate, field, plane + slab.elevation + OVER_FLOOR_EPSILON));
+        }
+    }
+    const rings = union(pieces)
+        .filter((polygon) => polygon.holes.length === 0)
+        .map((polygon) => polygon.outer);
+    overFloorsMemo.set(nodes, rings);
+    return rings;
+}
 /**
  * How deep the pit under the hole goes: the world Y of the top of the lowest floor of the level
  * shown (the sunken room of a split level, not its raised part), the deepest of the levels the hole
@@ -154,9 +198,8 @@ export function belowGradeFloorY(nodes, shownLevelId) {
 /** How far under the top of the floor plate the pit hangs its own floor: the default plate's thickness. */
 export const GROUND_PIT_FLOOR_DROP = 0.05;
 /**
- * How far the pit's floor keeps from the plane of the plate's underside. The foundation under the
- * level tops out on that plane (`genericFoundation`), and seen through the hole it has to stand
- * on the pit's floor, not share its plane: two faces on one plane flicker. 2 cm is what a 24-bit
+ * How far the pit's floor keeps from the plane of the plate's underside: two faces on one plane
+ * flicker. 2 cm is what a 24-bit
  * depth buffer with the viewer's 0.3 m near plane tells apart out to about 300 m, further than
  * the hole is ever looked into from.
  */