@corensystem/coren-ui 1.0.0-next.20260924.75108.887a9c2

package/dist/fragment-viewer/context.mjs

@@ -0,0 +1,168 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/fragment-viewer/context.tsx
+const FragmentViewerContext = React.createContext(null);
+const INITIAL = {
+	status: "idle",
+	error: null,
+	ready: false,
+	selection: null,
+	modelIds: [],
+	navigation: "Orbit",
+	projection: "Perspective",
+	interaction: null,
+	clippingEnabled: true,
+	ghost: false,
+	cinematic: false,
+	storeys: [],
+	activeStorey: null,
+	heading: 0
+};
+function FragmentViewerProvider({ children }) {
+	const [state, setState] = React.useState(INITIAL);
+	const viewportRef = React.useRef(null);
+	const patch = React.useCallback((next) => {
+		setState((prev) => ({
+			...prev,
+			...next
+		}));
+	}, []);
+	const register = React.useCallback((viewport) => {
+		viewportRef.current = viewport;
+		setState((prev) => viewport ? {
+			...prev,
+			ready: true
+		} : { ...INITIAL });
+	}, []);
+	const api = React.useMemo(() => {
+		const of = () => viewportRef.current;
+		return {
+			viewport: of,
+			async fit() {
+				await of()?.fit();
+			},
+			setNavigation(mode) {
+				of()?.setNavigation(mode);
+				patch({ navigation: mode });
+			},
+			async toggleProjection() {
+				const next = await of()?.toggleProjection();
+				if (next) patch({ projection: next });
+			},
+			setInteraction(mode) {
+				setState((prev) => {
+					const next = prev.interaction === mode ? null : mode;
+					of()?.setInteraction(next);
+					return {
+						...prev,
+						interaction: next
+					};
+				});
+			},
+			toggleClipping() {
+				const enabled = of()?.toggleClipping();
+				if (enabled !== void 0) patch({ clippingEnabled: enabled });
+			},
+			clearSections() {
+				of()?.clearSections();
+			},
+			clearMeasurements() {
+				of()?.clearMeasurements();
+			},
+			async hideSelection() {
+				await of()?.hideSelection();
+			},
+			async isolateSelection() {
+				await of()?.isolateSelection();
+			},
+			async showAll() {
+				await of()?.showAll();
+				patch({ activeStorey: null });
+			},
+			setPostproduction(enabled) {
+				of()?.setPostproduction(enabled);
+			},
+			async setGhost(enabled) {
+				await of()?.setGhost(enabled);
+				patch({ ghost: enabled });
+			},
+			setCinematic(enabled) {
+				const active = of()?.setCinematic(enabled);
+				patch({ cinematic: active ?? false });
+			},
+			async loadStoreys() {
+				const storeys = await of()?.storeys() ?? [];
+				patch({ storeys });
+			},
+			async openStorey(id) {
+				patch({ activeStorey: id });
+				await of()?.openStorey(id);
+			},
+			async closeStorey() {
+				patch({ activeStorey: null });
+				await of()?.closeStorey();
+			},
+			setMarkers(markers, options) {
+				of()?.setMarkers(markers, options);
+			},
+			clearMarkers() {
+				of()?.clearMarkers();
+			},
+			bounds() {
+				return of()?.bounds() ?? null;
+			},
+			async storeyFootprints() {
+				return await of()?.storeyFootprints() ?? {};
+			}
+		};
+	}, [patch]);
+	const value = React.useMemo(() => ({
+		state,
+		api,
+		register,
+		patch
+	}), [
+		state,
+		api,
+		register,
+		patch
+	]);
+	return /* @__PURE__ */ jsx(FragmentViewerContext.Provider, {
+		value,
+		children
+	});
+}
+/** Read viewer state and drive the engine. Must be called under a FragmentViewerProvider. */
+function useFragmentViewer() {
+	const context = React.useContext(FragmentViewerContext);
+	if (!context) throw new Error("useFragmentViewer must be used within a FragmentViewerProvider");
+	return {
+		state: context.state,
+		api: context.api
+	};
+}
+/**
+* Viewer state and engine when there is a provider, or `null` when there is not.
+*
+* The null-tolerant twin of {@link useFragmentViewer}, for a surface whose stage may or may not be a
+* FragmentViewer — Workforce Map View renders a placeholder plan when it is not. Callers used to get
+* this by wrapping `useFragmentViewer()` in a try/catch, which reads as a conditional hook call (and
+* oxlint's `react-hooks(rules-of-hooks)` rejects it), besides swallowing every other error the hook
+* might raise. Reading the context directly is both honest and unconditional.
+*/
+function useOptionalFragmentViewer() {
+	const context = React.useContext(FragmentViewerContext);
+	if (!context) return null;
+	return {
+		state: context.state,
+		api: context.api
+	};
+}
+/** Internal wiring for FragmentViewer. Returns null outside a provider so the viewer can stand alone. */
+function useFragmentViewerRegistration() {
+	return React.useContext(FragmentViewerContext);
+}
+//#endregion
+export { FragmentViewerProvider, useFragmentViewer, useFragmentViewerRegistration, useOptionalFragmentViewer };
+
+//# sourceMappingURL=context.mjs.map

