@ahrowe/ui 0.34.0 → 0.36.0

package/dist/cjs-types/common/flip/flip.types.d.ts

@@ -0,0 +1,44 @@
+import { CSSProperties, ReactNode, Ref } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type FlipAxis = 'x' | 'y';
+export type FlipSlots = 'root' | 'perspective' | 'surface' | 'front' | 'back';
+export interface FlipHandle {
+    /** Toggles the flip state. No-op (with a dev warning) when `flipped` is controlled. */
+    flip: () => void;
+    /** Explicitly sets the flip state. No-op (with a dev warning) when `flipped` is controlled. */
+    setFlipped: (value: boolean) => void;
+    /** Returns to unflipped (front-facing). */
+    reset: () => void;
+}
+export interface FlipProps extends HtmlProps {
+    /** Front-face content. */
+    front: ReactNode;
+    /** Back-face content. */
+    back: ReactNode;
+    /** Controlled flip state. */
+    flipped?: boolean;
+    /** Initial flip state when uncontrolled. @default false */
+    defaultFlipped?: boolean;
+    /** Clicking the element toggles the flip state (uncontrolled) or calls `onFlip` (controlled). @default false */
+    flipOnClick?: boolean;
+    /** Which edge the flip hinges on. @default 'y' */
+    flipAxis?: FlipAxis;
+    /** Flips the rotation sign on `flipAxis` (+180deg vs -180deg), so the flip sweeps the opposite way without changing which edge it hinges on. @default false */
+    reverse?: boolean;
+    /** Flip transition duration in ms. @default 600 */
+    flipDuration?: number;
+    /** CSS `perspective` in px, applied to the perspective wrapper. Pass `'none'` when nesting inside something that already establishes its own perspective (e.g. `Tilt`), to avoid two stacked perspective contexts. @default 800 */
+    perspective?: number | 'none';
+    /** Disables `flipOnClick`; programmatic flips via prop or ref still work. @default false */
+    disabled?: boolean;
+    /** Fires after a user-initiated flip (click or ref call), not fired for externally-driven `flipped` prop changes. */
+    onFlip?: (flipped: boolean) => void;
+    /** Fires once the flip transition finishes settling on the new face, for any trigger (click, controlled prop change, or ref call). Fires synchronously under `prefers-reduced-motion: reduce`, since no transition runs to wait for. */
+    onFlipEnd?: (flipped: boolean) => void;
+    /** Imperative handle for flipping without owning the state. */
+    ref?: Ref<FlipHandle>;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<FlipSlots>;
+    styles?: SlotStyles<FlipSlots>;
+}

package/dist/cjs-types/common/flip/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './flip.js';
+export * from './flip.types.js';

package/dist/cjs-types/common/floorPlan/floorPlan.faces.d.ts

@@ -0,0 +1,33 @@
+import { areaCentroid } from './floorPlan.geometry.js';
+import { PlanFace, PlanFloor } from './floorPlan.types.js';
+/**
+ * Extracts every enclosed face from the wall graph, with nested components attached as
+ * holes.
+ *
+ * Returned faces are positively wound (visually clockwise in SVG space) and their
+ * `area` already has holes subtracted.
+ */
+export declare function deriveFaces(floor: PlanFloor): PlanFace[];
+/**
+ * Euler's formula per connected component: `V - E + F === 2C`, counting every cycle as
+ * a face, including each component's own outer boundary.
+ *
+ * Note it is `2C`, not the `1 + C` of a single connected embedding. The dart walk
+ * cannot bridge between disconnected components, so the region between two of them is
+ * produced once per component rather than once in total.
+ *
+ * Exported for tests and dev assertions: it is the cheapest whole-graph check that the
+ * dart permutation is intact.
+ */
+export declare function eulerCheck(floor: PlanFloor): {
+    v: number;
+    e: number;
+    f: number;
+    c: number;
+    holds: boolean;
+};
+/** Test/diagnostic helper: how many cycles each dart appears in. Must be all 1s. */
+export declare function dartCycleCounts(floor: PlanFloor): number[];
+/** Degree of each node, by id. Used by wall-path chaining and by validation. */
+export declare function nodeDegrees(floor: PlanFloor): Map<string, number>;
+export { areaCentroid };

