@kerros/editor 0.0.0-stage → 0.1.0-rc.2

package/dist/types/map/SceneLayer.d.ts

@@ -0,0 +1,306 @@
+import { type CustomLayerInterface, type Map as MapLibreMap, type CustomRenderMethodInput } from 'maplibre-gl';
+import type { Floor, Point, ProjectDocument, Ring, SiteObject } from '../model/types';
+import type { Route } from '../model/navigation';
+import { type VoidOptions } from '../model/vertical';
+import type { StatusReading } from '../model/live';
+import type { MapStyleOptions } from '../theme';
+import { type UndergroundView } from './underground';
+import { type Sun } from './lighting';
+export { rampJoins } from '../model/ramps';
+export { rampVoids } from './rampGeometry';
+export declare const nestingLift: (area: number) => number;
+export { LIFT, SLAB } from './levels';
+/** How far an absolutely-placed piece of geometry has to move to join the rest of the scene.
+ *
+ *  Geometry arrives in two coordinate systems. Most of it is placed relative to the level in focus,
+ *  which is what lets a cutaway sit on the map and a walk stand on the map's own ground plane. The
+ *  rest carries the elevation the document authored: a ramp's slope, the parcel and the fences out
+ *  of doors, the excavation and its cage. Nothing reconciled the two, so walking a P1 deck put the
+ *  ramps 12.6 m under the walker and left the pavement level with a fifth-floor shop. This is the
+ *  one number that carries an authored elevation into the frame everything else is drawn in. The
+ *  stacked view is already drawn at authored elevations, so there it is nothing. */
+export declare const sceneGround: (stack: boolean, rebase: number, activeElevation: number) => number;
+/** Where an authored elevation ends up on screen, once the view's depth mapping has had its say.
+ *
+ *  `undergroundView` compresses a shaft deeper than 96 m so a 400 m one can be looked at, and its
+ *  header asks every consumer to share that one transform. They did not: the stack compressed its
+ *  geometry vertex by vertex while a single-floor cutaway rebased to the compressed depth and then
+ *  added raw deltas to it, which put a level 140 m under the one in focus 44 m into the sky. This is
+ *  the mapping the plate, the flights climbing through it, the excavation's strata and the cage all
+ *  go through. A walk is the one view it has nothing to say to: inside one storey there is no depth
+ *  to compress, and the storey has been moved onto the map's ground plane anyway. */
+export declare const sceneElevation: (view: UndergroundView, walk: boolean, z: number) => number;
+/** The underside of a walked storey's ceiling, above the storey's own datum.
+ *
+ *  It is the next slab's underside, not the storey height less a slab: fixtures are authored against
+ *  the storey — the garage's 3.1 m luminaires, its 4.2 m pillars — and a lid a third of a metre low
+ *  had them poking through it. And a storey the document drew too low for a person to stand in must
+ *  still get a ceiling above the eye rather than one you look down onto: the 1.6 m entresol put its
+ *  glowing plane at 1.42 m, a good half metre under the walker's eye. */
+export declare const walkSoffit: (rebase: number, height: number) => number;
+/** A mezzanine shares the surrounding hall's roof. Its own partial footprint cannot close the
+ *  space seen beyond the gallery edge. Other floors keep their own ceiling. */
+export declare function walkCeiling(project: ProjectDocument, floorId: string): {
+    floor: Floor;
+    soffit: number;
+} | undefined;
+/** The single plate a storey is drawn as when it is drawn as a shell — the ceiling you look down
+ *  onto from the storey above — with the stairwells punched through it.
+ *
+ *  Only the storey's top-level areas go in. A parking deck is one plate carrying four hundred bays
+ *  drawn on it as zones; unioning every one of them is the input polygon-clipping's sweep line gives
+ *  up on, and the caller's catch then left the deck with no slab at all. The bays are inside the
+ *  plate anyway, so they say nothing about where the storey reaches. Sloped areas keep their own
+ *  geometry: flattening their footprints into this plate seals the ramp with a horizontal lid.
+ *
+ *  A storey drawn as rooms rather than as a zone has no single plate, and `floorOutline` already
+ *  knows how to make one: rooms plus the walls between them, snapped and cached. */
+export declare function shellPlate(project: ProjectDocument, floorId: string, primary?: Set<string>, voidOptions?: VoidOptions): Ring[][];
+export declare class SceneLayer implements CustomLayerInterface {
+    id: string;
+    type: "custom";
+    renderingMode: "3d";
+    private map?;
+    private renderer?;
+    private scene;
+    private camera;
+    private worldToClip;
+    private clipToWorld;
+    private transform;
+    private center;
+    private unit;
+    private project?;
+    private stack;
+    private walking;
+    /** The walked floor has lamps of its own. Then the walk hands the interior over to them and
+     *  turns the general ceiling light down; a floor without any keeps the general light, or it is
+     *  a dark floor with a bright lid. */
+    private lampLit;
+    private poolLitOnly;
+    private poolOverview;
+    /** Per-storey ghost strength for the things a stack is FOR — the floor plates that carry each
+     *  storey's plan — on the storeys ABOVE the one in focus. Shared out across however many of them
+     *  the stack layers up between the eye and the focus. */
+    private ghostAlpha;
+    /** And for the storeys UNDER the one in focus, which are read through the active plate as well as
+     *  through everything above it and need the strength to survive both. Keeping the two apart is
+     *  also what lets the active plate be drawn between them — see the render-order pass. */
+    private underAlpha;
+    private activeFloor;
+    private hovered;
+    private rebase;
+    /** See sceneGround: what an authored elevation has to be shifted by to join the scene. */
+    private ground;
+    private growth;
+    private growthStart;
+    private materials;
+    private cabinMaterials?;
+    private passenger?;
+    private cabinFinishes;
+    wave(): void;
+    private fixtureLights?;
+    private waterTime;
+    private hasWater;
+    private batch;
+    private highlight;
+    private selected;
+    /** Where the sun stands over this project right now, and whether that counts as evening. */
+    private sunState;
+    private statuses;
+    private excavation;
+    /** Only the part of the feed the scene is built from — where the cars are and whether doors stand
+     *  open. A tone changing from normal to alarm recolours a marker and must not rebuild the scene. */
+    private liftSignature;
+    /** Per-floor stairwell cut-outs; cleared with the scene. */
+    private voidCache;
+    /** Moving parts, rebuilt with the scene each update — see `rig`. */
+    private rigs;
+    /** Where each moving part has got to, carried ACROSS rebuilds. The geometry is disposed with the
+     *  scene like everything else; this is not, or every lift car would jump back to the bottom of its
+     *  shaft on any edit, and every open door would slam. */
+    private rigState;
+    /** Whether the last animation frame moved anything that casts a shadow. */
+    private shadowsMoved;
+    private lastFrame;
+    private revision;
+    private depthScale;
+    private buried;
+    private presentedElevation;
+    private cage;
+    private sun?;
+    /** The two lights that are not the sun, kept so the scene can be re-lit without being rebuilt. */
+    private skyLight?;
+    private roomLight?;
+    private route;
+    private routeStep;
+    private routeGroup;
+    private routeTile;
+    private mapStyle;
+    setMapStyle(style?: MapStyleOptions): void;
+    private xyCache;
+    private markerCache;
+    private occlusionCache;
+    private previousProjection;
+    private previousScale;
+    private previousSize;
+    private pickables;
+    private clipBounds;
+    private clipBoundsDirty;
+    onAdd(map: MapLibreMap, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /** A tiny procedural sky/ground gradient, prefiltered for image-based lighting. Without an
+     *  environment every MeshStandardMaterial is lit by two lights alone and reads flat; with one, every
+     *  surface picks up sky above and bounced ground below, which is most of what makes 3D look solid.
+     *  Built once per lighting mood and cached — PMREM generation is not cheap. */
+    private envCache;
+    private environmentMap;
+    /** Move the existing lights to where a new sun puts them, without touching the geometry. Valid
+     *  only while the dusk treatment is unchanged — see the caller. */
+    private relight;
+    /** Redraw every shadow map on the next frame: the sun's, and each lamp's. Shadows are drawn on
+     *  demand, and each light says for itself whether it is owed a redraw — the sun's map is one
+     *  2048² pass over the whole model and a lamp's is six, so a lamp swapping under a walker must
+     *  not cost the sun's as well. This is the "everything changed" case. */
+    private refreshShadows;
+    /** Point the sun at the model and shrink its shadow frustum to fit. A fixed +/-140 m box spends
+     *  most of a 2048 map on empty ground: a small building got a handful of texels and its shadows
+     *  came out as soft mush. Fitting to the real extent keeps texel density high whatever the scale. */
+    private fitShadowCamera;
+    private xy;
+    /** Several extrusions welded into one moving part. An escalator's step band is twenty boxes that
+     *  travel together, and twenty meshes per flight — times a bank of four, times the flights in
+     *  view — is a draw call apiece for something that moves as one thing. Merged, it is one. */
+    private parts;
+    /** Register a moving part. Called while the scene is being built; the geometry is fresh each time
+     *  and the position it has reached is not, so a car mid-ride keeps riding across an edit.
+     *
+     *  `settled` seeds the value the first time a part is ever seen, so opening a document does not
+     *  send every lift travelling up from the basement to wherever it actually is. */
+    private rig;
+    /** Advance every moving part toward its target. Returns true while anything is still moving, which
+     *  is what keeps asking the map to repaint — MapLibre draws on demand, so without that a ride would
+     *  advance one frame per mouse move. */
+    private animate;
+    /** Ask for a repaint at the loop rate rather than at once, coalescing the requests so a dozen
+     *  escalators still only cost one frame between them. */
+    private loopTimer?;
+    private paintSoon;
+    /** One vertex, mapped by the view's depth transform — see sceneElevation. Geometry is built at
+     *  the elevations the document authored, so this is the last thing that touches a z before it
+     *  reaches the buffer. It ran in the stacked view only, which left a deep cutaway drawing its
+     *  plate at the compressed depth and everything around it at the real one. */
+    private present;
+    private surface;
+    /** A sloped area (garage ramp, loading incline): the plate's own footprint, but each vertex lifted
+     *  to its elevation along the slope axis, then given thickness along -Z so the deck reads solid
+     *  from below. Depth compression is applied per-vertex, exactly as for flat surfaces. */
+    private slopedSurface;
+    /** The façade envelope for a set of levels: each level's slab, its exterior walls with their
+     *  authored finish, and the glazing punched into them. Interior partitions are deliberately left
+     *  out — from outside they are hidden work, and they used to produce seams along the façade. */
+    private envelope;
+    private opening;
+    /** A door as a leaf in a frame, standing open when the feed says it is.
+     *
+     *  In 3D a door had been a slab filling its whole opening — a door you could never walk through and
+     *  that looked identical whether it was open, closed or unmonitored. The plan has drawn the swing
+     *  for a long time; this is the same statement in three dimensions, hinged the same way, so the two
+     *  views agree about which side it opens from.
+     *
+     *  Unknown status means shut. The plan can draw the architectural swing symbol for "a door is here
+     *  and this is how it opens" because a symbol is allowed to be about the door rather than about its
+     *  state; a solid leaf in space is not, so it stays in the frame until something says otherwise. */
+    private leaf;
+    /** The inward-facing edge of an exterior wall.
+     *
+     *  Which face is the inside is not a property of the wall — it is a question about the building
+     *  around it — so it is answered the only way it can be: step off the wall each way and see which
+     *  side lands within the floor's footprint. A wall with no footprint to be inside of (an outbuilding
+     *  wall, a fence read as exterior) has no interior face. */
+    private interiorFace;
+    /** An area's rings with the shafts that climb through its level, and the ramps that drive through
+     *  it, cut out of them.
+     *
+     *  `through` says which plate is being cut: a floor is open where something arrives up through it,
+     *  a ceiling where something sets off up through it. They are not the same holes — the bottom of a
+     *  run departs without arriving and the top arrives without departing — and on a criss-cross
+     *  escalator bank they are at opposite ends of the same box.
+     *
+     *  `wells` is whether a stairwell may be punched at all — a hole onto a storey nobody is drawing
+     *  is worse than no hole. A ramp is not subject to it: what is under a ramp's hole is the ramp.
+     *
+     *  Cheap when there is nothing to cut, which is the usual case: a floor with no shaft through it
+     *  gets its own rings back untouched, and one with a shaft pays a clip only for the areas the
+     *  shaft actually lands in. */
+    private withVoids;
+    /** A stair, spiral or escalator, drawn as the climb it actually makes.
+     *
+     *  The flights come from the levels the document says the shaft serves, not from whatever storey
+     *  happens to sit above it, and each is drawn at the elevation of the level it leaves — so the
+     *  flight arriving at the level you are standing on is there, coming up through the floor, instead
+     *  of being filed invisibly under the storey below. */
+    private shaft;
+    /** A straight climb: treads for a stair, a ribbed deck between flat landing plates for an
+     *  escalator. Both run along the object's own depth axis, which is where the plan put them. */
+    private flight;
+    /** A lift: the shaft as tall as the levels it serves, its doors on the level you are standing on,
+     *  and the car where the feed says it is.
+     *
+     *  It used to be a 1.2 m box — shorter than the doors it was supposed to contain — because the
+     *  generic object path capped elevators there to stop them blocking the view. A lift is not
+     *  furniture: it is a hole through the building, and drawing it as one is the only way the plan
+     *  shows that floors 2 and 7 are on the same shaft. Above the level in focus it turns to ghost, so
+     *  it reads as continuing without becoming a column in front of everything else. */
+    private lift;
+    /** A spiral: wedge treads winding around a central pole.
+     *
+     *  Its exits are wherever it is served — a spiral passing three levels with a landing on each is
+     *  one object serving three floors, which the document could already say and nothing drew. */
+    private spiral;
+    update(project: ProjectDocument, floorId: string | null, stack: boolean, selected: string | null, sun?: Sun, statuses?: Map<string, StatusReading> | null, excavation?: boolean, 
+    /** Walk mode: put the floor being walked on the map's own ground plane. MapLibre's camera cannot
+     *  go below that plane, so a basement drawn at its true depth would be unreachable on foot. */
+    walk?: boolean): void;
+    /** Show/replace the 3D route. When only the active step changed, restyle materials in place;
+     * otherwise rebuild the route group. Route state is retained across update() rebuilds — every
+     * rebuild re-runs buildRoute with FRESH materials, because disposeScene disposes all mesh
+     * materials and a cached material would die silently on the next floor switch. */
+    setRoute(route: Route | null, activeStep?: number | null): void;
+    /** The track's texture already carries the green and the white kerb, so the material's own colour
+     *  stays white and only emphasis separates the step being walked from the rest of the path. A
+     *  route is one route: dimming the other steps says "later", where recolouring them would say
+     *  "different". */
+    private routeStyle;
+    private restyleRoute;
+    private buildRoute;
+    /** Flat mitred triangle-strip ribbon at a constant z, in scene metres. */
+    private ribbonGeometry;
+    animateIn(): void;
+    private refreshHighlight;
+    setHover(id: string | null): void;
+    get diagnostics(): {
+        revision: number;
+        drawCalls: number;
+        geometries: number;
+        textures: number;
+        animatedWater: boolean;
+    };
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, args: CustomRenderMethodInput): void;
+    /** Where a point on a floor's walking surface lands on screen — the avatar marker, which is not an
+     *  object and has no occlusion to test. `visible` is the frustum only. */
+    projectPoint(pt: Point, floorId: string | null): {
+        x: number;
+        y: number;
+        visible: boolean;
+    } | null;
+    projectObject(o: SiteObject): {
+        x: number;
+        y: number;
+        visible: boolean;
+    } | null;
+    pick(point: {
+        x: number;
+        y: number;
+    }): string | null;
+    private disposeScene;
+    onRemove(): void;
+}

