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

package/dist/theme/index.js

@@ -0,0 +1,34 @@
+import { jsx as n } from "react/jsx-runtime";
+import { createContext as u, useMemo as i, useContext as m, useState as f, useEffect as d } from "react";
+import { en as s } from "../i18n.js";
+function h() {
+  const [e, r] = f(() => localStorage.getItem("kerros:dark") === "1");
+  return d(() => {
+    document.documentElement.classList.toggle("dark", e), localStorage.setItem("kerros:dark", e ? "1" : "0");
+  }, [e]), [e, () => r((o) => !o)];
+}
+const c = u({});
+function j({ theme: e = {}, children: r }) {
+  const o = Object.fromEntries(
+    Object.entries(e.tokens ?? {}).map(([t, a]) => [t.startsWith("--") ? t : `--${t}`, a])
+  );
+  return /* @__PURE__ */ n(c.Provider, { value: e, children: /* @__PURE__ */ n("div", { className: "kerros-root kerros-passthrough", style: o, children: r }) });
+}
+const l = () => m(c);
+function v() {
+  const { strings: e } = l();
+  return i(() => {
+    if (!e) return s;
+    const r = { ...s };
+    for (const [o, t] of Object.entries(e))
+      r[o] = t && typeof t == "object" && !Array.isArray(t) ? { ...s[o], ...t } : t;
+    return r;
+  }, [e]);
+}
+export {
+  j as KerrosThemeProvider,
+  h as useDarkMode,
+  l as useKerrosTheme,
+  v as useStrings
+};
+//# sourceMappingURL=index.js.map

