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

package/dist/types/import/openings.d.ts

@@ -0,0 +1,22 @@
+import type { Point } from '../schema';
+import { type Wall } from './walls';
+export interface ResolvedOpening {
+    kind: 'door' | 'window';
+    /** Along-axis centre and width, in the wall's own coordinate. */
+    centre: number;
+    width: number;
+}
+export interface GapResolution {
+    gap: [number, number];
+    openings: ResolvedOpening[];
+    /** A stretch with no wall at all — the barrier must be split around it. */
+    passage?: [number, number];
+}
+/** Envelope openings: door and window symbol clusters projected onto the wall. Door clusters win
+ *  where the two overlap — a swing sweeps across the window symbols beside it. */
+export declare function resolveEnvelopeOpenings(w: Wall, doorPts: Point[], windowPts: Point[]): ResolvedOpening[];
+/** Partition gaps: the gap is the opening; symbols say the kind, and no symbol means a passage. */
+export declare function resolvePartitionGap(w: Wall, gap: [number, number], doorPts: Point[], windowPts: Point[]): GapResolution;
+/** The barrier spans a wall keeps once its passages are cut out of it. */
+export declare function barrierSpans(w: Wall, passages: [number, number][]): [number, number][];
+export declare const openingLabel: (w: Wall, o: ResolvedOpening) => string;

package/dist/types/import/planImport.d.ts

@@ -0,0 +1,22 @@
+import type { Point, ProjectDocument } from '../schema';
+import { type PlanEntity, type PlanImportOptions, type PlanImportReport } from './types';
+/** Import a floor's worth of plan entities into `draft`. Call inside a transaction. */
+export declare function importPlanEntities(draft: ProjectDocument, entities: PlanEntity[], options: PlanImportOptions): PlanImportReport;
+/** Close an oblique doorway the Manhattan pass could not see.
+ *
+ *  The reconstruction reads axis-aligned faces, which is what a Finnish prefab drawing is made of —
+ *  except where it is not. A room cut off at 45° leaves two wall ends dangling a metre or so apart
+ *  with nothing between them but the door symbol drawn across the gap, and every axis-aligned pass
+ *  drops all three: the faces because they are oblique, the wall because it has no faces, the door
+ *  because it has no wall. The region then leaks and two rooms import as one.
+ *
+ *  What the drawing is actually saying there is legible without reading oblique geometry at all: two
+ *  loose wall ends, a plausible door's distance apart, with door symbols standing on the line between
+ *  them. That is a doorway, and this bridges it — a barrier on that line carrying the door.
+ *
+ *  Deliberately conservative. It fires only between ends that nothing else has claimed, only when the
+ *  span is a door's width, and only when the drawing put a door symbol there: it can close a gap the
+ *  drawing shows a door in, and it cannot invent a wall anywhere else. */
+export declare function bridgeDoorways(draft: ProjectDocument, floorId: string | null, doorPts: Point[], report: PlanImportReport): void;
+export { VERTEX_LAYERS } from './types';
+export type { PlanEntity, PlanImportOptions, PlanImportReport, PlanLayerMap } from './types';

package/dist/types/import/register.d.ts

@@ -0,0 +1,25 @@
+import type { Point } from '../schema';
+import type { PlanEntity } from './types';
+import { type PlanLayerMap } from './types';
+/** Every entity moved by (dx, dy). Sheets are registered before import, not after: the reconstruction
+ *  snaps and welds as it goes, and moving the result would mean re-deciding all of it. */
+export declare function shiftEntities(entities: PlanEntity[], dx: number, dy: number): PlanEntity[];
+export interface Landmark {
+    centre: Point;
+    width: number;
+    height: number;
+}
+/** The blocks a layer's geometry falls into — a stair core on a plan, and nothing else on that layer.
+ *  Single-link clustering: strokes of one stair touch, and two cores are metres apart. */
+export declare function landmarks(entities: PlanEntity[], layer: RegExp): Landmark[];
+/** The shift that puts `sheet` into `reference`'s frame, or null when they share no landmark.
+ *
+ *  Matching is by SIZE: a stair core is a particular 1.87 x 2.05 m block and the one on the storey
+ *  above is the same block, while a second core at the other end of the building is a different one.
+ *  Two sheets whose stairs are the same size but in genuinely different places would register
+ *  wrongly, so the answer is only offered when exactly one pairing is plausible — a registration
+ *  that might be wrong is worse than none, because nothing downstream can tell.
+ *
+ *  Returns null for a sheet with no stair drawn on it, which a cellar entered from outside will not
+ *  have. There is nothing to match there and the caller must say where that storey goes. */
+export declare function sheetOffset(reference: PlanEntity[], sheet: PlanEntity[], layers?: PlanLayerMap): Point | null;