package/dist/types/map/UndergroundContext.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import type { Point } from '../model/types';
+/** A camera-facing cutaway cage. Rotating updates two existing buffers, never GPU resources. */
+export declare class UndergroundCage extends THREE.Group {
+    private rings;
+    private columns;
+    private center;
+    private bottom;
+    private top;
+    private bearing;
+    private ringLines?;
+    private columnLines?;
+    configure(rings: THREE.Vector3[][], columns: Point[], bottom: number, top: number, evening: boolean): void;
+    setBearing(bearing: number): void;
+    dispose(): void;
+}
+/** Only the shaft boundary needs vertical faces; no 1.8 km cap to triangulate or raycast. */
+export declare function undergroundPit(ring: Point[], floor: number, bottom: number, strata?: number[]): THREE.Group;

package/dist/types/map/ambience.d.ts

@@ -0,0 +1,29 @@
+import type { Ambience, AmbiencePreset, Point, ProjectDocument } from '../model/types';
+export declare const AMBIENCES: {
+    id: AmbiencePreset;
+    label: string;
+    description: string;
+}[];
+/** What a point on a floor sounds like: the space's own ambience, else the floor's, else nothing.
+ *  `silent` resolves to null too, so a room can be the quiet one on a humming floor. */
+export declare function ambienceAt(project: ProjectDocument, floorId: string | null, at: Point): Ambience | null;
+/** Plays one ambience at a time and cross-fades between them. Owns its AudioContext, which the
+ *  browser will only let run after the person has clicked or pressed something — resume() is for
+ *  the host to call from such a gesture, and everything else copes with a context that is not yet
+ *  running by starting silently and coming up when it is. */
+export declare class AmbienceEngine {
+    private ctx?;
+    private master?;
+    private playing?;
+    private fading;
+    private muted;
+    get isMuted(): boolean;
+    /** Let the context run. Safe to call on every gesture; a running context ignores it. */
+    resume(): void;
+    setMuted(muted: boolean): void;
+    /** Play this — or nothing, for null — fading out whatever was playing. Same thing again is a no-op. */
+    set(ambience: Ambience | null): void;
+    dispose(): void;
+    private context;
+    private fadeOut;
+}