package/dist/theme/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/theme/index.tsx"],"sourcesContent":["import {\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n  type ComponentType,\n  type CSSProperties,\n  type ReactNode,\n} from 'react';\nimport type { SiteObject } from '../model/types';\nimport type { StatusTone } from '../model/live';\nimport { en, type En } from '../i18n';\n\ntype DeepPartial<T> = { [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K] };\n\n/** App-wide dark mode: a `dark` class on the root element, remembered per browser. */\nexport function useDarkMode(): [boolean, () => void] {\n  const [dark, setDark] = useState(() => localStorage.getItem('kerros:dark') === '1');\n  useEffect(() => {\n    document.documentElement.classList.toggle('dark', dark);\n    localStorage.setItem('kerros:dark', dark ? '1' : '0');\n  }, [dark]);\n  return [dark, () => setDark(d => !d)];\n}\n\n// ——— Theming & pluggable chrome. Hosts wrap the viewer/editor in <KerrosThemeProvider> to override\n// design tokens, supply custom icons, and route notifications/confirms into their own UI. Every\n// field is optional; unset falls back to the built-in default, so the components work with no theme.\nexport interface ConfirmOptions {\n  title: string;\n  body?: string;\n  danger?: boolean;\n  confirmLabel?: string;\n}\n/** Plan/route/device rendering colours, per deployment (\"operation model\"). Basemap is separate (BasemapConfig). */\nexport interface MapStyleOptions {\n  /** Plan area fill and wall colour (top-down 2D). */\n  room?: string;\n  wall?: string;\n  route?: string;\n  routeActive?: string;\n  /** Selection/hover/draft highlight colours, applied on both the 2D plan and the 3D scene. */\n  selection?: string;\n  /** Soft (translucent) selection fill for areas; defaults to a light tint of the selection colour. */\n  selectionFill?: string;\n  hover?: string;\n  draft?: string;\n  statusTones?: Partial<Record<StatusTone, string>>;\n  /** Last-word override for any area/object fill and marker accent; return undefined to fall through. */\n  objectColor?: (object: SiteObject) => string | undefined;\n}\nexport interface KerrosTheme {\n  /** CSS custom-property overrides (e.g. { '--accent': '#e8562f' }); applied to the theme wrapper. */\n  tokens?: Record<string, string>;\n  /** Per kind/tool/POI-symbol icon overrides; keys match EntityIcon's `kind`/`symbol`. */\n  icons?: Record<string, ComponentType<{ size?: number }>>;\n  /** Show a transient notification. Unset → the built-in toast. */\n  notify?: (message: string, tone?: 'info' | 'error') => void;\n  /** Ask the user to confirm a destructive action. Unset → the built-in dialog. */\n  confirm?: (options: ConfirmOptions) => Promise<boolean>;\n  /** Plan/route/device rendering colours. */\n  mapStyle?: MapStyleOptions;\n  /** Override any library UI strings (deep-merged over the built-in English); read via useStrings(). */\n  strings?: DeepPartial<En>;\n}\nconst ThemeContext = createContext<KerrosTheme>({});\nexport function KerrosThemeProvider({ theme = {}, children }: { theme?: KerrosTheme; children: ReactNode }) {\n  // Only the tokens are inline — they are the one genuinely dynamic part. The wrapper's layout role\n  // (none: display:contents) is .kerros-passthrough in the stylesheet, kept apart from .kerros-root so\n  // that \"scope for the resets\" and \"box in the layout\" stay two separate, legible ideas.\n  const style = Object.fromEntries(\n    Object.entries(theme.tokens ?? {}).map(([k, v]) => [k.startsWith('--') ? k : `--${k}`, v]),\n  ) as CSSProperties;\n  return (\n    <ThemeContext.Provider value={theme}>\n      <div className=\"kerros-root kerros-passthrough\" style={style}>\n        {children}\n      </div>\n    </ThemeContext.Provider>\n  );\n}\nexport const useKerrosTheme = () => useContext(ThemeContext);\n\n// Library UI strings with the host's overrides deep-merged over the built-in English (one level of\n// nesting — tools/navigate/map — is enough for the current dictionary).\nexport function useStrings(): En {\n  const { strings } = useKerrosTheme();\n  return useMemo(() => {\n    if (!strings) return en;\n    const out = { ...en } as Record<string, unknown>;\n    for (const [k, v] of Object.entries(strings))\n      out[k] =\n        v && typeof v === 'object' && !Array.isArray(v)\n          ? { ...((en as Record<string, unknown>)[k] as object), ...v }\n          : v;\n    return out as En;\n  }, [strings]);\n}\n"],"names":["useDarkMode","dark","setDark","useState","useEffect","d","ThemeContext","createContext","KerrosThemeProvider","theme","children","style","k","v","jsx","useKerrosTheme","useContext","useStrings","strings","useMemo","en","out"],"mappings":";;;AAiBO,SAASA,IAAqC;AACnD,QAAM,CAACC,GAAMC,CAAO,IAAIC,EAAS,MAAM,aAAa,QAAQ,aAAa,MAAM,GAAG;AAClF,SAAAC,EAAU,MAAM;AACd,aAAS,gBAAgB,UAAU,OAAO,QAAQH,CAAI,GACtD,aAAa,QAAQ,eAAeA,IAAO,MAAM,GAAG;AAAA,EACtD,GAAG,CAACA,CAAI,CAAC,GACF,CAACA,GAAM,MAAMC,EAAQ,CAAAG,MAAK,CAACA,CAAC,CAAC;AACtC;AA0CA,MAAMC,IAAeC,EAA2B,EAAE;AAC3C,SAASC,EAAoB,EAAE,OAAAC,IAAQ,CAAA,GAAI,UAAAC,KAA0D;AAI1G,QAAMC,IAAQ,OAAO;AAAA,IACnB,OAAO,QAAQF,EAAM,UAAU,CAAA,CAAE,EAAE,IAAI,CAAC,CAACG,GAAGC,CAAC,MAAM,CAACD,EAAE,WAAW,IAAI,IAAIA,IAAI,KAAKA,CAAC,IAAIC,CAAC,CAAC;AAAA,EAAA;AAE3F,SACE,gBAAAC,EAACR,EAAa,UAAb,EAAsB,OAAOG,GAC5B,UAAA,gBAAAK,EAAC,OAAA,EAAI,WAAU,kCAAiC,OAAAH,GAC7C,UAAAD,EAAA,CACH,GACF;AAEJ;AACO,MAAMK,IAAiB,MAAMC,EAAWV,CAAY;AAIpD,SAASW,IAAiB;AAC/B,QAAM,EAAE,SAAAC,EAAA,IAAYH,EAAA;AACpB,SAAOI,EAAQ,MAAM;AACnB,QAAI,CAACD,EAAS,QAAOE;AACrB,UAAMC,IAAM,EAAE,GAAGD,EAAA;AACjB,eAAW,CAACR,GAAGC,CAAC,KAAK,OAAO,QAAQK,CAAO;AACzC,MAAAG,EAAIT,CAAC,IACHC,KAAK,OAAOA,KAAM,YAAY,CAAC,MAAM,QAAQA,CAAC,IAC1C,EAAE,GAAKO,EAA+BR,CAAC,GAAc,GAAGC,MACxDA;AACR,WAAOQ;AAAA,EACT,GAAG,CAACH,CAAO,CAAC;AACd;"}