package/dist/types/import/runs.d.ts

@@ -0,0 +1,31 @@
+import type { Point } from '../schema';
+import type { PlanEntity } from './types';
+export interface FaceSegment {
+    axis: 'h' | 'v';
+    c: number;
+    lo: number;
+    hi: number;
+}
+export interface Run extends FaceSegment {
+    /** Bridged gaps big enough to be openings, as [lo, hi] along the run. */
+    gaps: [number, number][];
+}
+export declare const EPS = 0.02;
+/** Axis-aligned LINE/POLYLINE segments on a layer, as face segments. Oblique strokes are ignored —
+ *  this importer reads Manhattan drawings. */
+export declare function faceSegments(entities: PlanEntity[], layer: RegExp): FaceSegment[];
+/** Merge collinear fragments into runs, bridging gaps up to `bridge` metres. Gaps in the opening
+ *  size range are bridged but remembered — they are the doorways and windows. */
+export declare function mergeRuns(segments: FaceSegment[], bridge: number, openingGaps?: [number, number]): Run[];
+/** Every point a layer's geometry touches, sampled densely along strokes and arcs — the raw
+ *  material for "is there a door/window symbol standing in this opening?" scoring. */
+/** A symbol's own vertices, unsampled.
+ *
+ *  symbolPoints walks every stroke at 20 cm so a door swing reads as a cloud standing in its
+ *  opening, which is what finding a door needs. It is the wrong picture of a window: a window is
+ *  drawn as a block at each jamb with the glass between them left empty, and the sampling fills that
+ *  emptiness in at 20 cm intervals — so the one feature that says where a window begins and ends is
+ *  the one thing sampling destroys. Where the shape of the symbol is the information, read the
+ *  vertices. */
+export declare function symbolVertices(entities: PlanEntity[], layer: RegExp): Point[];
+export declare function symbolPoints(entities: PlanEntity[], layer: RegExp): Point[];

package/dist/types/import/session.d.ts

@@ -0,0 +1,33 @@
+import type { AssetRepository } from '../model/types';
+import { type ImportCheckpoint, type ImportBudget, type ImportPause } from './checkpoint';
+import { type AiTokenUsage } from './usage';
+export interface AiImportSession {
+    version: 1;
+    projectId: string;
+    sourceId: string;
+    sourceName: string;
+    sourceType: string;
+    instructions: string;
+    brief?: import('./brief').ImportBrief;
+    followUp: string;
+    tab?: 'setup' | 'analysis' | 'activity' | 'usage';
+    pendingInstructions?: import('./instructions').ImportInstruction[];
+    checkpoint?: ImportCheckpoint;
+    budget?: ImportBudget;
+    pause?: ImportPause;
+    messages: {
+        type: 'text' | 'tool' | 'user';
+        detail: string;
+        instructionId?: string;
+    }[];
+    phase: 'running' | 'done' | 'paused' | 'failed';
+    activity: string;
+    edits: number;
+    usage: AiTokenUsage;
+    hasUsage: boolean;
+    error: string;
+}
+/** Import state belongs to the host's asset store, alongside the original drawing. It is not
+ * another plan: all geometry lives in the normal project repository. */
+export declare function loadAiImportSession(assets: AssetRepository, projectId: string): Promise<AiImportSession | null>;
+export declare function saveAiImportSession(assets: AssetRepository, session: AiImportSession): Promise<void>;

package/dist/types/import/types.d.ts