package/dist/cjs-types/common/floorPlan/floorPlan.fixtures.d.ts

@@ -0,0 +1,35 @@
+import { PlanFloor, PlanPoint, PlanWall } from './floorPlan.types.js';
+export declare function emptyFloor(overrides?: Partial<PlanFloor>): PlanFloor;
+export declare class FloorBuilder {
+    floor: PlanFloor;
+    private nodeSeq;
+    private wallSeq;
+    constructor(floor?: PlanFloor);
+    /** Adds a node with an explicit id, or the next free auto-generated one. */
+    node(x: number, y: number, id?: string): string;
+    wall(a: string, b: string, attrs?: Partial<PlanWall>): string;
+    /** Adds a closed ring of walls through the given points, returning the node ids. */
+    ring(points: PlanPoint[], attrs?: Partial<PlanWall>): string[];
+    rect(x: number, y: number, w: number, h: number, attrs?: Partial<PlanWall>): string[];
+}
+/** A single 4m x 3m room. */
+export declare function singleRoom(): PlanFloor;
+/**
+ * Two rooms sharing one wall, the case the previous polygon model could not express.
+ * Left room 0..3000, right room 3000..7000, both 3000 tall. 7 walls, not 8.
+ */
+export declare function twoRoomsSharedWall(): PlanFloor;
+/** A square room with a free-standing interior wall attached at one corner. */
+export declare function roomWithDanglingWall(): PlanFloor;
+/** A square room containing a completely detached floating wall segment. */
+export declare function roomWithFloatingWall(): PlanFloor;
+/** An outer room with a detached inner room: the outer face needs a hole. */
+export declare function donut(): PlanFloor;
+/** Three nested squares: C's ring must attach to B, never to A. */
+export declare function tripleNested(): PlanFloor;
+/** A concave L-shaped room built from six walls. */
+export declare function lShapedRoom(): PlanFloor;
+/** A square divided into four by a full cross. */
+export declare function fourQuadrants(): PlanFloor;
+/** Every fixture, for invariant tests that should hold across all of them. */
+export declare const ALL_FIXTURES: Record<string, () => PlanFloor>;

package/dist/cjs-types/common/floorPlan/floorPlan.geometry.d.ts