package/dist/fragment-viewer/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"sources":["../../src/fragment-viewer/context.tsx"],"sourcesContent":["import * as React from \"react\";\n\nimport type {\n\tFragmentMarker,\n\tFragmentSelection,\n\tFragmentStorey,\n\tFragmentViewport,\n\tFragmentViewportStatus,\n\tInteractionMode,\n\tNavigationMode,\n\tProjectionMode,\n} from \"./runtime\";\n\n/**\n * Shared state between FragmentViewer (the canvas) and ViewerToolbar (the chrome).\n *\n * A context rather than an imperative ref because the toolbar has to *reflect* engine state — which\n * projection is active, which tool is armed — not just fire at it. Both components mount under one\n * FragmentViewerProvider; the template composes them however it likes.\n */\n\nexport interface FragmentViewerState {\n\tstatus: FragmentViewportStatus;\n\terror: Error | null;\n\t/** True once a viewport has mounted and registered itself. */\n\tready: boolean;\n\tselection: FragmentSelection | null;\n\tmodelIds: string[];\n\tnavigation: NavigationMode;\n\tprojection: ProjectionMode;\n\t/** Armed tool: what a double-click will do. */\n\tinteraction: InteractionMode;\n\t/** Whether existing clipping planes are active (they persist while disabled). */\n\tclippingEnabled: boolean;\n\t/** Whole model faded back so selections and sections read clearly. */\n\tghost: boolean;\n\t/** Cinematic mode (shadows + AO + bloom + beams + tone mapping) is on. Full navigation stays live. */\n\tcinematic: boolean;\n\tstoreys: FragmentStorey[];\n\tactiveStorey: string | null;\n\t/** Camera yaw (azimuth) in degrees, updated as the model is orbited. Lets chrome like the site\n\t * minimap rotate to stay aligned with the view. */\n\theading: number;\n}\n\nexport interface FragmentViewerApi {\n\tfit(): Promise<void>;\n\tsetNavigation(mode: NavigationMode): void;\n\ttoggleProjection(): Promise<void>;\n\t/** Arm a tool, or pass null to return to plain selection. Re-arming the same tool disarms it. */\n\tsetInteraction(mode: InteractionMode): void;\n\ttoggleClipping(): void;\n\tclearSections(): void;\n\tclearMeasurements(): void;\n\thideSelection(): Promise<void>;\n\tisolateSelection(): Promise<void>;\n\tshowAll(): Promise<void>;\n\tsetPostproduction(enabled: boolean): void;\n\t/** Fade the model back (or restore it). */\n\tsetGhost(enabled: boolean): Promise<void>;\n\t/** Toggle cinematic mode (shadows + AO + bloom + beams + tone mapping). */\n\tsetCinematic(enabled: boolean): void;\n\t/** Derive storey views from the IFC spatial structure. Cached in state afterwards. */\n\tloadStoreys(): Promise<void>;\n\topenStorey(id: string): Promise<void>;\n\tcloseStorey(): Promise<void>;\n\t/** Draw point markers (workers, sensors…) — one InstancedMesh, so thousands stay cheap. */\n\tsetMarkers(markers: FragmentMarker[], options?: {radius?: number; color?: string; occluded?: boolean}): void;\n\tclearMarkers(): void;\n\t/** The whole model's world-space bounding box, for placing markers across the footprint. */\n\tbounds(): {min: [number, number, number]; max: [number, number, number]} | null;\n\t/** Each storey's world-space box (real footprint + height), keyed by storey id. */\n\tstoreyFootprints(): Promise<Record<string, {min: [number, number, number]; max: [number, number, number]}>>;\n\t/** The underlying viewport, for callers that need the raw SDK. */\n\tviewport(): FragmentViewport | null;\n}\n\ninterface ContextValue {\n\tstate: FragmentViewerState;\n\tapi: FragmentViewerApi;\n\t/** Called by FragmentViewer on mount/unmount. Not for application code. */\n\tregister: (viewport: FragmentViewport | null) => void;\n\tpatch: (next: Partial<FragmentViewerState>) => void;\n}\n\nconst FragmentViewerContext = React.createContext<ContextValue | null>(null);\n\nconst INITIAL: FragmentViewerState = {\n\tstatus: \"idle\",\n\terror: null,\n\tready: false,\n\tselection: null,\n\tmodelIds: [],\n\tnavigation: \"Orbit\",\n\tprojection: \"Perspective\",\n\tinteraction: null,\n\tclippingEnabled: true,\n\tghost: false,\n\tcinematic: false,\n\tstoreys: [],\n\tactiveStorey: null,\n\theading: 0,\n};\n\nexport function FragmentViewerProvider({children}: {children: React.ReactNode}) {\n\tconst [state, setState] = React.useState<FragmentViewerState>(INITIAL);\n\tconst viewportRef = React.useRef<FragmentViewport | null>(null);\n\n\tconst patch = React.useCallback((next: Partial<FragmentViewerState>) => {\n\t\tsetState((prev) => ({...prev, ...next}));\n\t}, []);\n\n\tconst register = React.useCallback((viewport: FragmentViewport | null) => {\n\t\tviewportRef.current = viewport;\n\t\tsetState((prev) => (viewport ? {...prev, ready: true} : {...INITIAL}));\n\t}, []);\n\n\tconst api = React.useMemo<FragmentViewerApi>(() => {\n\t\tconst of = () => viewportRef.current;\n\t\treturn {\n\t\t\tviewport: of,\n\t\t\tasync fit() {\n\t\t\t\tawait of()?.fit();\n\t\t\t},\n\t\t\tsetNavigation(mode) {\n\t\t\t\tof()?.setNavigation(mode);\n\t\t\t\tpatch({navigation: mode});\n\t\t\t},\n\t\t\tasync toggleProjection() {\n\t\t\t\tconst next = await of()?.toggleProjection();\n\t\t\t\tif (next) patch({projection: next});\n\t\t\t},\n\t\t\tsetInteraction(mode) {\n\t\t\t\tsetState((prev) => {\n\t\t\t\t\t// Clicking the armed tool again disarms it — how every BIM viewer behaves.\n\t\t\t\t\tconst next = prev.interaction === mode ? null : mode;\n\t\t\t\t\tof()?.setInteraction(next);\n\t\t\t\t\treturn {...prev, interaction: next};\n\t\t\t\t});\n\t\t\t},\n\t\t\ttoggleClipping() {\n\t\t\t\tconst enabled = of()?.toggleClipping();\n\t\t\t\tif (enabled !== undefined) patch({clippingEnabled: enabled});\n\t\t\t},\n\t\t\tclearSections() {\n\t\t\t\tof()?.clearSections();\n\t\t\t},\n\t\t\tclearMeasurements() {\n\t\t\t\tof()?.clearMeasurements();\n\t\t\t},\n\t\t\tasync hideSelection() {\n\t\t\t\tawait of()?.hideSelection();\n\t\t\t},\n\t\t\tasync isolateSelection() {\n\t\t\t\tawait of()?.isolateSelection();\n\t\t\t},\n\t\t\tasync showAll() {\n\t\t\t\tawait of()?.showAll();\n\t\t\t\tpatch({activeStorey: null});\n\t\t\t},\n\t\t\tsetPostproduction(enabled) {\n\t\t\t\tof()?.setPostproduction(enabled);\n\t\t\t},\n\t\t\tasync setGhost(enabled) {\n\t\t\t\tawait of()?.setGhost(enabled);\n\t\t\t\tpatch({ghost: enabled});\n\t\t\t},\n\t\t\tsetCinematic(enabled) {\n\t\t\t\tconst active = of()?.setCinematic(enabled);\n\t\t\t\tpatch({cinematic: active ?? false});\n\t\t\t},\n\t\t\tasync loadStoreys() {\n\t\t\t\tconst storeys = (await of()?.storeys()) ?? [];\n\t\t\t\tpatch({storeys});\n\t\t\t},\n\t\t\tasync openStorey(id) {\n\t\t\t\tpatch({activeStorey: id});\n\t\t\t\tawait of()?.openStorey(id);\n\t\t\t},\n\t\t\tasync closeStorey() {\n\t\t\t\tpatch({activeStorey: null});\n\t\t\t\tawait of()?.closeStorey();\n\t\t\t},\n\t\t\tsetMarkers(markers, options) {\n\t\t\t\tof()?.setMarkers(markers, options);\n\t\t\t},\n\t\t\tclearMarkers() {\n\t\t\t\tof()?.clearMarkers();\n\t\t\t},\n\t\t\tbounds() {\n\t\t\t\treturn of()?.bounds() ?? null;\n\t\t\t},\n\t\t\tasync storeyFootprints() {\n\t\t\t\treturn (await of()?.storeyFootprints()) ?? {};\n\t\t\t},\n\t\t};\n\t}, [patch]);\n\n\tconst value = React.useMemo<ContextValue>(() => ({state, api, register, patch}), [state, api, register, patch]);\n\n\treturn <FragmentViewerContext.Provider value={value}>{children}</FragmentViewerContext.Provider>;\n}\n\n/** Read viewer state and drive the engine. Must be called under a FragmentViewerProvider. */\nexport function useFragmentViewer(): {state: FragmentViewerState; api: FragmentViewerApi} {\n\tconst context = React.useContext(FragmentViewerContext);\n\tif (!context) throw new Error(\"useFragmentViewer must be used within a FragmentViewerProvider\");\n\treturn {state: context.state, api: context.api};\n}\n\n/**\n * Viewer state and engine when there is a provider, or `null` when there is not.\n *\n * The null-tolerant twin of {@link useFragmentViewer}, for a surface whose stage may or may not be a\n * FragmentViewer — Workforce Map View renders a placeholder plan when it is not. Callers used to get\n * this by wrapping `useFragmentViewer()` in a try/catch, which reads as a conditional hook call (and\n * oxlint's `react-hooks(rules-of-hooks)` rejects it), besides swallowing every other error the hook\n * might raise. Reading the context directly is both honest and unconditional.\n */\nexport function useOptionalFragmentViewer(): {state: FragmentViewerState; api: FragmentViewerApi} | null {\n\tconst context = React.useContext(FragmentViewerContext);\n\tif (!context) return null;\n\treturn {state: context.state, api: context.api};\n}\n\n/** Internal wiring for FragmentViewer. Returns null outside a provider so the viewer can stand alone. */\nexport function useFragmentViewerRegistration(): Pick<ContextValue, \"register\" | \"patch\"> | null {\n\treturn React.useContext(FragmentViewerContext);\n}\n"],"mappings":"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"}