@@ -0,0 +1,56 @@
+import type { Point } from '../schema';
+/** One normalized drawing entity, coordinates in metres. The shape scripts/plan-import/extract.mjs
+ *  emits with `--expand --units m`; hosts producing entities elsewhere target this. */
+export interface PlanEntity {
+    type: 'LINE' | 'POLYLINE' | 'ARC' | 'CIRCLE' | 'TEXT' | 'INSERT' | 'DIMENSION' | 'POINT';
+    layer: string;
+    a?: Point;
+    b?: Point;
+    points?: Point[];
+    closed?: boolean;
+    center?: Point;
+    r?: number;
+    start?: number;
+    end?: number;
+    at?: Point;
+    text?: string;
+    h?: number;
+    block?: string;
+    rotation?: number;
+}
+/** Which layers carry what. Defaults are the Vertex-style numbered taxonomy; override per source. */
+export interface PlanLayerMap {
+    /** Outside face of the building envelope. */
+    exteriorFace: RegExp;
+    /** Inside face of the envelope — also the outline the interior plate is traced from. */
+    interiorFace: RegExp;
+    /** Interior wall face layers; each wall is a pair of parallel runs within these. */
+    partitionFaces: RegExp;
+    /** Door symbol geometry (leaves, swings). Decides whether a wall gap is a doorway. */
+    doors: RegExp;
+    /** Window symbol geometry. Decides whether a wall gap is a window. */
+    windows: RegExp;
+    /** Room label texts. Area figures (pure numbers) are ignored automatically. */
+    labels: RegExp;
+    /** Stair treads. Optional: a sheet with no stair on it simply has none, which is a fact about the
+     *  building and not a failure. Where it is drawn, the symbol's extent is the flight's footprint. */
+    stairs?: RegExp;
+}
+export declare const VERTEX_LAYERS: PlanLayerMap;
+export interface PlanImportOptions {
+    floorId: string | null;
+    layers?: PlanLayerMap;
+}
+export interface PlanImportReport {
+    walls: number;
+    /** Flights of stairs read off the drawing. */
+    stairs: number;
+    rooms: number;
+    doors: number;
+    windows: number;
+    /** Doorless openings — stretches where the wall was split rather than sealed. */
+    passages: number;
+    named: number;
+    /** Things the drawing suggested but the import declined, each with the reason. */
+    skipped: string[];
+}

package/dist/types/import/usage.d.ts

@@ -0,0 +1,10 @@
+/** Disjoint provider-reported token counts. Input excludes cache reads and writes. */
+export interface AiTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+export declare const emptyTokenUsage: () => AiTokenUsage;
+export declare function addTokenUsage(a: AiTokenUsage, b: AiTokenUsage): AiTokenUsage;
+export declare function readTokenUsage(value: unknown): AiTokenUsage;

package/dist/types/import/walls.d.ts

@@ -0,0 +1,37 @@
+import type { Point } from '../schema';
+import type { Run } from './runs';
+export interface Wall {
+    axis: 'h' | 'v';
+    c: number;
+    lo: number;
+    hi: number;
+    thickness: number;
+    gaps: [number, number][];
+}
+/** Pair opposing face runs into walls: same axis, cross-distance within a wall thickness, intervals
+ *  overlapping. The wall sits on the centreline. `gapMode` decides what counts as an opening: for
+ *  partitions both faces must break ('both'); for the envelope the silhouette line is often drawn
+ *  continuous, so a break in either face counts ('either'). */
+export declare function pairWalls(a: Run[], b: Run[], minT: number, maxT: number, minOverlap: number, gapMode?: 'both' | 'either', 
+/** Wall extent from the pair: 'union' for the envelope (its faces fragment unevenly and corners
+ *  are closed afterwards); 'overlap' for partitions — a wall exists only where BOTH faces do,
+ *  and taking the union would stretch it over stretches where a lone line means something else. */
+extentMode?: 'union' | 'overlap'): Wall[];
+export declare const wallEnds: (w: Wall) => [Point, Point];
+export declare const along: (w: Wall, t: number) => Point;
+/** Merge an opening gap into a wall, unioning with any gap it overlaps — both faces usually report
+ *  the same opening at slightly different extents, and it must become ONE opening. */
+export declare function addGap(w: Wall, gap: [number, number]): void;
+/** Snap wall ends onto the centreline of the perpendicular wall they meet. CAD face lines are
+ *  drawn to the crossing wall's far face — or stop at its near one — so raw run extents overshoot
+ *  or undershoot T-junctions by half a thickness. Landing exactly on the centreline is what a
+ *  hand-drawn wall does in the editor, and it is what lets rendered caps disappear inside the
+ *  crossing wall instead of poking past it. */
+export declare function snapEnds(walls: Wall[], targets: Wall[], tolerance?: number): void;
+/** Extend each envelope wall to the centreline of its perpendicular neighbours, closing corners. */
+export declare function closeCorners(envelope: Wall[]): void;
+/** Chain envelope walls into the closed inner-face ring. Each corner is the intersection of two
+ *  adjacent walls' INNER faces (centreline offset half a thickness toward the building), so the
+ *  plate is the actual floor area, not the wall footprint. Handles L and T footprints; returns
+ *  null when the walls do not close into one loop. */
+export declare function traceRing(envelope: Wall[]): Point[] | null;

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

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+/** Private cabin finishes: their lighting environment is the ceiling diffuser, even in a dark
+ * basement. Metals reflect this environment; the cabin walls do not glow like the old grey box. */
+export declare class CabinMaterials {
+    readonly steel: THREE.MeshPhysicalMaterial;
+    readonly trim: THREE.MeshStandardMaterial;
+    readonly wall: THREE.MeshStandardMaterial;
+    readonly floor: THREE.MeshStandardMaterial;
+    readonly dark: THREE.MeshStandardMaterial;
+    readonly lamp: THREE.MeshBasicMaterial;
+    readonly display: THREE.MeshBasicMaterial;
+    readonly environment: THREE.Texture;
+    private target;
+    private textures;
+    private owned;
+    constructor(renderer: THREE.WebGLRenderer);
+    dispose(): void;
+}

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

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+import { Reflector } from 'three/addons/objects/Reflector.js';
+/** The head is visible in the mirror, but never surrounds the first-person camera. */
+export declare const REFLECTION_BODY = 29;
+/** MapLibre's camera encodes rotation in its projection matrix. Give the mirror a conventional
+ * view frame while preserving the exact world-to-clip mapping, including the chosen POV lens. */
+export declare function mirrorViewCamera(source: THREE.Camera, target: THREE.PerspectiveCamera): void;
+/** One live planar reflection, rendered only near a visible cabin. No recursive mirror passes. */
+export declare class CabinMirror extends Reflector {
+    private view;
+    private frames;
+    constructor(width: number, height: number);
+}

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