package/dist/types/map/architecture.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import type { BuildingRoof, Point, SiteObject } from '../model/types';
+import { MaterialLibrary } from './materials';
+type ProjectXY = (point: Point) => Point;
+/** Convex eaves fan into a ridge. Each plane receives actual interlocking tile geometry. */
+export declare function makeRoof(roof: BuildingRoof, projectXY: ProjectXY, id: string, materials: MaterialLibrary): THREE.Group;
+export declare function makeFixture(o: SiteObject, projectXY: ProjectXY, z: number, materials: MaterialLibrary, evening: boolean): THREE.Group;
+export {};

package/dist/types/map/bathMusic.d.ts

@@ -0,0 +1,14 @@
+/** An original, quiet score for the tiled baths: suspended chords and a sparse glass-bell melody.
+ * Synthesised locally, with a repeating forty-second phrase and a long stereo room tail. */
+export declare const bathMusic: (ctx: BaseAudioContext, out: AudioNode) => {
+    nodes: AudioNode[];
+    sources: (OscillatorNode | {
+        stop(): void;
+    })[];
+};
+export declare const elevatorMusic: (ctx: BaseAudioContext, out: AudioNode) => {
+    nodes: AudioNode[];
+    sources: (OscillatorNode | {
+        stop(): void;
+    })[];
+};

