@nika-js/onlymap 0.6.0 → 0.6.2

package/dist/{index-DSRIZR81.js → index-BF9iO8Tq.js}

@@ -1,4 +1,4 @@
-import { ag as Be, ah as le, ai as ce, aj as De, ak as Oe, al as ke } from "./index-Bz-rbmhj.js";
+import { ag as Be, ah as le, ai as ce, aj as De, ak as Oe, al as ke } from "./index-7B-6Cbzu.js";
 import { y as ve, a as he, z as G, R as J, A as ue, C as Fe, F as je, n as xe, S as Ie, E as Ne } from "./recordbatch-Bpc0uxFn.js";
 import { g as V, a as fe, b as Le, c as Ue, d as Me, e as qe, m as Ve } from "./table-accessors-CYWTzpQI.js";
 import { c as $e } from "./convert-arrow-schema-DrAihRf9.js";

package/dist/{index-GOwMjqm6.js → index-BmX6IId3.js}

@@ -1,4 +1,4 @@
-import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-Bz-rbmhj.js";
+import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-7B-6Cbzu.js";
 import { w as gs, t as Hs, f as Ws, m as Qs } from "./mgrs-BY9bIvp4.js";
 import { c as Xs } from "./convert-arrow-schema-DrAihRf9.js";
 import { y as Ys, A as bt, a as Ks, z as Vs, R as Zs } from "./recordbatch-Bpc0uxFn.js";

package/dist/{index-UzmNhuS0.js → index-SPJVn_n_.js}