@@ -0,0 +1,111 @@
+import { PlanPoint } from './floorPlan.types.js';
+/** Shortest wall the graph will accept. Keeps zero-length walls out entirely. */
+export declare const MIN_WALL_LENGTH = 10;
+/** Two points closer than this are the same point. */
+export declare const EPS_COINCIDENT = 1;
+/** A ring with |area| below this encloses nothing (0.0001 m²). */
+export declare const EPS_AREA = 100;
+/** Angular tolerance for "these two walls are collinear", in radians. */
+export declare const EPS_ANGLE = 0.0001;
+/** Narrowest scanline span that counts as room interior rather than a slit. */
+export declare const EPS_SPAN = 2;
+/** Narrowest opening worth keeping when a wall shortens under it. */
+export declare const MIN_OPENING_WIDTH = 100;
+export declare function dist(a: PlanPoint, b: PlanPoint): number;
+export declare function distSq(a: PlanPoint, b: PlanPoint): number;
+/** Cross product of ab and ac. Positive when c is clockwise of b in SVG's y-down space. */
+export declare function cross(a: PlanPoint, b: PlanPoint, c: PlanPoint): number;
+export declare function lerp(a: PlanPoint, b: PlanPoint, t: number): PlanPoint;
+/** Unit vector from a to b, or null when they are coincident. */
+export declare function direction(a: PlanPoint, b: PlanPoint): PlanPoint | null;
+/** Left-hand normal of the direction from a to b, or null when coincident. */
+export declare function normal(a: PlanPoint, b: PlanPoint): PlanPoint | null;
+/**
+ * Distance from p to segment ab, plus the clamped parameter t of the closest point.
+ * `t` is clamped to [0, 1], so the closest point is always on the segment.
+ */
+export declare function pointToSegment(p: PlanPoint, a: PlanPoint, b: PlanPoint): {
+    dist: number;
+    t: number;
+    point: PlanPoint;
+};
+/**
+ * Exact projection of p onto segment ab, clamped to the segment.
+ *
+ * Used after a fuzzy hit tolerance has decided that p belongs to this segment: intent
+ * is allowed to be approximate, the stored model never is.
+ */
+export declare function projectOnSegment(p: PlanPoint, a: PlanPoint, b: PlanPoint): PlanPoint;
+export type SegmentIntersectionKind = 
+/** The segments cross strictly inside both. */
+'proper'
+/** They are parallel and do not touch. */
+ | 'none'
+/** They lie on the same line and overlap over a non-zero length. */
+ | 'collinearOverlap'
+/** They lie on the same line but do not overlap. */
+ | 'collinearDisjoint'
+/** An endpoint of one lies on the other, or they share an endpoint. */
+ | 'touch';
+export interface SegmentIntersection {
+    kind: SegmentIntersectionKind;
+    /** Parameter along ab, for 'proper' and 'touch'. */
+    t?: number;
+    /** Parameter along cd, for 'proper' and 'touch'. */
+    s?: number;
+    point?: PlanPoint;
+}
+/**
+ * Classifies how segments ab and cd meet.
+ *
+ * `eps` is a millimetre distance tolerance, not a parameter tolerance, so the result
+ * does not change with segment length.
+ */
+export declare function segmentIntersection(a: PlanPoint, b: PlanPoint, c: PlanPoint, d: PlanPoint, eps?: number): SegmentIntersection;
+/**
+ * Shoelace area of a closed ring (first vertex not repeated).
+ *
+ * Positive means visually clockwise in SVG's y-down space. See `PlanFace.outer`.
+ */
+export declare function signedArea(ring: readonly PlanPoint[]): number;
+export declare function perimeter(ring: readonly PlanPoint[]): number;
+/**
+ * Area-weighted centroid of a ring.
+ *
+ * Deliberately not the vertex mean: a dangling wall adds an out-and-back vertex pair
+ * that skews the mean but contributes nothing to the area moment. Falls back to the
+ * vertex mean only for a degenerate (zero-area) ring.
+ */
+export declare function areaCentroid(ring: readonly PlanPoint[]): PlanPoint;
+/** Ray-casting point-in-ring test. Points exactly on an edge are unspecified. */
+export declare function pointInRing(p: PlanPoint, ring: readonly PlanPoint[]): boolean;
+/** Inside `outer` and outside every hole. */
+export declare function pointInRings(p: PlanPoint, outer: readonly PlanPoint[], holes?: readonly (readonly PlanPoint[])[]): boolean;
+/**
+ * A point guaranteed to lie strictly inside the ring set, placed somewhere visually
+ * central where possible.
+ *
+ * The area centroid is preferred, but it is not guaranteed to be inside a concave
+ * polygon (an L-shaped room's centroid can land in the notch), so a scanline fallback
+ * picks the widest interior span across several horizontal lines. The EPS_SPAN test on
+ * that span is what stops an anchor landing inside the zero-width slit that a dangling
+ * wall leaves in a face.
+ */
+export declare function representativePoint(outer: readonly PlanPoint[], holes?: readonly (readonly PlanPoint[])[]): PlanPoint;
+/**
+ * Removes out-and-back spurs (`... P, Q, P ...`) from a ring, repeatedly until none
+ * remain.
+ *
+ * A face containing a dangling wall is a valid fill but is not a simple polygon, which
+ * breaks polygon offsetting and makes some triangulators emit zero-area triangles. Run
+ * this before triangulating a floor slab; keep the raw ring for the 2D fill, where the
+ * slit is harmless and `wallIds` alignment matters.
+ */
+export declare function stripSpurs(ring: readonly PlanPoint[]): PlanPoint[];
+export declare function rectToPoints(x: number, y: number, w: number, h: number): PlanPoint[];
+export declare function boundsOf(points: readonly PlanPoint[]): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+} | null;

package/dist/cjs-types/common/floorPlan/floorPlan.graph.d.ts

