@kerros/editor 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, useState as i, useEffect as m, useContext as f, useMemo as d } from "react";
+import { en as s } from "../i18n.js";
+function h() {
+  const [e, r] = i(() => localStorage.getItem("kerros:dark") === "1");
+  return m(() => {
+    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 = () => f(c);
+function v() {
+  const { strings: e } = l();
+  return d(() => {
+    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/SitePlanner.d.ts

@@ -0,0 +1,5 @@
+import type { SitePlannerProps } from './model/host';
+export declare function SitePlanner({ project: initial, adapters, onChange, onSelectionChange, onBack, initialView, onViewChange, onModeChange, renderStatusPanel, elevators, readOnly, }: SitePlannerProps & {
+    readOnly?: boolean;
+}): import("react").JSX.Element;
+export declare function SiteViewer(props: SitePlannerProps): import("react").JSX.Element;

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/adapters/useProjectPersistence.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectDocument, ProjectRepository } from '../model/types';
+/** Orders writes even when a future server repository responds slowly. */
+export declare class ProjectWriter {
+    private readonly repository;
+    private queue;
+    constructor(repository: ProjectRepository);
+    save(project: ProjectDocument): Promise<void>;
+}
+export declare function useProjectPersistence(project: ProjectDocument, repository: ProjectRepository, enabled: boolean, onError: (message: string) => void): {
+    state: "error" | "saved" | "saving";
+    flush: () => Promise<void>;
+    saveNow: (snapshot: ProjectDocument) => Promise<void>;
+};

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

@@ -0,0 +1,9 @@
+import type { AiImportAdapter } from '../model/host';
+import type { AssetRepository, ProjectDocument } from '../model/types';
+export declare function AiImportPanel({ adapter, assets, onProject, onRunningChange, currentProject, }: {
+    adapter: AiImportAdapter;
+    assets: AssetRepository;
+    onProject: (project: ProjectDocument) => void | Promise<void>;
+    onRunningChange: (running: boolean) => void;
+    currentProject: ProjectDocument;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+import { type ImportAnalysisPreview } from '../import/analysisPreview';
+export declare function AnalysisPreview({ preview }: {
+    preview: ImportAnalysisPreview;
+}): import("react").JSX.Element;

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/ImportDialog.d.ts

@@ -0,0 +1,42 @@
+import type { AssetRepository, Drawing, Point, ProjectDocument } from '../model/types';
+import type { AiImportAdapter, ImportProjection, PdfDrawingAdapter } from '../model/host';
+import type { PlanEntity } from '../import/planImport';
+import type { PlanLayerMap } from '../import/types';
+export interface PreparedDrawing {
+    blob: Blob;
+    name: string;
+    width: number;
+    height: number;
+}
+export declare function ImportDialog({ project, floorId, assets, onClose, onProject, onAiProject, onAiRunningChange, onFootprints, onDrawing, onPlan, onOrigin, importProjections, aiImport, pdfDrawing, mode, }: {
+    project: ProjectDocument;
+    floorId: string | null;
+    assets: AssetRepository;
+    onClose: () => void;
+    onProject: (p: ProjectDocument) => void | Promise<void>;
+    onAiProject?: (p: ProjectDocument) => void | Promise<void>;
+    onAiRunningChange?: (running: boolean) => void;
+    onFootprints: (objects: ProjectDocument['objects']) => void;
+    onDrawing: (drawing: PreparedDrawing) => void | Promise<void>;
+    /** CAD plan entities (metres, extracted host-side — see scripts/plan-import). The handler builds
+     *  walls, rooms and openings on the chosen floor through the editor's transactional commit. */
+    onPlan?: (entities: PlanEntity[], floorId: string | null, layers?: PlanLayerMap) => void;
+    /** Turn the site to a new bearing (degrees clockwise from north) before the plan is applied. */
+    onOrigin?: (bearing: number) => void;
+    importProjections?: ImportProjection[];
+    aiImport?: AiImportAdapter;
+    pdfDrawing?: PdfDrawingAdapter;
+    mode?: 'reference' | 'plan';
+}): import("react").JSX.Element;
+export declare function AlignmentPanel({ drawing, mapPoints, imagePoints, setImagePoints, onCancel, onPreview, onConfirm, onKnownDistance, preview, }: {
+    drawing: PreparedDrawing;
+    mapPoints: Point[];
+    imagePoints: Point[];
+    setImagePoints: (points: Point[]) => void;
+    onCancel: () => void;
+    onPreview: () => void;
+    onConfirm: () => void;
+    onKnownDistance: (metres: number) => void;
+    preview: boolean;
+}): import("react").JSX.Element;
+export declare const makeDrawing: (prepared: PreparedDrawing, floorId: string | null) => Drawing;

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/editor/host.d.ts

@@ -0,0 +1,9 @@
+export type { ProjectRepository, AssetRepository, Tool } from '../model/types';
+export type { StatusFeed, StatusReading, StatusMetrics, StatusTone } from '../model/live';
+export type { SitePlannerProps, ElevatorControls, PlannerAdapters, AiImportAdapter, PdfDrawingAdapter, BasemapConfig, BasemapVectorSchema, PlannerMode, StatusPanelContext, ImportProjection, ViewState, CameraState, } from '../model/host';
+export { LocalProjectRepository, IndexedProjectRepository, IndexedAssetRepository } from '../adapters/persistence';
+export { neutralBasemap } from '../adapters/basemap';
+export { KerrosThemeProvider, useKerrosTheme, useDarkMode, useStrings, type KerrosTheme, type MapStyleOptions, type ConfirmOptions, } from '../theme';
+export * from '../schema';
+export * from '../import';
+export { StructureView, type StructureViewProps, type StructureTarget } from '../components/StructureView';

package/dist/types/editor/index.d.ts

@@ -0,0 +1,2 @@
+export { SitePlanner as FloorEditor, SiteViewer } from '../SitePlanner';
+export * from './host';

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/detect.d.ts

@@ -0,0 +1,34 @@
+import type { PlanEntity, PlanLayerMap } from './types';
+export type LayerRole = keyof PlanLayerMap;
+export declare const LAYER_ROLES: LayerRole[];
+export interface LayerReport {
+    layer: string;
+    entities: number;
+    /** Entity counts by DXF type, for the census a person reads. */
+    types: Record<string, number>;
+    /** Extent in metres. */
+    width: number;
+    height: number;
+    /** Total length of its axis-aligned segments — how much wall it could possibly describe. */
+    length: number;
+    /** Walls its own runs pair into, and their median thickness. A layer that pairs with itself is
+     *  carrying both faces, which is the case no amount of renaming fixes. */
+    selfPaired: number;
+    thickness: number;
+    /** 0..1 per role, best first in `ranked`. */
+    scores: Partial<Record<LayerRole, number>>;
+    ranked: LayerRole[];
+    /** The role this layer was assigned, if any. */
+    role?: LayerRole;
+}
+export interface LayerDetection {
+    /** Ready to hand to importPlanEntities. Roles nothing matched are left at the Vertex default. */
+    suggested: PlanLayerMap;
+    layers: LayerReport[];
+    /** Roles no layer could be found for — the ones worth asking a person about. */
+    missing: LayerRole[];
+}
+/** A regex matching exactly this layer. Layer names carry underscores, dots and accented letters. */
+export declare const layerPattern: (...names: string[]) => RegExp;
+/** Read every layer's shape, then score each against the six roles. */
+export declare function detectLayers(entities: PlanEntity[]): LayerDetection;

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

@@ -0,0 +1,2 @@
+import type { ProjectDocument } from '../schema';
+export declare function documentSvg(doc: ProjectDocument, width?: number): string;

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

@@ -0,0 +1,10 @@
+export { importPlanEntities } from './planImport';
+export { VERTEX_LAYERS } from './types';
+export { detectLayers, layerPattern, LAYER_ROLES } from './detect';
+export type { LayerDetection, LayerReport, LayerRole } from './detect';
+export type { PlanEntity, PlanImportOptions, PlanImportReport, PlanLayerMap } from './types';
+export type { AiTokenUsage } from './usage';
+export type { ImportBrief, SourceCalibration } from './brief';
+export { documentSvg } from './documentSvg';
+export { landmarks, sheetOffset, shiftEntities, type Landmark } from './register';
+export type { ImportInstruction } from './instructions';

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[];