@@ -1,4 +1,4 @@
-import { ae as _t, af as Ct } from "./index-Bz-rbmhj.js";
+import { ae as _t, af as Ct } from "./index-7B-6Cbzu.js";
 function Yt(e, r, t = 2, i, o = "xy") {
   const s = r && r.length, l = s ? r[0] * t : e.length;
   let c = Ut(e, 0, l, t, !0, i && i[0], o);

package/dist/{index-CCQttJzO.js → index-xmJjZxQJ.js}

@@ -1,5 +1,5 @@
-import { i as E, j as S, k as R, o as N, p as h, q as w, s as O, t as W, v as x, w as I, x as B, y as _, A as P, B as k, E as $, F as z, H as v, I as F, J as C, K as U, N as p, O as M } from "./index-Bz-rbmhj.js";
-import { P as $e, R as ze, _ as ve, Q as Ce, S as Ue, T as Me, U as je, X as De, Y as Je, Z as qe, $ as He, a0 as Ve, a1 as Ge, a2 as Ke, a3 as Qe, a4 as Xe, a5 as Ye, a6 as Ze, a7 as et, a8 as tt, a9 as nt, aa as rt, ab as at, ac as st, ad as ot } from "./index-Bz-rbmhj.js";
+import { i as E, j as S, k as R, o as N, p as h, q as w, s as O, t as W, v as x, w as I, x as B, y as _, A as P, B as k, E as $, F as z, H as v, I as F, J as C, K as U, N as p, O as M } from "./index-7B-6Cbzu.js";
+import { P as $e, R as ze, _ as ve, Q as Ce, S as Ue, T as Me, U as je, X as De, Y as Je, Z as qe, $ as He, a0 as Ve, a1 as Ge, a2 as Ke, a3 as Qe, a4 as Xe, a5 as Ye, a6 as Ze, a7 as et, a8 as tt, a9 as nt, aa as rt, ab as at, ac as st, ad as ot } from "./index-7B-6Cbzu.js";
 import { g as j, i as D } from "./table-accessors-CYWTzpQI.js";
 async function J(t, e, n = {}, r = {}) {
   const a = E(t), s = S.getWorkerFarm(n), { source: o } = n, c = { name: a, source: o };

package/dist/index.d.ts

@@ -13,7 +13,10 @@
  * renderer against an empty registry and never picks up the built-in.
  */
 import "./widgets/built-in";
+import "./widgets/ifc";
+import "./widgets/ifc-clash";
 import "./measure-controller";
+import "./region-export-controller";
 import "./elements/om-map";
 import "./elements/om-layer";
 import "./elements/om-widget";
@@ -33,6 +36,7 @@ import { configureTelemetry } from "./telemetry";
 import { configureLicense } from "./license";
 import { validateManifestString } from "./validation";
 import { snapshotIR } from "./ir-snapshot";
+import { snapshotDescriptorIR } from "./programmatic";
 import { resolveImageOverlay } from "./image-overlay";
 export { registerLayer, getLayerSchema } from "./layer-registry";
 export type { LayerSchema, PropDescriptor, PropKind } from "./layer-registry";
@@ -56,11 +60,17 @@ export { registerTerrain, getTerrain, parseTerrainAttrs } from "./terrain";
 export type { TerrainPreset, TerrainIR, ElevationDecoder, LayerTerrainMode } from "./terrain";
 export type { SnapshotOptions } from "./snapshot";
 export { configureTelemetry } from "./telemetry";
+export type { IfcModel, IfcFeature, LoadIfcOptions } from "./ifc";
+export declare function loadIfc(source: ArrayBuffer | Uint8Array | Blob, options?: import("./ifc").LoadIfcOptions): Promise<import("./ifc").IfcModel>;
+/** Point the IFC loader at a self-hosted web-ifc build instead of the default CDN. */
+export declare function configureIfc(options: {
+    wasmPath?: string;
+}): Promise<void>;
 export type { TelemetryConfig, TelemetrySnapshot } from "./telemetry";
 export { configureLicense, getEntitlements } from "./license";
-export type { Entitlements } from "./license";
+export type { Entitlements, LicenseIdentity } from "./license";
 export type { RuntimeContext } from "./ctx";
-export { MapController, descriptorToIR } from "./programmatic";
+export { MapController, descriptorToIR, snapshotDescriptorIR } from "./programmatic";
 export type { LayerDescriptor, MapControllerOptions, CameraState, OverlayPositioner, PickListener } from "./programmatic";
 export { MANAGED_SLOTS, LEGACY_POSITION_ALIASES, ALL_POSITION_VALUES, FOLD_SIDES, resolveSlot, slotLayout, slotContainerStyle, foldSideForSlot, foldToggleSlot, foldDrawerStyle, foldPanelStyle, foldToggleStyle, resolveFoldBreakpointPx, shouldFoldAtWidth, DEFAULT_FOLD_BREAKPOINT_PX, FOLD_HYSTERESIS_PX, parseWidgetStyle, WIDGET_STYLE_KEY_NAMES, } from "./widget-layout";
 export type { ManagedSlot, WidgetSlot, FoldSide, SlotLayout, WidgetStyleParse } from "./widget-layout";
@@ -119,6 +129,7 @@ export declare const OmMap: {
     configureLicense: typeof configureLicense;
     validate: typeof validateManifestString;
     snapshotIR: typeof snapshotIR;
+    snapshotDescriptorIR: typeof snapshotDescriptorIR;
     resolveImageOverlay: typeof resolveImageOverlay;
     loadRasterModule: typeof loadRasterModule;
 };

package/dist/ir-snapshot.d.ts

@@ -22,7 +22,7 @@
  * (snapshots are side-effect-free; a URL-backed layer shows the same empty
  * placeholder the live Q6 pre-fetch state has).
  */
-import type { LayerMeta, LayerFilter, LayerAssetState } from "./ir";
+import type { LayerIR, LayerMeta, LayerFilter, LayerAssetState } from "./ir";
 import type { Shape } from "./expr";
 export interface LayerIRSnapshot {
     id: string;
@@ -49,6 +49,8 @@ export interface LayerIRSnapshot {
     props: Record<string, unknown>;
     updateTriggers: Record<string, string>;
 }
+/** Convert one already-resolved layer IR to the public deterministic JSON-safe form. */
+export declare function snapshotLayerIR(ir: LayerIR): LayerIRSnapshot;
 /**
  * Resolves a manifest to JSON-safe layer IR snapshots.
  *

package/dist/layer-registry.d.ts

@@ -50,6 +50,20 @@ export interface LayerSchema {
      * `compact`/`neverHides` widget-flag precedent — one source of truth).
      */
     carriesTileset?: boolean;
+    /**
+     * BIM feature-picking epic, Phase 2 (design pending). Supports
+     * `pick-features`/`feature-id-property` — the runtime injects the
+     * `_subLayerProps` sublayer-class swap (to `FeatureMeshLayer`) only into
+     * these types, same one-source-of-truth reasoning as `carriesTileset`.
+     */
+    supportsFeaturePicking?: boolean;
+    /**
+     * Loads its own georeferencing from the source file (spec: "auto-terrain
+     * for georeferenced BIM") and supports the `onGeoreference` deck prop —
+     * the runtime injects that hook only into these types, same
+     * one-source-of-truth reasoning as `carriesTileset`.
+     */
+    carriesGeoreference?: boolean;
     /** Layer-owned async asset resolver; keeps parse/runtime branching registry-driven rather than name-matched. */
     assetResolver?: "image-overlay";
 }

package/dist/layers/bim-layer.d.ts

@@ -0,0 +1,127 @@
+/**
+ * BIMLayer — a Tile3DLayer for BIM SOURCE files, not pre-baked tilesets.
+ *
+ * `<om-layer type="Tile3DLayer" tileset="…/tileset.json">` expects a 3D Tiles
+ * root someone already produced (by hand, by `dev/tools/gen-ifc-fixture.ts`,
+ * by any other converter). `BIMLayer` takes the BIM file itself — today an
+ * `.ifc` — and runs it through `loadIfc` (the SAME parser the BIM workbench's
+ * `ifc-loader` widget uses) the moment it loads, so a page never needs a
+ * separate conversion step or a pre-built tileset checked into the repo.
+ *
+ * Two things fall out of using the loader rather than a static tileset:
+ *
+ *  - No `site-origin`/`site-heading`/`site-scale` needed. `loadIfc` already
+ *    reads the file's own georeference and bakes the HORIZONTAL placement
+ *    (eastings/northings/heading/scale) into the tileset it returns (or
+ *    falls back honestly when the file declares none). `site-origin` itself
+ *    is NOT wired up on `BIMLayer` (an authored one is ignored) — it rides
+ *    runtime-core.ts's `tilesetBakedFrame`/`tilesetPlacementMatrix`
+ *    machinery, which reads a tileset.json's baked root transform
+ *    SYNCHRONOUSLY off the layer's `data` prop at construction time, and
+ *    BIMLayer's tileset is an in-browser blob URL that doesn't exist until
+ *    `loadIfc` resolves asynchronously inside `updateState` below — an
+ *    honest, documented gap rather than a half-built override path.
+ *  - The VERTICAL placement, by contrast, IS automatic — matching how the
+ *    BIM workbench's `ifc-loader` WIDGET already behaves, not a separate
+ *    opt-in. `IfcMapConversion`'s `OrthogonalHeight` (this model's real
+ *    absolute elevation) is computed by `loadIfc` but left out of the
+ *    tileset's own baked transform (see that field's doc comment in
+ *    src/ifc.ts) — correct on a flat, no-`terrain` basemap (a local Z≈0
+ *    model sits right on a Z=0 ground plane), wrong once a REAL terrain
+ *    surface is active (whose elevation at any inhabited location is
+ *    essentially never 0 — the model ends up buried inside the mesh).
+ *    `runtime-core.ts` reports whether terrain is active via a
+ *    `terrainActive` prop (the same `carriesGeoreference`-gated channel
+ *    `onGeoreference` already rides); `renderLayers` below applies
+ *    `OrthogonalHeight` as an ENU re-placement AT the model's own already-
+ *    correct lon/lat (same site point, just a non-zero height component)
+ *    only when that prop is true — reusing `tilesetPlacementMatrix`, the
+ *    exact mechanism `ifc-loader`'s own manual `site-origin` override rides,
+ *    just triggered automatically instead of requiring the author (or a
+ *    widget) to compute and restate a number that's already known.
+ *  - The outline overlay is automatic. `loadIfc` already returns an
+ *    `edgesUrl` alongside the tileset; a separate `<om-layer type="PathLayer"
+ *    data="…/edges.json">` was only ever there because a plain Tile3DLayer
+ *    has no way to render one itself.
+ *
+ * The outline overlay follows `isolate-features`/`hide-features` the same way
+ * the mesh does: `loadModel` parses the edges blob into memory (it is a
+ * same-origin blob URL it just created, not a real network round trip), and
+ * `renderLayers` filters those rows with the SAME `matchToken`/
+ * `normalizeMatchList` helpers `FeatureMeshLayer` uses for the mesh, keyed on
+ * `feature-filter-field`. It does NOT follow `ghost-features` — ghosting only
+ * dims the mesh's opacity, never the outline, and that is not a BIMLayer gap:
+ * the OLDER two-layer pattern (`ifc-loader`'s own `Tile3DLayer` + companion
+ * `<layer-id>-edges` PathLayer, still used by the widget — see
+ * src/widgets/ifc.ts) never ghosted its outlines either, since its
+ * `filter-category`/`filter-categories` pair is a plain keep-list with no
+ * partial-opacity concept. Matching that, not inventing new behaviour.
+ *
+ * Implementation: a CompositeLayer wrapping a real `Tile3DLayer`, not a
+ * Tile3DLayer subclass — `renderLayers` fetches+parses on `src` change, then
+ * spreads `this.props` onto the inner Tile3DLayer verbatim (dropping `src`
+ * and the runtime's own harmless `data: []` baseline, setting `data` to the
+ * resolved tileset URL instead). That spread is load-bearing: the
+ * runtime injects `_subLayerProps`/`onTileLoad`/`onTilesetLoad` onto
+ * whatever top-level props a `supportsFeaturePicking`/`carriesTileset`
+ * layer receives (see runtime-core.ts's `pickFeaturesHook`/`featureTableHook`),
+ * and forwarding them unchanged is what makes picking, `feature-styles`,
+ * `ctx.features()`, and `om-tileset-load` all keep working without BIMLayer
+ * having to know anything about them itself.
+ *
+ * Other BIM formats: the loader dispatch (currently a straight call to
+ * `loadIfc`) is the one seam a future format would extend — nothing else
+ * here is IFC-specific.
+ */
+import { CompositeLayer } from "@deck.gl/core";
+import type { Layer } from "@deck.gl/core";
+/** One outline polyline plus the same category fields the mesh filters on — see `readGeoreference`'s edges row shape in `../ifc`. */
+interface EdgeRow {
+    path: [number, number, number][];
+    [field: string]: unknown;
+}
+interface LoadedBim {
+    tilesetUrl: string;
+    edgeRows: EdgeRow[] | null;
+    lonLat: [number, number];
+    heading: number;
+    scale: number;
+    /** The file's own `IfcMapConversion.OrthogonalHeight`, undefined when it never declared one — see renderLayers' `terrainActive` handling. */
+    orthogonalHeight?: number;
+    revoke(): void;
+}
+export interface BIMLayerProps {
+    /**
+     * URL of the BIM source file (an `.ifc` today).
+     *
+     * Deliberately NOT `data`: deck.gl's own `Layer` base class auto-fetches
+     * any string `data` prop through loaders.gl's generic loader registry —
+     * fine for a ScatterplotLayer's rows, fatal here ("No valid loader found"
+     * for a `.ifc`, confirmed by running this in a real browser). Tile3DLayer
+     * avoids this because deck.gl gives Tile3DLayer itself custom handling for
+     * `data`; a plain CompositeLayer like this one does not inherit that.
+     */
+    src: string;
+    [prop: string]: unknown;
+}
+export declare class BIMLayer extends CompositeLayer<BIMLayerProps> {
+    static layerName: string;
+    static defaultProps: {
+        pickFeatures: boolean;
+    };
+    state: {
+        loaded: LoadedBim | null;
+        loadingFor: string | null;
+        destroyed: boolean;
+        abort: AbortController | null;
+    };
+    initializeState(): void;
+    updateState({ props, oldProps }: {
+        props: BIMLayerProps;
+        oldProps: BIMLayerProps;
+    }): void;
+    finalizeState(): void;
+    private loadModel;
+    renderLayers(): Layer[];
+}
+export {};

package/dist/layers/feature-mesh-layer.d.ts

@@ -0,0 +1,288 @@
+import { type ShaderModule } from "@luma.gl/shadertools";
+import { Model, Geometry } from "@luma.gl/engine";
+import { Matrix4 } from "@math.gl/core";
+import { SimpleMeshLayer, ScenegraphLayer, type SimpleMeshLayerProps } from "@deck.gl/mesh-layers";
+import { CompositeLayer, type DefaultProps, type UpdateParameters } from "@deck.gl/core";
+import { type GltfExtStructuralMetadata } from "../tile3d-metadata";
+import { type FeatureColorMapping } from "../feature-colors";
+/**
+ * A primitive whose POSITION accessor did not resolve (unsupported
+ * componentType, a missing buffer, `loadBuffers` off, a corrupt bufferView —
+ * `toLumaGeometry` silently omits the key rather than fabricating one) has
+ * nothing to draw at all, so this can't degrade to a partially-rendered mesh
+ * the way a missing property table degrades to "no properties" — there is no
+ * useful "unstyled but visible" state for zero vertices. What it CAN do is
+ * fail with a message that says why, instead of the opaque "Cannot read
+ * properties of undefined (reading 'length')" a non-null assertion produced
+ * here previously — deck.gl's LayerManager already catches a layer update
+ * throwing (this doesn't crash the page), so the only actual regression from
+ * throwing plainly is a worse error message, which this fixes.
+ */
+export declare function validateGeometryAttributes(attributes: Record<string, {
+    value: ArrayLike<number>;
+} | undefined>): void;
+/** Loose shape of the `tile` prop Tile3DLayer's `_make3DModelLayer` passes through. `featureIdPropertyTableIndex` is set by the outer `FeatureMeshLayer` composite below, during its own `renderLayers()`, right before constructing this inner layer — not by a separate async step. */
+interface FeatureTileProp {
+    content?: {
+        gltf?: {
+            extensions?: {
+                EXT_structural_metadata?: GltfExtStructuralMetadata;
+            };
+        };
+        featureIdPropertyTableIndex?: number;
+    };
+}
+/**
+ * One row of the per-feature style table, keyed by feature ID (the array index
+ * IS the feature ID). Every field is optional; an omitted or absent row leaves
+ * that feature rendered exactly as it would be unstyled.
+ */
+export interface FeatureStyle {
+    /** Tint colour, `[r, g, b]` 0-255. */
+    color?: [number, number, number];
+    /** How strongly `color` replaces the lit colour, 0-1. Defaults to 1 when a colour is given, 0 otherwise. */
+    strength?: number;
+    /** Alpha multiplier, 0-1. Defaults to 1 (opaque). */
+    opacity?: number;
+}
+/** The extra props this layer adds on top of SimpleMeshLayer's own (mesh/getPosition/getColor/…). */
+interface FeatureMeshLayerExtraProps {
+    pbrMaterial: Record<string, unknown> | null;
+    /** Per-vertex feature ID for the single primitive `FeatureMeshLayer` resolved — see this file's module doc. */
+    featureIds?: ArrayLike<number> | null;
+    /** Per-feature style table indexed by feature ID — see featureStyleUniforms. Null/empty renders unstyled. */
+    featureStyles?: FeatureStyle[] | null;
+    /** Raw feature-ID texture image, when the dataset carries IDs per texel. Enables the per-fragment path. */
+    featureIdImage?: unknown;
+    /** Which RGBA channels compose the ID, low byte first — the extension's own `channels` array. */
+    featureIdChannels?: number[] | null;
+    /** EXT_mesh_features' "belongs to no feature" sentinel — a pick of this ID reports as no feature. */
+    featureIdNull?: number | null;
+    tile?: FeatureTileProp;
+}
+/**
+ * Turns the extension's `channels` array into the four per-channel byte
+ * weights the shader multiplies by — channels[i] names an RGBA channel and its
+ * position sets its significance, so [0,1] means R is the low byte and G the
+ * next (weights 1 and 256).
+ */
+export declare function featureIdChannelWeights(channels: number[] | null | undefined): [number, number, number, number];
+/** 0-1 style fraction → a 0-255 texel byte (the tables are rgba8unorm). */
+export declare const styleByte: (value: number) => number;
+/** Builds the two `count x 1` RGBA lookup tables described in featureStyleUniforms' doc. */
+export declare function encodeFeatureStyleTables(styles: FeatureStyle[]): {
+    tint: Uint8Array;
+    opacity: Uint8Array;
+};
+/** True when any row asks for transparency — the layer must then enable blending. */
+export declare function hasTranslucentFeature(styles: FeatureStyle[] | null | undefined): boolean;
+type DrawParams = Parameters<InstanceType<typeof SimpleMeshLayer>["draw"]>[0];
+type MeshParam = Parameters<InstanceType<typeof SimpleMeshLayer>["getModel"]>[0];
+type PickingInfoParams = Parameters<InstanceType<typeof SimpleMeshLayer>["getPickingInfo"]>[0];
+declare class SinglePrimitiveFeatureLayer extends SimpleMeshLayer<unknown, FeatureMeshLayerExtraProps> {
+    static layerName: string;
+    static defaultProps: DefaultProps<SimpleMeshLayerProps<unknown> & FeatureMeshLayerExtraProps>;
+    getShaders(): {
+        vs: string;
+        fs: string;
+        modules: ShaderModule[];
+        defines?: Record<string, unknown>;
+    };
+    initializeState(): void;
+    /** Registers the per-vertex feature-ID attributes exactly once — callable late, from the texture-failure fallback. */
+    private registerFeatureIdAttributes;
+    updateState(params: UpdateParameters<this>): void;
+    /**
+     * Uploads the feature-ID texture once per tile and keeps it — this is the
+     * cache. The image itself is already cached upstream by loaders.gl for the
+     * tile's lifetime, so the only per-tile cost here is the single upload, and
+     * it replaces what was previously one CPU texture sample per vertex.
+     */
+    private updateFeatureIdTexture;
+    /** Rebuilds both style lookup textures. Cheap enough to redo wholesale on any style change — each table is `featureCount x 1` texels. */
+    private updateFeatureStyleTexture;
+    draw(opts: DrawParams): void;
+    protected getModel(mesh: MeshParam): Model;
+    private updatePbrMaterialUniforms;
+    private parseMaterial;
+    private calculateFeatureIdsPickingColors;
+    private calculateFeatureIdValues;
+    finalizeState(context: Parameters<InstanceType<typeof SimpleMeshLayer>["finalizeState"]>[0]): void;
+    getPickingInfo(params: PickingInfoParams): {
+        color: Uint8Array | null;
+        layer: import("@deck.gl/core").Layer | null;
+        sourceLayer?: import("@deck.gl/core").Layer | null;
+        viewport?: import("@deck.gl/core").Viewport;
+        index: number;
+        picked: boolean;
+        object?: any;
+        x: number;
+        y: number;
+        pixel?: [number, number];
+        coordinate?: number[];
+        devicePixel?: [number, number];
+        pixelRatio: number;
+    } & {
+        featureId?: number;
+        properties?: Record<string, unknown>;
+        class?: string | null;
+        guid?: string | null;
+    };
+}
+/** The extra props `_make3DModelLayer` passes that this composite wrapper reads directly (everything else is forwarded to the fallback ScenegraphLayer verbatim). */
+interface FeatureMeshLayerOuterExtraProps {
+    scenegraph?: unknown;
+    tile?: FeatureTileProp;
+    featureIdProperty?: string;
+    /** Per-feature style table, forwarded to the picking-aware sublayer. Ignored on the ScenegraphLayer fallback, which has no feature IDs to key on. */
+    featureStyles?: FeatureStyle[] | null;
+    /**
+     * The GLOBAL colour mapping (feature-color-by / feature-color-scale),
+     * applied to THIS tile's own property rows in composeFeatureStyles —
+     * feature IDs are tile-local, so the style table must be built per tile
+     * from per-tile rows (a shared globally-indexed table was only ever
+     * correct for the first tile). Identity is memoized upstream
+     * (runtime-core.featureColorMappingFor), which keeps the derived table —
+     * and its GPU textures — stable across reconciles and animation frames.
+     */
+    featureColorMapping?: FeatureColorMapping | null;
+    /** Property-table field the three visibility lists below match against. */
+    featureFilterField?: string | null;
+    /** Show ONLY features whose field matches; everything else is hidden. */
+    isolateFeatures?: unknown[] | null;
+    hideFeatures?: unknown[] | null;
+    ghostFeatures?: unknown[] | null;
+    ghostOpacity?: number;
+}
+/**
+ * Property values are compared as strings so a manifest can write
+ * `hide-features='["Windows"]'` or `'[3]'` without caring whether the column
+ * decoded to strings, numbers or booleans — an attribute is text either way.
+ */
+export declare function matchToken(value: unknown): string;
+/** Normalizes an attribute list to a lookup set, or null when there is nothing to match. */
+export declare function normalizeMatchList(values: unknown[] | null | undefined): Set<string> | null;
+/** See this file's module doc — dispatches between the per-vertex feature-picking single-primitive path and a plain ScenegraphLayer fallback. */
+export declare class FeatureMeshLayer extends CompositeLayer<FeatureMeshLayerOuterExtraProps> {
+    static layerName: string;
+    static defaultProps: DefaultProps<FeatureMeshLayerOuterExtraProps>;
+    /**
+     * Resolves the primitive, builds its Geometry and locates its feature-ID
+     * image ONCE, whenever the glTF itself changes — never per render.
+     *
+     * Doing this inside renderLayers (as an earlier version did) handed
+     * SimpleMeshLayer a brand-new Geometry instance every time ANY prop changed.
+     * A `mesh` identity change makes it destroy and rebuild its Model, so simply
+     * switching style mode re-uploaded every visible tile's vertex buffers at
+     * once and the model blanked out until something forced another redraw —
+     * which is why it only reappeared after a pan or zoom.
+     */
+    updateState({ props, oldProps, changeFlags }: UpdateParameters<this>): void;
+    /**
+     * Folds the declarative `isolate-features`/`hide-features`/`ghost-features`
+     * lists onto the author's own `feature-styles` table.
+     *
+     * Precedence is deliberate: the authored table supplies COLOUR, the
+     * declarative lists supply VISIBILITY, and visibility wins on `opacity`.
+     * That means switching a colour scheme never silently un-hides anything, and
+     * isolating never discards the colouring — the two are orthogonal, which is
+     * what makes them composable in a story or an undo step.
+     *
+     * `isolate` is evaluated first and is exclusive: anything not named is
+     * hidden outright, so it is a scope, not another kind of hide.
+     */
+    private composeFeatureStyles;
+    private resolvePrimitives;
+    renderLayers(): SinglePrimitiveFeatureLayer[] | ScenegraphLayer<any, {
+        data: string | {
+            length: number;
+            attributes?: Record<string, import("@math.gl/types").TypedArray | import("@luma.gl/core").Buffer | import("@deck.gl/core").BinaryAttribute>;
+        } | Iterable<unknown> | AsyncIterable<unknown[]> | Promise<import("@deck.gl/core").LayerData<unknown>> | null;
+        mesh: string | import("@loaders.gl/schema").MeshAttributes | Geometry | {
+            attributes: import("@loaders.gl/schema").MeshAttributes;
+            indices?: import("@loaders.gl/schema").MeshAttribute;
+        } | Promise<import("@loaders.gl/schema").MeshAttributes | Geometry | {
+            attributes: import("@loaders.gl/schema").MeshAttributes;
+            indices?: import("@loaders.gl/schema").MeshAttribute;
+        }> | null;
+        texture: string | HTMLCanvasElement | import("@luma.gl/core").Texture | import("@luma.gl/core").TextureProps | HTMLImageElement | ImageData | HTMLVideoElement | ImageBitmap | Promise<import("@deck.gl/core").TextureSource>;
+        textureParameters: import("@luma.gl/core").SamplerProps | null;
+        getPosition: readonly [number, number] | readonly [number, number, number] | Readonly<Float32Array<ArrayBufferLike>> | Readonly<Float64Array<ArrayBufferLike>> | import("@deck.gl/core").AccessorFunction<unknown, import("@deck.gl/core").Position>;
+        getColor: readonly [number, number, number] | readonly [number, number, number, number] | Readonly<Uint8Array<ArrayBufferLike>> | Readonly<Uint8ClampedArray<ArrayBufferLike>> | import("@deck.gl/core").AccessorFunction<unknown, import("@deck.gl/core").Color>;
+        getOrientation: readonly [number, number, number] | import("@deck.gl/core").AccessorFunction<unknown, readonly [number, number, number]>;
+        getScale: readonly [number, number, number] | import("@deck.gl/core").AccessorFunction<unknown, readonly [number, number, number]>;
+        getTranslation: readonly [number, number, number] | import("@deck.gl/core").AccessorFunction<unknown, readonly [number, number, number]>;
+        getTransformMatrix: number[] | import("@deck.gl/core").AccessorFunction<unknown, number[]>;
+        sizeScale: number;
+        _instanced: boolean;
+        wireframe: boolean;
+        material: import("@deck.gl/core").Material;
+        id: string;
+        dataComparator: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => boolean) | null;
+        _dataDiff: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(newData: LayerDataT, oldData?: LayerDataT) => {
+            startRow: number;
+            endRow?: number;
+        }[]) | null;
+        dataTransform: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: unknown, previousData?: LayerDataT) => LayerDataT) | null;
+        fetch: (url: string, context: {
+            propName: string;
+            layer: import("@deck.gl/core").Layer;
+            loaders?: import("@loaders.gl/loader-utils").Loader[];
+            loadOptions?: any;
+            signal?: AbortSignal;
+        }) => any;
+        updateTriggers: Record<string, any>;
+        operation: "terrain" | "draw" | "mask" | "terrain+terrain" | "terrain+draw" | "terrain+mask" | "draw+terrain" | "draw+draw" | "draw+mask" | "mask+terrain" | "mask+draw" | "mask+mask";
+        visible: boolean;
+        pickable: boolean | "3d";
+        opacity: number;
+        coordinateSystem: "default" | "lnglat" | "meter-offsets" | "lnglat-offsets" | "cartesian";
+        coordinateOrigin: [number, number, number];
+        modelMatrix: Matrix4 | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | import("@math.gl/types").NumberArray16 | null;
+        wrapLongitude: boolean;
+        positionFormat: "XYZ" | "XY";
+        colorFormat: "RGBA" | "RGB";
+        parameters: {
+            cullMode?: import("@luma.gl/core").CullMode;
+            frontFace?: import("@luma.gl/core").FrontFace;
+            depthBias?: number;
+            depthBiasSlopeScale?: number;
+            depthBiasClamp?: number;
+            unclippedDepth?: boolean;
+            provokingVertex?: "first" | "last";
+            polygonMode?: "fill" | "line";
+            polygonOffsetLine?: boolean;
+            clipDistance0?: boolean;
+            clipDistance1?: boolean;
+            clipDistance2?: boolean;
+            clipDistance3?: boolean;
+            clipDistance4?: boolean;
+            clipDistance5?: boolean;
+            clipDistance6?: boolean;
+            clipDistance7?: boolean;
+        } & import("@luma.gl/core").DepthStencilParameters & import("@luma.gl/core").ColorParameters & import("@luma.gl/core").MultisampleParameters;
+        transitions: Record<string, any> | null;
+        extensions: import("@deck.gl/core").LayerExtension[];
+        loaders: import("@loaders.gl/loader-utils").Loader[];
+        loadOptions: any;
+        getPolygonOffset: ((params: {
+            layerIndex: number;
+        }) => [number, number]) | null;
+        autoHighlight: boolean;
+        highlightedObjectIndex: number | null;
+        highlightColor: number[] | ((pickingInfo: import("@deck.gl/core").PickingInfo) => number[]);
+        onDataLoad: (<LayerDataT = import("@deck.gl/core").LayerData<unknown>>(data: LayerDataT, context: {
+            propName: string;
+            layer: import("@deck.gl/core").Layer;
+        }) => void) | null;
+        onError: ((error: Error) => boolean | void) | null;
+        onHover: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+        onClick: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+        onDragStart: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+        onDrag: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+        onDragEnd: ((pickingInfo: import("@deck.gl/core").PickingInfo, event: import("mjolnir.js").MjolnirEvent) => boolean | void) | null;
+        numInstances: number | null;
+        startIndices: number[] | Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | null;
+    }> | null;
+}
+export {};