package/dist/types/map/cameraAim.d.ts

@@ -0,0 +1,20 @@
+import * as maplibregl from 'maplibre-gl';
+import type { Map as GLMap } from 'maplibre-gl';
+import type { Point, ProjectDocument } from '../model/types';
+export declare function cameraToCenterDistance(map: GLMap): number;
+export declare function cameraPosition(map: GLMap): {
+    lngLat: maplibregl.LngLat;
+    altitude: number;
+};
+/** fit()'s depth-aim factored out and shared with the journey: with a pitched camera a plate at
+ * elevation elev projects off-centre unless the ground target shifts by elev·tan(pitch) along the
+ * view bearing. elev must already be the PRESENTED elevation (undergroundView().focusElevation). */
+export declare function aimCenter(center: [number, number], elev: number, pitchDeg: number, bearingDeg: number): [number, number];
+/** The map centre that brings a plan position on `floorId` under the crosshair. Anyone easing to a
+ * point in the document wants this rather than the raw ground coordinate: the storey is drawn at its
+ * presented elevation, and a pitched camera sees it displaced along the view bearing, so centring on
+ * the ground beneath a basement leaves the thing you asked for a good ten metres off screen centre. */
+export declare function floorAim(map: GLMap, project: ProjectDocument, position: Point, floorId: string | null, view: {
+    threeD: boolean;
+    stack: boolean;
+}): [number, number];