@@ -0,0 +1,184 @@
+import { PlanEdit, PlanFloor, PlanIssue, PlanNode, PlanOpening, PlanPoint, PlanWall } from './floorPlan.types.js';
+/**
+ * Ids are deliberately non-numeric strings, so `Record` iteration keeps insertion
+ * order (JavaScript reorders integer-like keys), which is what makes derivation
+ * reproducible.
+ */
+export declare function newId(prefix: string): string;
+/** Test-only: makes generated ids reproducible within a single test. */
+export declare function __resetIdSeq(): void;
+declare function wallLength(floor: PlanFloor, wall: PlanWall): number;
+declare function wallsAtNode(floor: PlanFloor, nodeId: string): PlanWall[];
+declare function findWallBetween(floor: PlanFloor, a: string, b: string): PlanWall | null;
+/** Nearest existing node within `tol`, using the spatial hash. */
+export declare function findNodeNear(floor: PlanFloor, p: PlanPoint, tol: number): PlanNode | null;
+/** Nearest wall whose centreline passes within `tol` of `p`. */
+export declare function findWallNear(floor: PlanFloor, p: PlanPoint, tol: number, exclude?: ReadonlySet<string>): {
+    wall: PlanWall;
+    t: number;
+    point: PlanPoint;
+    dist: number;
+} | null;
+export interface SplitWallResult {
+    nodeId: string;
+    wallIds: [string, string] | null;
+    droppedOpeningIds: string[];
+}
+/**
+ * Splits a wall at a point or parameter, returning the node at the cut.
+ *
+ * Refuses to cut within `MIN_WALL_LENGTH` of either end, returning that endpoint's
+ * existing node instead. That single rule is what keeps zero-length walls out of the
+ * graph entirely, which in turn is what stops the angular sort from being fed a
+ * direction-less dart.
+ */
+export declare function splitWall(floor: PlanFloor, wallId: string, at: PlanPoint | number): PlanEdit<SplitWallResult>;
+export interface ResolveNodeResult {
+    nodeId: string;
+    createdNode: boolean;
+    splitWallId: string | null;
+}
+/**
+ * Returns the node to use at `p`: an existing one within `tol`, a new one created by
+ * splitting a wall that passes under `p`, or a brand new free-standing node.
+ */
+export declare function resolveNodeAt(floor: PlanFloor, p: PlanPoint, tol: number): PlanEdit<ResolveNodeResult>;
+export type WallAttrs = Pick<PlanWall, 'thickness' | 'type'> & Partial<Pick<PlanWall, 'height' | 'baseHeight'>>;
+export declare const DEFAULT_WALL_ATTRS: WallAttrs;
+/**
+ * Adds a wall from `a` to `b`, splitting anything it crosses so the graph stays planar.
+ *
+ * Collect-then-apply, in two phases: the naive version splits walls while iterating
+ * over walls, which both invalidates the iteration and reparameterises the very
+ * segments it is about to test.
+ */
+export declare function addWall(floor: PlanFloor, a: PlanPoint, b: PlanPoint, attrs?: WallAttrs, tol?: number): PlanEdit<{
+    wallIds: string[];
+    nodeIds: string[];
+}>;
+/** Draws the four walls of an axis-aligned rectangle, welding onto anything already there. */
+export declare function addRect(floor: PlanFloor, corner: PlanPoint, opposite: PlanPoint, attrs?: WallAttrs, tol?: number): PlanEdit<{
+    wallIds: string[];
+}>;
+/**
+ * Merges `removeId` into `keepId`, as when a node is dragged onto another.
+ *
+ * Order matters, and step 3 is mandatory rather than cosmetic: a duplicate wall between
+ * the same pair of nodes is exactly the identical-angle degeneracy that corrupts the
+ * face walk's angular sort.
+ */
+export declare function mergeNodes(floor: PlanFloor, keepId: string, removeId: string): PlanEdit<{
+    removedWallIds: string[];
+}>;
+export interface DissolveNodeOptions {
+    /**
+     * Rejoin the two walls even when the corner is bent or the walls differ in
+     * construction, taking the thicker wall's attributes and rescaling openings onto the
+     * shorter merged wall.
+     *
+     * This is "delete this corner" as a user means it. The default, unforced behaviour is
+     * the stricter one used by cleanup and by `removeWall`, where dissolving must not
+     * change the drawing's geometry at all.
+     */
+    force?: boolean;
+}
+/**
+ * Merges the two walls meeting at a degree-2 node back into one, the natural inverse of
+ * `splitWall`.
+ *
+ * Returns `null` unless the node is genuinely a seam: degree exactly 2, both walls
+ * identical in construction, and the turn within `EPS_ANGLE` of straight. Pass
+ * `{ force: true }` to rejoin a bent corner as well. Never call it mid-drag: it destroys
+ * node ids the user may be holding.
+ */
+export declare function dissolveNode(floor: PlanFloor, nodeId: string, options?: DissolveNodeOptions): PlanEdit<{
+    wallId: string;
+} | null>;
+export interface DetachWallResult {
+    /** The wall's end nodes after the detach, in `[a, b]` order. */
+    nodeIds: [string, string];
+    /** Connecting walls minted where an end was shared with a neighbour. */
+    connectorIds: string[];
+    /** Ends that became a straight seam once the wall left, and were dissolved away. */
+    dissolvedNodeIds: string[];
+}
+/**
+ * Pulls a wall off the nodes it shares with its neighbours and moves it by `delta`,
+ * leaving a connecting wall behind at each end that was shared.
+ *
+ * This is the extrude half of dragging a wall. A plain drag moves the shared end nodes,
+ * so everything meeting the wall follows it; here the neighbours keep their ends and
+ * only the new connectors grow, which is what you want when a partition joins the wall
+ * halfway along and should stay put.
+ *
+ * A free end is only moved: there is nothing there to detach from, and a connector would
+ * be zero length. For the same reason `delta` must be at least `MIN_WALL_LENGTH` long —
+ * below that the caller should `moveNode` both ends instead.
+ *
+ * The connector continues whatever was already at the corner (its thickness, type and
+ * heights) when exactly one wall was, so pulling a wall off a plain corner redraws
+ * exactly as a plain drag would: the seam that leaves behind is straight and is
+ * dissolved before returning. At a junction there is no single wall to continue, so the
+ * connector takes the dragged wall's own construction.
+ */
+export declare function detachWall(floor: PlanFloor, wallId: string, delta: PlanPoint): PlanEdit<DetachWallResult | null>;
+/**
+ * Collapses every wall shorter than `minLength` by merging its two ends together.
+ *
+ * Squashing a wall to nothing is the one thing a drag can do that the model forbids, and
+ * it is easy to do by accident: pushing a wall back onto the line it was detached from,
+ * or dragging a corner past the one next to it. Deleting the short wall is the wrong
+ * repair — it leaves two nodes sitting on the same point with the plan split between
+ * them, which reads as two corners stacked on top of each other and derives as two
+ * rooms. Merging is lossless, since the two ends are within `minLength` of each other by
+ * definition.
+ *
+ * The end with more walls on it survives, so the corner that was already there keeps its
+ * position and the one that arrived is the one that gives way.
+ */
+export declare function weldShortWalls(floor: PlanFloor, minLength?: number): PlanEdit<{
+    weldedWallIds: string[];
+}>;
+export declare function removeWall(floor: PlanFloor, wallId: string, opts?: {
+    pruneOrphanNodes?: boolean;
+    dissolveCollinear?: boolean;
+}): PlanEdit<{
+    removedNodeIds: string[];
+    dissolvedWallIds: string[];
+}>;
+export declare function moveNode(floor: PlanFloor, nodeId: string, to: PlanPoint): PlanEdit;
+/**
+ * Translates every node, and every room anchor with it.
+ *
+ * Room matching does not depend on this (it is primarily wall-id based), but a plan
+ * that is dragged and then saved without a derive should still have sane anchors.
+ */
+export declare function transformPlan(floor: PlanFloor, dx: number, dy: number): PlanFloor;
+/**
+ * Multiplies every coordinate and dimension by `factor`.
+ *
+ * The one place a scale factor belongs: converting a unitless legacy plan into the
+ * module's millimetre invariant, once, at the import boundary. The caller picks the
+ * factor, because nothing in the old data says what it should be.
+ */
+export declare function scalePlan(floor: PlanFloor, factor: number): PlanFloor;
+export declare function addOpening(floor: PlanFloor, opening: Omit<PlanOpening, 'id'>): PlanEdit<{
+    openingId: string | null;
+}>;
+export declare function updateOpening(floor: PlanFloor, openingId: string, patch: Partial<Omit<PlanOpening, 'id' | 'wallId'>>): PlanEdit;
+export declare function removeOpening(floor: PlanFloor, openingId: string): PlanEdit;
+/**
+ * Reports every way the graph currently violates the planar invariant.
+ *
+ * O(W²), so run it in tests and in development, not on every keystroke.
+ */
+export declare function validatePlan(floor: PlanFloor): PlanIssue[];
+/**
+ * Removes what validation can safely remove: degenerate walls, orphan nodes, dangling
+ * openings, and duplicate walls. Idempotent.
+ *
+ * Deliberately does not touch unsplit crossings: fixing one changes the room structure,
+ * which is the user's call, not a cleanup pass's.
+ */
+export declare function cleanupPlan(floor: PlanFloor): PlanEdit<PlanIssue[]>;
+export { wallLength, wallsAtNode, findWallBetween };