package/dist/types/adapters/basemap.d.ts

@@ -0,0 +1,2 @@
+import type { BasemapConfig } from '../model/host';
+export declare const neutralBasemap: BasemapConfig;

package/dist/types/adapters/persistence.d.ts

@@ -0,0 +1,29 @@
+import type { AssetRepository, ProjectDocument, ProjectRepository, ProjectSummary } from '../model/types';
+export { validateProject } from '../model/validate';
+export { exportProject, importProject, blobDataUrl } from '../model/document';
+export declare class LocalProjectRepository implements ProjectRepository {
+    list(): Promise<ProjectSummary[]>;
+    load(id: string): Promise<ProjectDocument | null>;
+    save(project: ProjectDocument): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+/** Large documents belong in IndexedDB rather than localStorage's small synchronous quota.
+ * An optional previous repository keeps existing browser saves readable; new saves take precedence. */
+export declare class IndexedProjectRepository implements ProjectRepository {
+    private previous?;
+    private db?;
+    constructor(previous?: ProjectRepository | undefined);
+    private open;
+    list(): Promise<ProjectSummary[]>;
+    load(id: string): Promise<ProjectDocument | null>;
+    private write;
+    save(project: ProjectDocument): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare class IndexedAssetRepository implements AssetRepository {
+    private db?;
+    private open;
+    get(id: string): Promise<Blob | undefined>;
+    put(id: string, asset: Blob): Promise<void>;
+    delete(id: string): Promise<void>;
+}

package/dist/types/adapters/status.d.ts

@@ -0,0 +1,4 @@
+import type { StatusReading, StatusTone } from '../model/live';
+export declare const unknownStatus: (feedId: string) => StatusReading;
+export declare function statusTone(status?: StatusReading, now?: number): StatusTone;
+export declare function statusLabel(status?: StatusReading, now?: number): string;

package/dist/types/components/ElevatorPanel.d.ts

@@ -0,0 +1,18 @@
+import type { ElevatorControls } from '../model/host';
+import type { ProjectDocument } from '../model/types';
+import type { WalkController } from '../map/walk';
+export declare function ElevatorPanel({ project, floorId, controls, walker, riding, onRide, onFloor, requested, onWave, soundOn, onSound, }: {
+    project: ProjectDocument;
+    floorId: string | null;
+    controls: ElevatorControls;
+    walker: {
+        current: WalkController | null;
+    };
+    riding: string | null;
+    onRide(id: string | null): void;
+    onFloor?(id: string): void;
+    requested: number;
+    onWave(): void;
+    soundOn: boolean;
+    onSound(): void;
+}): import("react").JSX.Element | null;

package/dist/types/components/Icons.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectKind, SiteObject, Tool } from '../model/types';
+export declare function EntityIcon({ kind, size, symbol, travel, }: {
+    kind: ObjectKind | Tool | 'wall' | 'fence';
+    size?: number;
+    symbol?: SiteObject['symbol'];
+    /** An escalator's direction, so a descending one is not drawn with an arrow pointing up. */
+    travel?: SiteObject['travel'];
+}): import("react").JSX.Element;

package/dist/types/components/Inspector.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import type { Barrier, Drawing, Floor, ProjectDocument, SiteObject } from '../model/types';
+import type { StatusReading } from '../model/live';
+import type { StatusPanelContext } from '../model/host';
+export interface InspectorProps {
+    project: ProjectDocument;
+    floorId: string | null;
+    selected: string | null;
+    statuses: Map<string, StatusReading>;
+    /** Whether the host supplied a StatusFeed at all. False hides every live-status surface — a
+     *  rollup of bindings that can only ever read "unknown" is worse than no rollup. */
+    monitoring: boolean;
+    editing: boolean;
+    live: boolean;
+    renderStatusPanel?: (ctx: StatusPanelContext) => ReactNode;
+    onClose: () => void;
+    onUpdateObject: (id: string, patch: Partial<SiteObject>) => void;
+    /** Apply an arbitrary change through the host's commit/undo path — used for the ontology, which
+     *  edits entities beside the object rather than fields on it. */
+    onEdit?: (change: (draft: ProjectDocument) => void) => void;
+    /** Editing operations are supplied by the editor, so read-only consumers need no authoring engine. */
+    onSpaceGeometry?: (id: string, source: 'outline' | 'walls' | 'independent') => void;
+    onShiftOrigin?: (east: number, north: number) => void;
+    onUpdateBarrier: (id: string, patch: Partial<Barrier>) => void;
+    onUpdateDrawing: (id: string, patch: Partial<Drawing>) => void;
+    onUpdateFloor: (id: string, patch: Partial<Floor>) => void;
+    /** Set (or clear, with null) the floor a viewer opens this document on. */
+    onSetInitialFloor: (id: string | null) => void;
+    /** Remove a floor and everything on it (confirms first). */
+    onDeleteFloor: (id: string) => void;
+    onDuplicate: () => void;
+    onDelete: () => void;
+    onSelect: (id: string) => void;
+    /** Open a floor — a lift's levels are the one relation that crosses them. */
+    onFloor: (id: string) => void;
+    onTraceFootprint: (id: string) => void;
+}
+export declare function Inspector(props: InspectorProps): import("react").JSX.Element;

package/dist/types/components/NavigatePanel.d.ts

@@ -0,0 +1,27 @@
+import type { Point, ProjectDocument } from '../model/types';
+import type { Route } from '../model/navigation';
+export interface NavigatePanelProps {
+    project: ProjectDocument;
+    /** Where the person is — the walk's avatar — offered as "Where you are" and proposed as the
+     *  start whenever nothing else has been chosen. Null when nobody has walked yet. */
+    here?: {
+        floorId: string | null;
+        position: Point;
+    } | null;
+    from: string | null;
+    to: string | null;
+    route: Route | null;
+    playing: boolean;
+    activeStep: number | null;
+    editing: boolean;
+    onFrom: (id: string | null) => void;
+    onTo: (id: string | null) => void;
+    onSwap: () => void;
+    onClear: () => void;
+    onPlay: () => void;
+    onPause: () => void;
+    onStep: (delta: 1 | -1) => void;
+    onSeek: (index: number) => void;
+    onClose: () => void;
+}
+export declare function NavigatePanel({ project, here, from, to, route, playing, activeStep, editing, onFrom, onTo, onSwap, onClear, onPlay, onPause, onStep, onSeek, onClose, }: NavigatePanelProps): import("react").JSX.Element;

package/dist/types/components/NavigationGraph.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectDocument } from '../model/types';
+import type { StructureTarget } from './StructureView';
+export interface NavigationGraphProps {
+    project: ProjectDocument;
+    initialFloor?: string | null;
+    dark: boolean;
+    onLocate: (target: StructureTarget) => void;
+    onClose: () => void;
+}
+export declare function NavigationGraph({ project, initialFloor, dark, onLocate, onClose }: NavigationGraphProps): import("react").JSX.Element;