package/dist/types/map/elevators.d.ts

@@ -0,0 +1,16 @@
+import type { Point, ProjectDocument, SiteObject } from '../model/types';
+export declare const cabinDimensions: (o: SiteObject) => {
+    width: number;
+    depth: number;
+};
+/** The car supplies the floor inside its footprint, even at the shaft's lowest landing. */
+export declare function cabinFloorVoids(project: ProjectDocument, floorId: string, primary: Set<string>): import("../schema").Ring[];
+export declare const elevatorDoorWidth: (o: SiteObject, turn?: number) => number;
+export declare const elevatorFacing: (o: SiteObject) => number;
+export declare const elevatorLanding: (o: SiteObject) => Point;
+export declare function insideElevator(o: SiteObject, at: Point): boolean;
+/** Shaft faces and their jambs, shared by collision and the visible cabin. */
+export declare function elevatorWalls(o: SiteObject, open: boolean): Point[][];
+/** Prefer the back wall for a mirror, and a side wall for a through-car lift. */
+export declare const elevatorMirrorFace: (o: SiteObject) => "left" | "right" | "front" | "back" | undefined;
+export declare function elevatorMirrorPoint(o: SiteObject): Point;

package/dist/types/map/excavation.d.ts

@@ -0,0 +1,9 @@
+import type { Floor, Point, ProjectDocument } from '../model/types';
+/** The excavated volume's plan outline(s). A below-grade complex is rarely just the tower footprint:
+ * parking decks sprawl past it and driveway ramps reach out to the street. Scoping the pit to a single
+ * floor plate left everything beyond it hanging in open air, so union the plates of every below-grade
+ * level with the footprints of any ramps (which are few, and are what actually reach the surface).
+ * Returns one outline per disjoint excavation; empty when there is nothing below ground. */
+export declare function excavationRings(project: ProjectDocument, levels: Floor[], ceiling?: number): Point[][];
+/** Rings that lie wholly inside another ring in the list add nothing to an excavation outline. */
+export declare function dropContained(rings: Point[][]): Point[][];