package/dist/cjs-types/common/floorPlan/floorPlan.hit.d.ts

@@ -0,0 +1,26 @@
+import { DerivedRoom, PlanFloor, PlanPoint, PlanSelection } from './floorPlan.types.js';
+export interface HitTolerances {
+    node: number;
+    opening: number;
+    wall: number;
+}
+/** Screen-pixel hit radii, divided by `view.zoom` to get world tolerances. */
+export declare const HIT_PX: HitTolerances;
+/** Wider targets for touch, where there is no pixel-accurate pointer. */
+export declare const HIT_PX_COARSE: HitTolerances;
+export declare function worldTolerances(px: HitTolerances, zoom: number): HitTolerances;
+export interface HitTestOptions {
+    /** Restricts what can be hit. Defaults to everything. */
+    accept?: Array<PlanSelection['type']>;
+    excludeIds?: ReadonlySet<string>;
+}
+/**
+ * Finds what is under `point`, in priority order: node handle, opening, wall, then room
+ * fill.
+ *
+ * The order is what makes editing feel right. A node sits on top of the walls that meet
+ * there, and an opening sits on top of the wall it cuts, so the smaller, more specific
+ * target always wins over the larger one underneath it.
+ */
+export declare function hitTest(floor: PlanFloor, rooms: DerivedRoom[], point: PlanPoint, tolerances: HitTolerances, options?: HitTestOptions): PlanSelection | null;
+export declare function selectionsEqual(a: PlanSelection | null, b: PlanSelection | null): boolean;