package/dist/types/components/StructureExplorer.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+import type { StructureViewProps } from './StructureView';
+export declare function StructureExplorer({ project, selected, onSelect, onFloorChange, onLocate, onGraphView, renderZones, }: StructureViewProps & {
+    renderZones: (filter: {
+        query: string;
+        floor: string;
+    }) => ReactNode;
+}): import("react").JSX.Element;

package/dist/types/components/StructureView.d.ts

@@ -0,0 +1,22 @@
+import { type Point, type ProjectDocument, type SiteObject, type Zone } from '../model/types';
+export interface StructureViewProps {
+    project: ProjectDocument;
+    selected?: string | null;
+    /** Fires when a space or opening is picked, so a host can follow along on the plan. */
+    onSelect?: (id: string) => void;
+    /** Fires alongside onSelect when the pick lives on a particular floor. */
+    onFloorChange?: (floorId: string | null) => void;
+    onLocate?: (target: StructureTarget) => void;
+    onGraphView?: (floorId?: string | null) => void;
+    /** Omit to keep the panel read-only. Given, the panel can author zones: the host applies the
+     *  mutation to a draft and owns undo, exactly as the map tools do. */
+    onEdit?: (change: (draft: ProjectDocument) => void) => void;
+}
+export interface StructureTarget {
+    objectIds?: string[];
+    floorId?: string | null;
+    position?: Point;
+}
+export declare function StructureView(props: StructureViewProps): import("react").JSX.Element;
+/** Exported for hosts that want the same grouping without the chrome. */
+export declare const zoneMembers: (project: ProjectDocument, zone: Zone) => SiteObject[];