@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import type { SiteObject } from '../model/types';
+import type { MaterialLibrary } from './materials';
+/** Local metres: X along the opening, Y toward side A, Z up. Hardware moves with its leaf. */
+export declare function makeDoor(door: SiteObject, wallDepth: number, height: number, materials: MaterialLibrary): {
+    frame: THREE.Group<THREE.Object3DEventMap>;
+    panels: {
+        group: THREE.Group;
+        setOpen: (value: number) => void;
+    }[];
+};

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

@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+import type { SiteObject } from '../model/types';
+import type { CabinMaterials } from './CabinMaterials';
+export declare const FACE_TURN: {
+    front: number;
+    right: number;
+    back: number;
+    left: number;
+};
+export declare function makeElevatorCabin(o: SiteObject, height: number, finish: CabinMaterials, floorCode: string, moving: boolean): THREE.Group<THREE.Object3DEventMap>;
+/** The visible portion of a leaf as it retracts behind the jamb. Clipping at the opening keeps
+ * the concealed leaf inside its pocket even on shafts narrower than a full exposed door travel. */
+export declare function doorLeafSlice(gap: number, sign: number, progress: number): {
+    width: number;
+    center: number;
+};
+export declare function makeCabinDoor(gap: number, height: number, sign: number, finish: CabinMaterials): {
+    group: THREE.Group<THREE.Object3DEventMap>;
+    update: (progress: number) => void;
+};

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

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import type { Point, SiteObject } from '../model/types';
+import type { MaterialLibrary } from './materials';
+/** Occasional ballast dropouts, not a regular strobe. Stable per fixture and elapsed time. */
+export declare function fixtureOutput(id: string, seconds: number, flicker?: number): number;
+export declare const MAX_FIXTURE_LIGHTS = 4;
+/** How many of those throw shadows. A shadowed lamp is six shadow passes when it moves and a cube
+ *  of shadow taps on every pixel every frame; the two nearest carry the room, and the two beyond
+ *  them light without shadow, which nobody notices past the first two. The count is held constant
+ *  — an empty slot keeps its flag — because the shader is compiled for a number of shadowed lights
+ *  and changing that number recompiles every material in the scene. */
+export declare const SHADOWED_FIXTURE_LIGHTS = 2;
+/** All fittings are two instanced draws. Only the nearest few cast light/shadows, keeping the
+ * shader and shadow-map budget constant whether the document contains ten lamps or ten thousand. */
+export declare class FixtureLights {
+    private fixtures;
+    private points;
+    private colors;
+    private emitters;
+    private lights;
+    private active;
+    private lastFlicker;
+    private flickering;
+    constructor(scene: THREE.Scene, fixtures: SiteObject[], xy: (p: Point) => Point, base: number, materials: MaterialLibrary);
+    /** The shadows go to the nearest lamps, and stay with them until a lamp without one is clearly
+     *  nearer — a swap redraws a shadow, so a walker straddling two lamps must not swap on every step.
+     *  Always exactly SHADOWED_FIXTURE_LIGHTS flags are set, empty slots included: see the constant. */
+    private assignShadows;
+    /** Every lamp's shadow is stale — the scene changed under them. */
+    invalidate(): void;
+    update(eye: THREE.Vector3, seconds: number): {
+        shadowsChanged: boolean;
+        animate: boolean;
+    };
+}

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