package/dist/types/map/exteriors.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectDocument } from '../model/types';
+/** Follow each floor's footprint, including stepped upper floors and courtyard edges. */
+export declare function exteriorWalls(project: ProjectDocument): Set<string>;

package/dist/types/map/features.d.ts

@@ -0,0 +1,33 @@
+import type { FeatureCollection } from 'geojson';
+import type { MaterialKind, Point, ProjectDocument, Ring, SiteObject } from '../model/types';
+import type { StatusReading } from '../model/live';
+import type { MapStyleOptions } from '../theme';
+export declare const COLORS: Record<string, string>;
+export declare const visibleOnFloor: (object: {
+    floorId: string | null;
+}, floorId: string | null) => boolean;
+/** The same question for objects that span levels. A shaft is filed under the lowest level it serves
+ *  and reaches the rest, so asking only where it is filed hides it from every storey it arrives at —
+ *  on the plan as much as in the model. Takes the project because the answer is in `servedFloorIds`. */
+export declare const onFloor: (project: ProjectDocument, object: SiteObject, floorId: string | null) => boolean;
+export declare const objectRings: (o: SiteObject) => Ring[];
+/** Roughly how wide a shape is on the plan, independent of its rotation. `width`/`depth` are an
+ *  axis-aligned bounding box, which badly overstates anything drawn on a rotated site grid — a 2.5 m
+ *  parking bay turned 55° measures nearly 5 m that way. 4·area/perimeter is the harmonic mean of a
+ *  rectangle's sides (2wh/(w+h)), so it tracks the narrow dimension and does not care about angle. */
+export declare function planWidth(o: SiteObject): number;
+export interface WallPiece {
+    ring: Ring;
+    base: number;
+    height: number;
+    id: string;
+    color: string;
+    floorId: string | null;
+    material?: MaterialKind;
+}
+export declare function wallPieces(project: ProjectDocument, floorId: string | null, stack?: boolean): WallPiece[];
+export declare function makeFeatures(project: ProjectDocument, floorId: string | null, selected: string | null, coverage: boolean, statuses?: Map<string, StatusReading>, mapStyle?: MapStyleOptions): FeatureCollection;
+/** Edit-mode nav-graph overlay data (kerros-navgraph): nodes as points, edges as lines. Vertical edges
+ * join twin shaft positions so they render as a marker-sized stub rather than a long line. */
+export declare function navGraphFeatures(project: ProjectDocument, floorId: string | null, selected: string | null): FeatureCollection;
+export declare function draftFeatures(project: ProjectDocument, points: Point[], hover: Point | null, tool: string): FeatureCollection;