package/dist/types/components/controls.d.ts

@@ -0,0 +1,52 @@
+import { type ReactNode } from 'react';
+export declare function Modal({ title, subtitle, onClose, children, wide, fullscreen, }: {
+    title: string;
+    subtitle?: string;
+    onClose: () => void;
+    children: ReactNode;
+    wide?: boolean;
+    fullscreen?: boolean;
+}): import("react").JSX.Element;
+export declare function Field({ label, value, onChange, type, suffix, min, max, step, }: {
+    label: string;
+    value: string | number;
+    onChange: (value: string) => void;
+    type?: string;
+    suffix?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}): import("react").JSX.Element;
+export declare function Toggle({ label, value, onChange, description, }: {
+    label: string;
+    value: boolean;
+    onChange: () => void;
+    description?: string;
+}): import("react").JSX.Element;
+/** A row of mutually exclusive choices, for a setting that has three answers rather than two.
+ *  Same shape as `Toggle` — label, optional description, the control on the right — so a panel of
+ *  switches does not acquire a second visual language for the one setting that needs a third state. */
+export declare function Choice<T extends string>({ label, value, options, onChange, description, }: {
+    label: string;
+    value: T;
+    options: {
+        value: T;
+        label: string;
+        title?: string;
+    }[];
+    onChange: (value: T) => void;
+    description?: string;
+}): import("react").JSX.Element;
+/** Searchable dropdown for level selection: projects like the Silo carry a hundred floors. */
+export interface FloorEntry {
+    id: string;
+    code: string;
+    name: string;
+    hint?: string;
+}
+export declare function FloorSelect({ entries, value, onPick, ariaLabel, }: {
+    entries: FloorEntry[];
+    value: string;
+    onPick: (id: string) => void;
+    ariaLabel: string;
+}): import("react").JSX.Element;

package/dist/types/components/graphLayout.d.ts

@@ -0,0 +1,9 @@
+export interface GraphPoint {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    pinned?: boolean;
+}
+/** Bounded sampled repulsion keeps large navigation graphs out of quadratic per-frame work. */
+export declare function balanceGraph(points: GraphPoint[], links: [number, number][], tick: number): void;

package/dist/types/i18n.d.ts

@@ -0,0 +1,85 @@
+export declare const en: {
+    app: string;
+    brand: string;
+    viewer: string;
+    editor: string;
+    monitor: string;
+    overview: string;
+    floors: string;
+    drawings: string;
+    objects: string;
+    import: string;
+    export: string;
+    saved: string;
+    saving: string;
+    saveError: string;
+    outdoors: string;
+    tools: {
+        select: string;
+        pan: string;
+        wall: string;
+        boundary: string;
+        partition: string;
+        fence: string;
+        zone: string;
+        room: string;
+        rectangle: string;
+        hole: string;
+        door: string;
+        window: string;
+        gate: string;
+        turnstile: string;
+        reader: string;
+        camera: string;
+        elevator: string;
+        stairs: string;
+        office: string;
+        container: string;
+        storage: string;
+        poi: string;
+        measure: string;
+        adopt: string;
+        split: string;
+        enclose: string;
+        route: string;
+        sensor: string;
+        light: string;
+        alarm: string;
+        equipment: string;
+        evacuation: string;
+    };
+    navigate: {
+        title: string;
+        from: string;
+        to: string;
+        choose: string;
+        swap: string;
+        clear: string;
+        play: string;
+        pause: string;
+        prev: string;
+        next: string;
+        walking: string;
+        floors: string;
+        steps: string;
+        noGraph: string;
+        noGraphHintEdit: string;
+        noGraphHintView: string;
+        unreachable: string;
+        unreachableHint: string;
+        pick: string;
+        here: string;
+        hereHint: string;
+        levels: string;
+        allLevels: string;
+        places: string;
+        more: string;
+    };
+    map: {
+        basemapUnavailable: string;
+        basemapUnavailablePlan: string;
+        adoptMiss: string;
+        adoptFail: string;
+    };
+};
+export type En = typeof en;

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