package/dist/layers/gltf-scene-walk.d.ts

@@ -0,0 +1,55 @@
+/**
+ * BIM feature-picking epic, Phase 2 — glTF scene-graph walk. `ScenegraphLayer`
+ * (via the undocumented `@luma.gl/gltf` `createScenegraphsFromGLTF`) is what
+ * actually renders 3D-Tiles glTF/glb/b3dm/i3dm content in this repo — NOT
+ * the I3S-only `MeshLayer`/`content.featureIds` path (verified against
+ * `@loaders.gl/3d-tiles`'s `getTileType()`: gltf/glb/b3dm/i3dm all map to
+ * `TILE_TYPE.SCENEGRAPH`, and `@loaders.gl/i3s` isn't even installed here).
+ * `pick-features` therefore only fast-paths the realistic single-element
+ * case — one node, one mesh, one primitive — and walks that node's actual
+ * transform (glTF node placement is independent of the tile's own 3D-Tiles
+ * transform); anything else falls back to a plain, unmodified
+ * `ScenegraphLayer` with zero rendering regression.
+ */
+import { Matrix4 } from "@math.gl/core";
+interface GltfNode {
+    mesh?: {
+        primitives?: unknown[];
+    };
+    children?: GltfNode[];
+    matrix?: number[];
+    translation?: [number, number, number];
+    rotation?: [number, number, number, number];
+    scale?: [number, number, number];
+}
+interface GltfScene {
+    nodes?: GltfNode[];
+}
+interface GltfLike {
+    scene?: number | GltfScene;
+    scenes?: GltfScene[];
+}
+export interface ResolvedSinglePrimitive {
+    primitive: unknown;
+    /** This node's transform composed down from the scene root — glTF-internal placement, independent of the tile's own 3D-Tiles transform. */
+    worldMatrix: Matrix4;
+}
+/**
+ * Walks the glTF's node hierarchy (starting at its default/only scene) and
+ * returns EVERY {primitive, worldMatrix} pair, each carrying its own node's
+ * transform composed down from the scene root.
+ *
+ * Multi-primitive content is the norm, not the exception: glTF allows exactly
+ * one material per primitive, so a mesh with five materials is five
+ * primitives. Real IFC exports split much further still — the Building-
+ * Architecture sample converts to 14 nodes/14 primitives. Only single-material
+ * content (photogrammetry tiles, for instance) resolves to one.
+ */
+export declare function resolvePrimitiveNodes(gltf: GltfLike): ResolvedSinglePrimitive[];
+/**
+ * The single-primitive special case, kept as its own entry point because
+ * "exactly one primitive" is still a meaningful question (a caller that cannot
+ * fan out wants to know). Returns null for anything more complex.
+ */
+export declare function resolveSinglePrimitiveNode(gltf: GltfLike): ResolvedSinglePrimitive | null;
+export {};