package/dist/types/map/fences.d.ts

@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+import type { Point, Ring } from '../model/types';
+/** Open railing geometry for one wall piece; the piece interval already excludes gates. */
+export declare function fenceGeometry(a: Point, b: Point, ring: Ring, base: number, height: number, thickness: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;

package/dist/types/map/journey.d.ts

@@ -0,0 +1,36 @@
+import type { Map as GLMap } from 'maplibre-gl';
+import type { Origin } from '../model/types';
+import type { Route } from '../model/navigation';
+export { aimCenter, floorAim } from './cameraAim';
+export interface JourneyCallbacks {
+    /** Ask the app to switch floors; the map rebuild follows via React. */
+    requestFloor(floorId: string | null): void;
+    /** Resolves once the app shows floorId and the view has rebuilt (implemented by MapCanvas). */
+    waitForFloor(floorId: string | null): Promise<void>;
+    /** Presented elevation of a floor: undergroundView(...).focusElevation in 3D, 0 in 2D. */
+    focusElevation(floorId: string | null): number;
+    onStep(index: number): void;
+    onEnd(): void;
+}
+export declare class JourneyPlayer {
+    private map;
+    private cb;
+    private cancelled;
+    private ended;
+    private _playing;
+    private origin;
+    constructor(map: GLMap, cb: JourneyCallbacks);
+    get playing(): boolean;
+    private onGesture;
+    play(route: Route, ctx: {
+        origin: Origin;
+        startFloorId: string | null;
+    }): void;
+    /** Cancel: abort the current ease, detach listeners, fire onEnd exactly once. Never resets the
+     * camera itself — the host re-runs fit if it wants to. */
+    stop(): void;
+    private end;
+    private ease;
+    private switchFloor;
+    private run;
+}

package/dist/types/map/levels.d.ts

@@ -0,0 +1,4 @@
+/** Clearance between the floor's datum and the underside of its slab. */
+export declare const LIFT = 0.15;
+/** The slab itself. */
+export declare const SLAB = 0.18;

package/dist/types/map/lighting.d.ts

@@ -0,0 +1,103 @@
+import type { InteriorLight, Point } from '../model/types';
+export type { InteriorLight } from '../model/types';
+/** Where the sun stands, seen from a place on the earth at a moment. */
+export interface SolarPosition {
+    /** Degrees above the horizon. Negative once the sun has set. */
+    altitude: number;
+    /** Degrees clockwise from due north: 90 is east, 180 south, 270 west. */
+    azimuth: number;
+}
+/** The sun's position over `lngLat` at `when`.
+ *
+ *  The NOAA low-precision formulae: good to about a hundredth of a degree over a century either
+ *  side of 2000, which is several orders of magnitude better than a picture of a building needs and
+ *  costs a few lines of arithmetic. Time is read in UTC, so no timezone table is involved — the
+ *  earth's rotation is the clock, and a longitude is a time of day.
+ *
+ *  Atmospheric refraction is left out. It lifts a sun on the horizon by about half a degree, which
+ *  matters to an almanac and not to which way a shadow falls. */
+export declare function solarPosition(lngLat: Point, when?: Date | number): SolarPosition;
+/** How the scene is lit at a moment: where the sun is, and whether it is low enough that the model
+ *  should wear its dusk treatment. */
+export interface Sun extends SolarPosition {
+    /** Dusk: lamps on, warm low light, dark sky. True below civil twilight. */
+    evening: boolean;
+}
+/** Civil twilight. Below this the sky is no longer doing the lighting and the lamps are what you
+ *  see by — which at 60°N in June the sun only just reaches, for an hour either side of midnight,
+ *  and that is the honest picture of a white night. */
+export declare const CIVIL_TWILIGHT = -6;
+/** The sun over a project's origin at a moment, ready to light a scene with. */
+export declare function sunAt(lngLat: Point, when?: Date | number): Sun;
+/** A sun pinned to a look rather than to a clock, for the manual override and for tests. Afternoon
+ *  and dusk, at the angles the two fixed lightings used before this file knew where the sun was. */
+export declare const FIXED: Record<'day' | 'evening', Sun>;
+/** Mix two hex colours. Exported so the basemap's sky can follow the same sun the model does
+ *  rather than snapping between a day palette and a night one. */
+export declare const mixColor: (a: string, b: string, t: number) => string;
+/** Scene axes are east, north, up. Both renderers use this world-anchored sun. */
+export declare const sunlight: (sun: Sun) => {
+    position: [number, number, number];
+    color: string;
+    intensity: number;
+    mapPosition: [number, number, number];
+};
+/** The artificial light a level burns.
+ *
+ *  A building is not lit by the sky. Offices, shop floors, garages and platforms run their own
+ *  lighting through the working day and often through the night, and what colour that light is says
+ *  as much about a space as its plan does: a 4000 K fluorescent office, a 2700 K hotel corridor and
+ *  a 5000 K operating theatre are three different rooms before anything is drawn in them. So it is
+ *  a property of the floor, authored like its name and its height, rather than a render setting. */
+/** The lamps a floor is likely to be fitted with, warmest first. Fluorescent is the default because
+ *  it is what is actually overhead in most of the buildings anyone draws: offices, shops, schools,
+ *  hospitals, car parks. */
+export declare const LAMPS: {
+    id: string;
+    label: string;
+    kelvin: number;
+}[];
+/** What a floor is lit by when it does not say: a fluorescent ceiling, fully on. Most floors are
+ *  fully lit; dimming is the thing worth authoring. */
+export declare const DEFAULT_LIGHT: InteriorLight;
+/** The nearest named lamp to a colour temperature, for showing an authored number as a choice. */
+export declare const lampFor: (kelvin: number) => {
+    id: string;
+    label: string;
+    kelvin: number;
+};
+/** A colour temperature as a light colour: relative to the adapted white above, and held at one
+ *  brightness so that changing the temperature changes the TINT and nothing else. How bright a floor
+ *  is lit is the level's job, and the two must not fight each other. */
+export declare function kelvinColor(kelvin: number): string;
+/** Everything in the picture that is not the sun.
+ *
+ *  Two contributions, and they are different in kind. The SKY is daylight bouncing off the ground
+ *  and the air, so it follows the sun down and goes out with it. The INTERIOR is the building's own
+ *  lighting, and that does not follow anything: a shop floor is lit at four in the afternoon and at
+ *  four in the morning, which is why a cutaway of a storey at midnight is legible rather than black.
+ *  Kerros draws buildings from the inside, so this is most of what you are looking at. */
+export declare function ambient(sun: Sun, light?: InteriorLight): {
+    /** Hemisphere sky and ground colours, and its strength: the outdoor half. */
+    sky: string;
+    ground: string;
+    hemisphere: number;
+    /** The image-based environment, for specular life on glass and metal. */
+    environment: number;
+    /** The building's own lights: colour and strength, both from the floor, neither following the
+     *  sun. A level that says nothing is lit by a fluorescent ceiling, because most levels are.
+     *
+     *  A ceiling, which is to say it comes from ABOVE. Drawn as light arriving equally from every
+     *  direction it lit the underside of a landing as brightly as the floor under it, and to get a
+     *  floor bright enough it had to be turned up until the walls glowed — so the floor takes the
+     *  full value and a wall about half of it, which is what a room of downlights actually does. */
+    interior: string;
+    /** What comes back UP off the floor: the same lamps, much weaker, which is the half of the
+     *  picture that keeps a soffit from going black. */
+    interiorBounce: string;
+    interiorLevel: number;
+    /** How far along the fade to night the scene is: 1 in full day, 0 after civil twilight. */
+    day: number;
+    /** What the sky alone puts on a level surface, before the ceiling makes up the difference. */
+    daylight: number;
+};

package/dist/types/map/loadBasemap.d.ts

@@ -0,0 +1,4 @@
+import type { StyleSpecification } from 'maplibre-gl';
+import type { BasemapConfig } from '../model/host';
+/** Fetch the external style without replacing the working, locally rendered plan. */
+export declare function loadBasemap(config: BasemapConfig, signal: AbortSignal): Promise<StyleSpecification>;