@@ -0,0 +1,27 @@
+import type { AssetRepository } from '../model/types';
+/** Human-only vector evidence. Never part of the model checkpoint or its conversation. */
+export interface ImportAnalysisPreview {
+    artifactId: string;
+    page: number;
+    units: 'm' | 'px' | 'pt';
+    transformId?: string;
+    metresPerUnit?: number;
+    calibration?: string;
+    svg: string;
+    /** Human-only source raster, located in the SVG display coordinate frame. */
+    background?: {
+        pngBase64: string;
+        bounds: [number, number, number, number];
+        matrix: [number, number, number, number, number, number];
+    };
+    shown: number;
+    total: number;
+    counts: Record<string, number>;
+    warnings: string[];
+}
+export declare function readAnalysisPreview(value: unknown): ImportAnalysisPreview;
+export declare function saveAnalysisPreview(assets: AssetRepository, sourceId: string, preview: ImportAnalysisPreview): Promise<void>;
+export declare function loadAnalysisPreview(assets: AssetRepository, sourceId: string): Promise<ImportAnalysisPreview | undefined>;
+export declare const deleteAnalysisPreview: (assets: AssetRepository, sourceId: string) => Promise<void>;
+/** Compose only validated local evidence. Render as an inert image, never innerHTML. */
+export declare function analysisPreviewSvg(preview: ImportAnalysisPreview, hidden?: string[], showBackground?: boolean, opacity?: number): string;

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

@@ -0,0 +1,22 @@
+/** User-supplied import scope and whole-floor exterior scale references. */
+export interface ImportBrief {
+    buildingType?: 'apartment' | 'house' | 'office' | 'retail' | 'other';
+    floorCount?: number;
+    widthMetres?: number;
+    depthMetres?: number;
+    footprintAreaM2?: number;
+}
+export declare function readImportBrief(value: unknown): ImportBrief | undefined;
+export declare function importBriefInstructions(brief?: ImportBrief): string;
+export interface SourceCalibration {
+    drawingWidth?: number;
+    drawingDepth?: number;
+    drawingArea?: number;
+    drawingLength?: number;
+    realLengthMetres?: number;
+    basis: string;
+    metresPerUnit: number;
+}
+/** Compute scale from the user's references; never let the model silently substitute a smaller
+ * real-world width. Multiple references must agree within 10% in linear scale. */
+export declare function calibrateImport(value: unknown, brief?: ImportBrief): SourceCalibration;

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

@@ -0,0 +1,49 @@
+import { type ImportBrief, type SourceCalibration } from './brief';
+import { type ImportInstruction } from './instructions';
+/** Serializable continuation state, never a second copy of project geometry or source pixels.
+ * Extraction recipes restore cached backend artifacts after a worker/container restart. */
+export interface ImportCheckpoint {
+    version: 1;
+    projectId: string;
+    brief?: ImportBrief;
+    phase: 'inspect' | 'build' | 'review';
+    notes: string;
+    sourcePlan: string;
+    calibration?: SourceCalibration;
+    mutationKinds: string[];
+    lastAssistantText: string;
+    lastToolReport: string;
+    analysis: {
+        artifactId: string;
+        sourceHash: string;
+        request: Record<string, unknown>;
+        calibration?: {
+            input: Record<string, unknown>;
+            revision: number;
+        };
+    }[];
+    decisions?: CandidateDecision[];
+    steering?: ImportInstruction[];
+}
+export interface CandidateDecision {
+    artifactId: string;
+    transformId: string;
+    floorId: string;
+    candidateId: string;
+    status: 'accepted' | 'rejected' | 'needs-review';
+    modelIds: string[];
+}
+export declare function readImportCheckpoint(value: unknown): ImportCheckpoint | undefined;
+export interface ImportBudget {
+    inputTokens: number;
+    outputTokens: number;
+    /** Maximum provider turns in this run. Omitted by older hosts: 40. */
+    maxTurns?: number;
+}
+export declare const DEFAULT_IMPORT_BUDGET: ImportBudget;
+export declare function readImportBudget(value: unknown): ImportBudget;
+export interface ImportPause {
+    reason: 'input-budget' | 'output-budget' | 'turn-limit' | 'refusals' | 'repeated-tools';
+    message: string;
+}
+export declare function readImportPause(value: unknown): ImportPause | undefined;

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

@@ -0,0 +1,7 @@
+export interface ImportInstruction {
+    id: string;
+    text: string;
+}
+export declare function readImportInstruction(value: unknown): ImportInstruction;
+/** Keep the latest human steering separately from model-authored notes. */
+export declare function mergeImportInstructions(...groups: ImportInstruction[][]): ImportInstruction[];

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/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;
+    };
+}