package/dist/cjs-types/common/floorPlan/floorPlan.json.d.ts

@@ -0,0 +1,23 @@
+import { FloorPlan } from './floorPlan.types.js';
+/** The only `version` a file may carry. Bump only for a breaking shape change. */
+export declare const PLAN_FORMAT_VERSION = 1;
+export interface PlanParseResult {
+    /** `null` only when the file could not be read as a plan at all. */
+    plan: FloorPlan | null;
+    /**
+     * Everything that had to be repaired or dropped, in plain language. Empty means the
+     * file was clean. A non-empty list with a plan means it was salvaged.
+     */
+    issues: string[];
+}
+/** A plan as JSON text, ready to write to a file. Indented unless told otherwise. */
+export declare function planToJson(plan: FloorPlan, options?: {
+    pretty?: boolean;
+}): string;
+/**
+ * Reads JSON text as a plan, repairing what it can and reporting what it could not.
+ *
+ * `plan` is `null` only when the text is not JSON, is not an object, or carries a
+ * `version` this build does not know. Everything else comes back as a usable plan.
+ */
+export declare function planFromJson(text: string): PlanParseResult;

package/dist/cjs-types/common/floorPlan/floorPlan.mesh.d.ts

@@ -0,0 +1,36 @@
+import { PlanFloor } from './floorPlan.types.js';
+export type PlanMeshPart = 'wall' | 'floor';
+export interface PlanMeshGroup {
+    part: PlanMeshPart;
+    /** Offset into `indices`, and how many of them. Draw ranges, or assign materials. */
+    start: number;
+    count: number;
+}
+export interface PlanMesh {
+    /** World-space xyz triples, in millimetres. */
+    positions: Float32Array;
+    /** Unit face normals, one per vertex. */
+    normals: Float32Array;
+    indices: Uint32Array;
+    groups: PlanMeshGroup[];
+}
+export interface BuildPlanMeshOptions {
+    /** Storey height for walls that do not carry their own. Defaults to the floor's. */
+    wallHeight?: number;
+    /** Lay a slab under each room. Default true. */
+    includeFloorSlab?: boolean;
+    /** Millimetres. The slab hangs below the floor level. Default 200. */
+    slabThickness?: number;
+    /**
+     * Lift everything by the floor's own elevation, so several storeys stack into one
+     * scene. Default true.
+     */
+    applyElevation?: boolean;
+}
+/**
+ * Triangles for one floor: every wall, with its openings cut out, and a slab per room.
+ *
+ * Call it per storey and concatenate to build a whole building; each floor already knows
+ * its own elevation.
+ */
+export declare function buildPlanMesh(floor: PlanFloor, options?: BuildPlanMeshOptions): PlanMesh;