package/dist/fragment-viewer/runtime.d.mts

@@ -0,0 +1,288 @@
+import * as OBC from "@thatopen/components";
+import * as OBF from "@thatopen/components-front";
+//#region src/fragment-viewer/runtime.d.ts
+/**
+ * Fragments viewport: a container in, a navigable BIM model out.
+ *
+ * Framework-free on purpose — FragmentViewer is a thin React wrapper over this, the same way
+ * `map.tsx` wraps mapbox-gl, and ViewerToolbar drives it through these same public methods.
+ *
+ * Built on @thatopen/components + components-front rather than raw three.js, because every control
+ * a BIM viewer needs already exists there: orbit/first-person/plan navigation, ortho projection,
+ * clipping planes, four measurement tools, hide/isolate, storey views, item data. Re-deriving those
+ * would be weeks of work with worse results. The setup follows WC3's own 3.4.6 viewer.
+ *
+ * All three That Open packages are optional peer dependencies, reachable only through the
+ * `@corensystem/coren-ui/fragment-viewer` subpath.
+ */
+/**
+ * Navigation modes offered to the user. Both sit on the SDK's "Orbit" mode: `Pan` simply drags the
+ * camera on left-drag instead of rotating it, which is how CAD tools present it. The SDK's other
+ * modes (FirstPerson, Plan) are deliberately not exposed — Plan overlaps with Levels, and
+ * FirstPerson is a different product decision.
+ */
+export type NavigationMode = "Orbit" | "Pan";
+export type MeasurementKind = "length" | "area" | "angle" | "volume";
+/** What a double-click does. `null` leaves clicks to plain selection. */
+export type InteractionMode = "section" | MeasurementKind | null;
+export type ProjectionMode = "Perspective" | "Orthographic";
+export type FragmentViewportStatus = "idle" | "loading" | "ready" | "error";
+export interface FragmentSelection {
+  /** Number of highlighted elements across all models. */
+  itemCount: number;
+  /** IFC category of the first picked element, when resolvable. */
+  category?: string | null;
+  /** IFC GUID of the first picked element, when resolvable. */
+  guid?: string | null;
+  /** Raw per-item data from Fragments, for callers wanting more than the summary. */
+  data: unknown[];
+}
+/** A point marker drawn in the model — a worker, sensor, or anything else with a position. */
+export interface FragmentMarker {
+  id: string;
+  /** Position in the model's own coordinate frame, metres. */
+  position: [number, number, number];
+  /** CSS colour. Defaults to the viewport's marker colour. */
+  color?: string;
+}
+/** A storey view derived from the IFC spatial structure, for the Levels control. */
+export interface FragmentStorey {
+  id: string;
+  name: string;
+  /** World-space elevation of the floor, metres — lets callers place things on it (e.g. worker markers). */
+  elevation: number;
+}
+export interface FragmentViewportOptions {
+  /** URL of the Fragments worker. Vite consumers: `import url from "@thatopen/fragments/worker?url"`. */
+  workerUrl: string;
+  /** Scene background. `null` leaves the canvas transparent. */
+  background?: string | null;
+  /** Highlight colour for picked elements. */
+  selectionColor?: string;
+  /**
+   * Show the underlying SDK logo over the canvas. The React wrapper defaults this to false; direct
+   * runtime consumers may opt in explicitly.
+   */
+  showLogo?: boolean;
+  /**
+   * Floor-only picking: a click selects the storey the element belongs to instead of the element
+   * itself (no per-element highlight). The resolved storey id is reported via `onStoreyPick`.
+   */
+  selectFloorsOnly?: boolean;
+  /** Fires when a click resolves to a storey (only in `selectFloorsOnly` mode). */
+  onStoreyPick?: (storeyId: string) => void;
+  /** Animate the camera when first framing the model on load. Default true. Set false to jump the
+   * camera to the framed position instantly — useful when the viewer is revealed by an outer
+   * transition and its own zoom-in would double up. */
+  fitAnimation?: boolean;
+  /** Frame only the elements whose IFC category matches one of these patterns (e.g. the building
+   * shell) instead of the whole model. Keeps stray/site/annotation geometry from zooming the camera
+   * out. Falls back to the whole model when nothing matches. */
+  fitCategories?: RegExp[];
+  /** Multiply the fit distance. Default 1; below 1 frames tighter (closer), above 1 pulls back. */
+  fitFactor?: number;
+  onStatusChange?: (status: FragmentViewportStatus, error?: Error) => void;
+  onSelectionChange?: (selection: FragmentSelection | null) => void;
+  onModelsChange?: (modelIds: string[]) => void;
+  /** Fires as the camera orbits, reporting its yaw (azimuth) in degrees. Lets external chrome — e.g.
+   * a site minimap — rotate to stay aligned with the view. Throttled to meaningful changes. */
+  onHeadingChange?: (headingDeg: number) => void;
+}
+export declare class FragmentViewport {
+  readonly components: OBC.Components;
+  readonly world: OBC.SimpleWorld<OBC.SimpleScene, OBC.OrthoPerspectiveCamera, OBF.PostproductionRenderer>;
+  private readonly container;
+  private readonly options;
+  private readonly fragments;
+  private readonly highlighter;
+  /** GPU picker used only in floor-only mode (the highlighter is disabled there). */
+  private picker;
+  private readonly clipper;
+  private readonly grid;
+  private readonly measurements;
+  private readonly resizeObserver;
+  private readonly originalMaterials;
+  private markers;
+  private markerIds;
+  private markerCapacity;
+  private markerRadius;
+  private markerOccluded;
+  private selection;
+  private interaction;
+  private clippingEnabled;
+  private ghostStyle;
+  private storeyBands;
+  private ghostedStorey;
+  /** Cached per-element storey assignment (modelId → localId → storeyId). Avoids re-scanning geometry
+   *  on every floor switch, and lets openStorey apply only the *delta* in ghosting (no full un-ghost
+   *  flash). Invalidated when storeys are recomputed. */
+  private elementStoreys;
+  /** Last emitted camera yaw (deg); NaN until the first tick so the initial heading always fires. */
+  private lastHeadingDeg;
+  /** Cinematic mode (sun shadows + AO + bloom + beams + tone mapping). Built lazily on first enable. */
+  private cinematic;
+  private disposed;
+  constructor(container: HTMLElement, options: FragmentViewportOptions);
+  /** Fetch and display a `.frag`, then frame everything loaded. */
+  load(src: string, modelId: string): Promise<void>;
+  unload(modelId: string): Promise<void>;
+  get modelIds(): string[];
+  /** Frame the loaded models — or, when `fitCategories` is set, only the elements in those categories
+   * (e.g. the building shell), so stray/site geometry doesn't zoom the camera out. */
+  fit(): Promise<void>;
+  /**
+   * Sit the ground grid at the base of the loaded geometry instead of world Y=0.
+   *
+   * The grid is created at Y=0, but nothing guarantees a model's ground floor lives there: this
+   * building is authored with its origin up near the penthouse, so the whole tower hangs *below*
+   * Y=0 and the grid slices through the top floor. Snapping the grid to the model's own min-Y drops
+   * the reference plane back under the ground floor, where "the ground" belongs. Only the grid moves,
+   * so every coordinate the rest of the viewport works in (storeys, markers, sections) is untouched.
+   */
+  private groundGrid;
+  /** Bounding box of all loaded geometry. */
+  private wholeModelBox;
+  /** Union of the bounding boxes of the given categories across every model, or null if none matched
+   * (so the caller falls back to the whole model). */
+  private categoryBox;
+  setNavigation(mode: NavigationMode): void;
+  /**
+   * Swap what a left-drag does. camera-controls exposes its action enum as a static on the class;
+   * read it off the instance's constructor rather than importing camera-controls directly, which
+   * would add a dependency purely for two constants.
+   */
+  private setLeftDrag;
+  /**
+   * Toggle cinematic mode (sun cast-shadows + ambient occlusion + bloom + volumetric beams + ACES tone
+   * mapping) and return the state now active.
+   *
+   * Full navigation stays live while on — orbit, pan and zoom — so you can turn the model in the light.
+   * Turning it off restores every renderer/scene mutation and frees all GPU resources, so it costs
+   * nothing (memory or frame time) while off.
+   */
+  setCinematic(enabled: boolean): boolean;
+  get cinematicActive(): boolean;
+  /** Swap perspective <-> orthographic and return the mode now active. */
+  toggleProjection(): Promise<ProjectionMode>;
+  get projection(): ProjectionMode;
+  /**
+   * Choose what a double-click does: place a clipping plane, start a measurement, or nothing
+   * (leaving clicks to selection). Only one at a time, mirroring the toolbar's radio behaviour.
+   */
+  setInteraction(mode: InteractionMode): void;
+  get interactionMode(): InteractionMode;
+  /** Enable/disable existing planes without deleting them; returns the state now active. */
+  toggleClipping(): boolean;
+  clearSections(): void;
+  clearMeasurements(): void;
+  hideSelection(): Promise<void>;
+  isolateSelection(): Promise<void>;
+  /**
+   * Restore everything: un-hide every element and leave any open storey view.
+   *
+   * Both halves are needed. `Hider.set(true)` alone leaves an open storey still filtering the model,
+   * so the user clicks "Show all" and still sees one floor; closing the view alone leaves anything
+   * hidden or isolated by hand still hidden.
+   */
+  showAll(): Promise<void>;
+  get ghost(): boolean;
+  /**
+   * Fade the whole model to translucent glass so selections, sections and markers read through it —
+   * "ghost mode" in every BIM viewer. Two parts matter for it to look clean rather than a wall of
+   * white lines:
+   *
+   *  - The postproduction edge pass is turned off. It outlines every element, and over faded
+   *    geometry those crisp edges stack into the bright white grid you would otherwise see.
+   *  - Faces fade to a cool grey, not pure white, and don't write depth — so you see *through* the
+   *    building to a soft translucent shell, the way BIMCamel and the SDK's own ghost look.
+   */
+  setGhost(enabled: boolean): Promise<void>;
+  setPostproduction(enabled: boolean): void;
+  /**
+   * Draw point markers in the model. One InstancedMesh for the whole set: thousands of separate
+   * meshes would be thousands of draw calls and would stall the frame, while instancing draws them
+   * all in one and scales to tens of thousands.
+   *
+   * Radius defaults to a fraction of the model's diagonal, so markers read at a sensible size
+   * whether the model is a villa or a city block, and regardless of the file's units.
+   */
+  setMarkers(markers: FragmentMarker[], options?: {
+    radius?: number;
+    color?: string;
+    occluded?: boolean;
+  }): void;
+  clearMarkers(): void;
+  get markerCount(): number;
+  /** ~1/300th of the model diagonal: about 0.5 m on a 150 m building, which reads as a person. */
+  private defaultMarkerRadius;
+  /**
+   * Storeys from the IFC spatial structure. We don\'t use the SDK\'s storey plan-views: they cut a thin
+   * horizontal slab that, on a multi-storey tower, lands between floors and shows nothing. Instead a
+   * level is shown by ghosting every element not tagged to that storey (see `ensureElementStoreys`),
+   * which keeps the 3D view. The elevation bands built here are kept only for the known-storey guard in
+   * `openStorey` and the storey elevation metadata returned below.
+   */
+  storeys(): Promise<FragmentStorey[]>;
+  /** The whole model's world-space bounding box, as plain arrays (null if nothing is loaded). */
+  bounds(): {
+    min: [number, number, number];
+    max: [number, number, number];
+  } | null;
+  /**
+   * Emphasise one storey: keep its elements in their real materials and fade every other storey to
+   * translucent grey, so the level reads in context rather than floating alone. Done with a
+   * per-element highlight on the *other* storeys — a material swap wouldn't work, because Fragments
+   * materials are shared across storeys, so fading one fades all.
+   */
+  openStorey(id: string): Promise<void>;
+  closeStorey(): Promise<void>;
+  /**
+   * Assign every element to a storey from the model's real IFC spatial structure — the
+   * `IfcRelContainedInSpatialStructure` tags surfaced by the Classifier's `byIfcBuildingStorey`,
+   * grouped by storey name (the same key `openStorey`/`storeyBands` use). Cached once; reused by the
+   * ghosting delta and the per-storey footprints.
+   *
+   * We read the authored floor tags rather than guessing each element's storey from its centre
+   * elevation: band-guessing breaks when the model's origin is offset from world Y=0 (this villa hangs
+   * ~12.8 m below it), so the element boxes and the storey planes land in different frames, nothing
+   * falls in a band, and every floor click ended up un-ghosted.
+   */
+  private ensureElementStoreys;
+  /** Group every element by its containing IFCBUILDINGSTOREY (the `ContainsElements` relation),
+   *  keyed by the storey's Name — the same key `openStorey`/`storeyBands` use. Empty when the model has
+   *  no such relation. */
+  private storeysFromIfcTags;
+  /** Fallback assignment: bucket each element into a storey by its centre elevation. Only correct when
+   *  the model geometry shares the frame of the storey planes (origin near world Y=0). */
+  private storeysFromElevationBands;
+  /**
+   * The world-space bounding box of each storey's own elements — the real footprint and height of
+   * every floor. Lets callers place things *inside* a level (e.g. worker markers) rather than across
+   * the whole building.
+   */
+  storeyFootprints(): Promise<Record<string, {
+    min: [number, number, number];
+    max: [number, number, number];
+  }>>;
+  /** Clear the fade applied to non-selected storeys. */
+  private resetStoreyGhost;
+  /**
+   * Floor-only picking: GPU-pick the element under the pointer, resolve its storey, and report it so the
+   * host isolates that floor. Runs off the highlighter entirely, so element selection never fights the
+   * storey ghosting (which is what made floor→floor switching invert).
+   */
+  private pickFloorAtPointer;
+  private publishSelection;
+  private readonly resize;
+  private pointerDownAt;
+  private readonly onPointerDown;
+  private readonly onPointerUp;
+  private readonly onDoubleClick;
+  private useArmedTool;
+  private readonly onKeyDown;
+  private ensureActive;
+  /** Release the WebGL context and every listener. Must run on unmount or contexts leak. */
+  dispose(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=runtime.d.mts.map

package/dist/fragment-viewer/runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../../src/fragment-viewer/runtime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;YA4BY;YACA;;YAEA,8BAA8B;YAC9B;YACA;iBAEK;;EAEhB;;EAEA;;EAEA;;EAEA;;;iBAIgB;EAChB;;EAEA;;EAEA;;;iBAIgB;EAChB;EACA;;EAEA;;iBAGgB;;EAEhB;;EAEA;;EAEA;;;;;EAKA;;;;;EAKA;;EAEA,gBAAgB;;;;EAIhB;;;;EAIA,gBAAgB;;EAEhB;EACA,kBAAkB,QAAQ,wBAAwB,QAAQ;EAC1D,qBAAqB,WAAW;EAChC,kBAAkB;;;EAGlB,mBAAmB;;qBAgDP;WACH,YAAY,IAAI;WAChB,OAAO,IAAI,YAAY,IAAI,aAAa,IAAI,wBAAwB,IAAI;mBAEhE;mBACA;mBACA;mBACA;;UAET;mBACS;mBACA;mBACA;mBAEA;mBACA;UAIT;UACA;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;;;UAIA;;UAEA;;UAEA;UACA;EAEI,YAAA,WAAW,aAAa,SAAS;;EAkJvC,KAAK,aAAa,kBAAkB;EAmBpC,OAAO,kBAAkB;MAK3B;;;EAQE,OAAO;;;;;;;;;;UAqBL;;UAOA;;;UAWM;EAiBd,cAAc,MAAM;;;;;;UAUZ;;;;;;;;;EAkBR,aAAa;MAWT;;EAKE,oBAAoB,QAAQ;MAM9B,cAAc;;;;;EAUlB,eAAe,MAAM;MASjB,mBAAmB;;EAKvB;EAMA;EAIA;EAMM,iBAAiB;EAMjB,oBAAoB;;;;;;;;EAYpB,WAAW;MAKb;;;;;;;;;;;EAcE,SAAS,mBAAmB;EA2ClC,kBAAkB;;;;;;;;;EAclB,WAAW,SAAS,kBAAkB;IAAU;IAAiB;IAAgB;;EA+DjF;MAaI;;UAKI;;;;;;;;EAoBF,WAAW,QAAQ;;EAgCzB;IAAW;IAA+B;;;;;;;;EAoBpC,WAAW,aAAa;EAwDxB,eAAe;;;;;;;;;;;;UAkBP;;;;UAYA;;;UAqBA;;;;;;EA4BR,oBAAoB,QAAQ;IAAgB;IAA+B;;;UAgCnE;;;;;;UAeA;UASA;mBAoBG;UAOT;mBAES;mBAIA;mBAaA;UAMT;mBAWS;UAOT;;EAKF,WAAW"}