@@ -0,0 +1,87 @@
+import type { Map as GLMap } from 'maplibre-gl';
+import { type AssetRepository, type Point, type ProjectDocument, type Tool } from '../model/types';
+import type { StatusReading } from '../model/live';
+import type { BasemapConfig, ElevatorControls } from '../model/host';
+import { type Sun } from './lighting';
+import type { Route } from '../model/navigation';
+import { type WalkAvatar } from './walk';
+export interface MapCanvasProps {
+    project: ProjectDocument;
+    canEdit: boolean;
+    floorId: string | null;
+    selected: string | null;
+    tool: Tool;
+    draft: Point[];
+    hover: Point | null;
+    /** Alignment hints drawn under the draft: the axis a wall is being held to, or a whole segment
+     *  the tool is offering. Both are previews — nothing here exists in the document yet. */
+    guides?: {
+        line: [Point, Point];
+        role: 'guide' | 'proposal';
+    }[];
+    threeD: boolean;
+    stack: boolean;
+    coverage: boolean;
+    showLabels: boolean;
+    showPlan: boolean;
+    /** Where the sun stands over this project now. Carries its own `evening` for the dusk look. */
+    sun: Sun;
+    dark: boolean;
+    cityBuildings: boolean;
+    cadastre: boolean;
+    basemap?: BasemapConfig;
+    assets: AssetRepository;
+    statuses: Map<string, StatusReading>;
+    elevators?: ElevatorControls;
+    /** Draw the soil section around below-grade floors. */
+    excavation?: boolean;
+    /** First-person walk mode: the camera becomes a person standing on `floorId`. Requires threeD.
+     *  While it is on the map's own gestures are off and the floor is drawn at ground level. */
+    walk?: boolean;
+    /** Walk mode wants out (Escape). */
+    onWalkExit?: () => void;
+    /** Where the walker last stood, or was dropped — the person, kept apart from the camera. Drawn on
+     *  its floor in the other modes, and a walk resumes from it when it is in view. */
+    avatar?: WalkAvatar | null;
+    /** The walker moved. Throttled to a few times a second, and once more on leaving the walk. */
+    onAvatar?: (avatar: WalkAvatar) => void;
+    /** The person marker was dropped on the map, or the avatar clicked: walk from here. */
+    onWalkAt?: (avatar: WalkAvatar) => void;
+    focusId?: string | null;
+    alignment?: {
+        image: Point[];
+        map: Point[];
+    };
+    /** Exact camera to restore (deep links); suppresses the automatic fit and 3D tilt-in on load. */
+    initialCamera?: {
+        center: [number, number];
+        zoom: number;
+        bearing: number;
+        pitch: number;
+    };
+    route?: Route | null;
+    activeStep?: number | null;
+    playing?: boolean;
+    onJourneyStep?: (index: number) => void;
+    onJourneyEnd?: () => void;
+    onRequestFloor?: (floorId: string | null) => void;
+    onClick: (point: Point, entityId: string | null) => void;
+    onHover: (point: Point, tolerance: number) => void;
+    onAdopt?: (adopted: {
+        rings: Point[][];
+        sourceId: string | number;
+        storeys: number;
+        name: string;
+    }) => void;
+    onSelect: (id: string) => void;
+    onHoverObject?: (id: string | null) => void;
+    /** Lightweight snapped preview. Model validation runs on release, before committing the drop. */
+    onVertexPreview?: (kind: 'junction' | 'barrier' | 'ring', id: string, point: Point, ring?: number, vertex?: number, free?: boolean) => Point;
+    snapping?: boolean;
+    onVertexMove(kind: 'junction' | 'ring' | 'object' | 'barrier' | 'node' | 'opening' | 'rotate' | 'coverage', id: string, point: Point, ring?: number, vertex?: number, 
+    /** Shift was held on release: take the drop exactly as given, ignoring any snapping. */
+    free?: boolean): void;
+    onError: (message: string) => void;
+    onReady?: (map: GLMap) => void;
+}
+export declare function MapCanvas(props: MapCanvasProps): import("react").JSX.Element;

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

@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+/** A small articulated passenger: tailored jacket, trousers, shoes and a recognisable face.
+ * The view uses the lower body; reflections include the head and shoulders. All motion follows
+ * the actual walker, so a mirror shows a passenger at the correct location, not a painted figure. */
+export declare class Passenger extends THREE.Group {
+    private head;
+    private arms;
+    private elbows;
+    private legs;
+    private knees;
+    private previous?;
+    private phase;
+    private yaw?;
+    private waveUntil;
+    constructor(environment: THREE.Texture);
+    wave(now: number): void;
+    update(eye: THREE.Vector3, forward: THREE.Vector3, seconds: number, dt: number): boolean;
+}