package/dist/cjs-types/common/floorPlan/floorPlan.path.d.ts

@@ -0,0 +1,59 @@
+import { PlanFloor, PlanOpening, PlanPoint, PlanWall } from './floorPlan.types.js';
+export interface WallPathGroup {
+    /** Millimetres. The stroke width for the outline pass. */
+    thickness: number;
+    /**
+     * Path data, to be handed VERBATIM to both passes. The outline pass strokes it at
+     * `thickness`, the fill pass at `thickness - 2 * outlineWidth`.
+     */
+    d: string;
+}
+export type WallCapReason = 'jamb' | 'freeEnd' | 'thicknessStep';
+export interface WallCapLine {
+    a: PlanPoint;
+    b: PlanPoint;
+    reason: WallCapReason;
+    wallId: string;
+}
+export interface WallPathResult {
+    /** Render every group's outline first, then every group's fill. */
+    groups: WallPathGroup[];
+    /** Drawn last, in the outline colour, at the outline width. */
+    caps: WallCapLine[];
+}
+export interface BuildWallPathsOptions {
+    /**
+     * Build paths for only these walls, as if the rest were not drawn.
+     *
+     * Node degrees still come from the WHOLE floor, so chains break and corners are filled
+     * exactly where they are for the real walls. That is what lets a subset be painted over
+     * the top of the full drawing and land on it precisely: a highlight of a room's
+     * boundary is the same geometry as the walls themselves, openings and all.
+     */
+    wallIds?: ReadonlySet<string>;
+    /** Cap the free end of a wall that stops in mid-air. Default true. */
+    capFreeEnds?: boolean;
+    /** Cap the joint where two walls of different thickness meet. Default true. */
+    capThicknessSteps?: boolean;
+}
+/**
+ * The parts of a wall's centreline that are actually wall, as `[start, end]` offsets in
+ * millimetres from node `a`.
+ *
+ * Overlapping openings merge into one gap; an opening reaching an end removes that span
+ * entirely. An empty result means the opening spans the whole wall.
+ */
+export declare function wallCentrelineSpans(floor: PlanFloor, wall: PlanWall): Array<[number, number]>;
+/** Everything a renderer needs to draw a door leaf, swing arc or window symbol. */
+export declare function openingGeometry(floor: PlanFloor, opening: PlanOpening): {
+    centre: PlanPoint;
+    dir: PlanPoint;
+    normal: PlanPoint;
+    p1: PlanPoint;
+    p2: PlanPoint;
+} | null;
+/**
+ * Builds the stroke path data for every wall, grouped by thickness, plus the cap lines
+ * the two-pass trick cannot produce on its own.
+ */
+export declare function buildWallPaths(floor: PlanFloor, options?: BuildWallPathsOptions): WallPathResult;

package/dist/cjs-types/common/floorPlan/floorPlan.plan.d.ts