package/dist/layers/popup-layer.d.ts

@@ -31,6 +31,19 @@ export interface PopupLayerProps {
     getSubtext?: ((d: unknown) => string) | null;
     getColor?: unknown;
     getSize?: unknown;
+    /**
+     * Overrides the layout's default `[x, y]` screen-pixel offset. Not
+     * attribute-exposed (an internal escape hatch, set via `patchAnimatedProps`
+     * — same non-string-prop-injection precedent as a SimpleMeshLayer's
+     * `mesh`) — the volume gizmo's elevation tooltip uses this so it clears
+     * the gizmo mesh by a CONSTANT pixel gap at every zoom, which a world-space
+     * (meters) offset can't do: at low zoom a fixed meter offset shrinks to
+     * fewer pixels than the badge itself needs, causing exactly the overlap a
+     * real user reported.
+     */
+    pixelOffset?: [number, number];
+    /** Raw WebGL/GPU state passthrough (e.g. `{ depthTest: false }`) — same internal escape hatch as `pixelOffset`, not attribute-exposed. */
+    parameters?: Record<string, unknown>;
     updateTriggers?: Record<string, unknown>;
 }
 export declare class PopupLayer extends CompositeLayer<PopupLayerProps> {

package/dist/legend-spec.d.ts

@@ -45,7 +45,7 @@ export type LegendSpec = {
  * THE LEGEND, not the map (the map samples the GPU sprite; a 1-D CSS
  * gradient bar only needs a few stops and the eye fills in the rest).
  * Matplotlib reference colors at 0/.25/.5/.75/1. The sprite ships ~107
- * colormaps; this curated dozen covers the ones worth suggesting — an
+ * colormaps; this curated set covers the ones worth suggesting — an
  * authored name outside it still RENDERS (sprite lookup), it just gets the
  * single-swatch legend fallback.
  */

package/dist/{lerc-CuifOkoA.js → lerc-C6k7EzSN.js}

@@ -1,4 +1,4 @@
-import { C as a, D as s } from "./raster-dysYIQ_k.js";
+import { C as a, D as s } from "./raster-Cuzhibe2.js";
 const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null
 }, Symbol.toStringTag, { value: "Module" }));
@@ -8,7 +8,7 @@ var t;
 })(t || (t = {}));
 let l = !1;
 async function d() {
-  const e = await import("./LercDecode.es-fbo6h5rt.js");
+  const e = await import("./LercDecode.es-BOJJr6Gx.js");
   return l || (await e.load(), l = !0), e;
 }
 async function i(e, r) {