@@ -0,0 +1,98 @@
+import { PlanUnitSystem, FloorPlan, PlanEdit, PlanFloor } from './floorPlan.types.js';
+export interface EmptyFloorPlanOptions {
+    id?: string;
+    name?: string;
+    floorId?: string;
+    floorLabel?: string;
+    unitSystem?: PlanUnitSystem;
+    /** Default storey height in millimetres. */
+    height?: number;
+}
+export declare function emptyFloor(options?: Omit<EmptyFloorPlanOptions, 'id' | 'name'>): PlanFloor;
+export declare function emptyFloorPlan(options?: EmptyFloorPlanOptions): FloorPlan;
+export declare function getFloor(plan: FloorPlan, floorId?: string): PlanFloor | null;
+/**
+ * Applies a floor-level edit to one floor of a plan, bumping `revision` so memoised
+ * derivations know to recompute.
+ *
+ * The revision only moves when the edit actually returned a different floor, so a
+ * gesture that changed nothing does not invalidate anything.
+ */
+export declare function updateFloor<T>(plan: FloorPlan, floorId: string | undefined, edit: (floor: PlanFloor) => PlanEdit<T>): PlanEdit<T> & {
+    plan: FloorPlan;
+};
+/** Replaces one floor outright, bumping the revision. */
+export declare function setFloor(plan: FloorPlan, floor: PlanFloor): FloorPlan;
+/**
+ * Floors run bottom to top: index 0 is the lowest storey, and `elevation` rises with
+ * the index. Nothing enforces that beyond these helpers, but `floorBelow` and the
+ * drawer's underlay both read it, so an out-of-order `floors` array shows the wrong
+ * storey underneath.
+ */
+export declare function floorIndex(plan: FloorPlan, floorId: string): number;
+/** The storey directly under this one, which is what an underlay traces. */
+export declare function floorBelow(plan: FloorPlan, floorId: string): PlanFloor | null;
+export interface AddFloorOptions {
+    label?: string;
+    /** Millimetres. Defaults to the storey height of the floor it is added above. */
+    height?: number;
+    /** Where to put it. Defaults to directly above `aboveFloorId`, else on top. */
+    index?: number;
+    id?: string;
+}
+/**
+ * Adds an empty storey and returns the plan with it, plus the floor itself.
+ *
+ * Its elevation is the top of the storey below, so a plan stays physically coherent
+ * without the caller doing arithmetic. Everything above is pushed up by the new storey's
+ * height, since inserting a floor into a building raises the ones over it.
+ */
+export declare function addFloor(plan: FloorPlan, options?: AddFloorOptions): {
+    plan: FloorPlan;
+    floor: PlanFloor;
+};
+/**
+ * Removes a storey, unless it is the last one: a plan with no floors has nowhere to
+ * draw, and every consumer would need a special case for it.
+ */
+export declare function removeFloor(plan: FloorPlan, floorId: string): FloorPlan;
+/**
+ * Copies a storey, including its geometry, directly above itself.
+ *
+ * Every id is regenerated and every reference rewired to the copy, so the two storeys
+ * share nothing: an edit to one must not reach through into the other. This is the usual
+ * way to start an upper floor, since the walls below are mostly where the walls above go.
+ */
+export declare function duplicateFloor(plan: FloorPlan, floorId: string, options?: {
+    label?: string;
+}): {
+    plan: FloorPlan;
+    floor: PlanFloor | null;
+};
+/** Millimetres. Low enough for a crawl space, high enough to stop a zero-height storey. */
+export declare const MIN_FLOOR_HEIGHT = 500;
+/**
+ * Sets a storey's height, and drops or lifts everything above it to suit.
+ *
+ * This is why it is not a plain `setFloor`: a storey's height is what the next one sits
+ * on, so changing it without re-stacking leaves the floors above either buried in it or
+ * floating over it, which nothing in 2D would ever show.
+ */
+export declare function setFloorHeight(plan: FloorPlan, floorId: string, height: number): FloorPlan;
+/** Renames a storey. Its own field, since nothing else about a floor is text. */
+export declare function renameFloor(plan: FloorPlan, floorId: string, label: string): FloorPlan;
+/** Moves a storey up or down the stack, re-stacking the elevations behind it. */
+export declare function moveFloor(plan: FloorPlan, floorId: string, toIndex: number): FloorPlan;
+export interface PlanBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    width: number;
+    height: number;
+}
+/**
+ * Bounding box of a floor's geometry, padded by half the thickest wall so the outer
+ * face of every wall is inside it rather than its centreline.
+ */
+export declare function floorBounds(floor: PlanFloor): PlanBounds | null;