@nika-js/onlymap 0.6.4 → 0.6.7

package/dist/{index-tnlYDALL.js → index-CqsQz9Bp.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-Cxo9mCw_.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-Cxo9mCw_.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-CAuq7wRs.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-CAuq7wRs.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-Bx9GFkrn.js → index-iVMlGZS9.js}

@@ -1,4 +1,4 @@
-import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-Cxo9mCw_.js";
+import { ak as Bt, ax as Xt, ay as Yt, az as Us } from "./index-CAuq7wRs.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.d.ts

@@ -32,6 +32,7 @@ import { registerWidget } from "./widget-registry";
 import { registerAction } from "./actions";
 import { registerBasemap, configureBasemap } from "./basemap-registry";
 import { registerTerrain } from "./terrain";
+import { registerRoutingProvider } from "./providers";
 import { configureTelemetry } from "./telemetry";
 import { configureLicense } from "./license";
 import { validateManifestString } from "./validation";
@@ -40,7 +41,7 @@ import { snapshotDescriptorIR } from "./programmatic";
 import { resolveImageOverlay } from "./image-overlay";
 export { registerLayer, getLayerSchema } from "./layer-registry";
 export type { LayerSchema, PropDescriptor, PropKind } from "./layer-registry";
-export type { LayerIR, LayerMeta, LayerFilter, LayerData, ColumnarData, LayerAssetState } from "./ir";
+export type { LayerIR, LayerMeta, LayerFilter, LayerCategoryFilter, LayerData, ColumnarData, LayerAssetState } from "./ir";
 export { resolveImageOverlay, DRONE_SENSOR_DATABASE } from "./image-overlay";
 export type { ImageBounds, DroneExifData, DroneImageMetadata, DroneSensorDimensions, ResolveImageOverlayOptions, ResolvedImageOverlay, } from "./image-overlay";
 export { isColumnar, asRows, rowAt, normalizeData, arrowTableToColumnar } from "./data-layer";
@@ -58,6 +59,8 @@ export { LIGHTING_PRESET_NAMES, resolveLighting, solarAzElDegrees } from "./scen
 export type { LightingIR, LightingOptions, LightingPresetName } from "./scene-lighting";
 export { registerTerrain, getTerrain, parseTerrainAttrs } from "./terrain";
 export type { TerrainPreset, TerrainIR, ElevationDecoder, LayerTerrainMode } from "./terrain";
+export { registerRoutingProvider, getRoutingProvider, lineStringLengthMeters } from "./providers";
+export type { RoutingProvider, Route, RouteRequest, RouteWaypoint, RouteLeg } from "./providers";
 export type { SnapshotOptions } from "./snapshot";
 export { configureTelemetry } from "./telemetry";
 export type { IfcModel, IfcFeature, LoadIfcOptions } from "./ifc";
@@ -72,6 +75,8 @@ export type { Entitlements, LicenseIdentity } from "./license";
 export type { RuntimeContext } from "./ctx";
 export { MapController, descriptorToIR, snapshotDescriptorIR } from "./programmatic";
 export type { LayerDescriptor, MapControllerOptions, CameraState, OverlayPositioner, PickListener } from "./programmatic";
+/** Multi-dimension GPU filter entry (spec: "Filtering") — `LayerDescriptor.filterFields`' element type, and the React adapter's `OmLayer` twin. */
+export type { LayerFilterFieldSpec, LayerCategoryFilterFieldSpec } from "./attribute-resolution";
 export { releaseDataOwner } from "./data-layer";
 export type { DataTransportOwner } from "./data-layer";
 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";
@@ -125,6 +130,7 @@ export declare const OmMap: {
     registerSource: typeof registerSource;
     registerBasemap: typeof registerBasemap;
     registerTerrain: typeof registerTerrain;
+    registerRoutingProvider: typeof registerRoutingProvider;
     configureBasemap: typeof configureBasemap;
     configureData: typeof configureData;
     configureTelemetry: typeof configureTelemetry;

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 { LayerIR, LayerMeta, LayerFilter, LayerAssetState } from "./ir";
+import type { LayerIR, LayerMeta, LayerFilter, LayerCategoryFilter, LayerAssetState } from "./ir";
 import type { Shape } from "./expr";
 export interface LayerIRSnapshot {
     id: string;
@@ -38,6 +38,7 @@ export interface LayerIRSnapshot {
     rows: number;
     meta: LayerMeta;
     filter?: LayerFilter;
+    categoryFilter?: LayerCategoryFilter;
     /** Per-layer terrain mode when authored (`terrain` attribute) — absent = the type default. */
     terrain?: "drape" | "offset" | "off";
     /**

package/dist/ir.d.ts

@@ -30,18 +30,40 @@ export interface ColumnarData {
 /** A layer's resolved data: row objects (flat/geojson) or columns (columnar). */
 export type LayerData = unknown[] | ColumnarData;
 /**
- * The layer's active declarative filter (spec: "Filtering"), single-field
- * numeric only for now (`filterSize`/`categorySize` fixed at 1 — the spec's
- * own example is single-field; the "up to 4 dimensions" multi-field case is
- * a documented future extension, not implemented here). Carried on the IR
- * (not just `meta`) because `ctx.stats`/`ctx.dataInViewport` apply it
- * CPU-side by default (the "coherence rule") — it's operationally read, not
- * just display metadata.
+ * One numeric dimension of the layer's active declarative filter (spec:
+ * "Filtering"). Carried on the IR (not just `meta`) because `ctx.stats`/
+ * `ctx.dataInViewport` apply it CPU-side by default (the "coherence rule")
+ * — it's operationally read, not just display metadata.
  */
-export interface LayerFilter {
+export interface LayerFilterDimension {
     field: string;
     range: [number, number];
+    softRange?: [number, number];
 }
+/**
+ * The layer's active declarative filter — one entry per numeric dimension,
+ * up to 4 (deck.gl `DataFilterExtension`'s own `filterSize` ceiling; a
+ * GLSL compile-time define, verified against the extension's own source —
+ * see `applyFilterWiring`'s doc comment). The single-field case (the
+ * original, still-primary authoring path via `filter-field`/`filter-range`)
+ * is simply a one-entry array — every consumer treats N=1 the same as
+ * N>1, no special-casing.
+ */
+export type LayerFilter = LayerFilterDimension[];
+/**
+ * One categorical dimension of the layer's active declarative filter — a
+ * discrete keep-list rather than a numeric range (deck.gl's `categorySize`
+ * slot, a SEPARATE bitmask mechanism from `filterSize`'s range test; values
+ * may be string or number). Carried on the IR for the same reason
+ * `LayerFilterDimension` is: `ctx.stats`/`ctx.dataInViewport` apply it
+ * CPU-side by default too.
+ */
+export interface LayerCategoryFilterDimension {
+    field: string;
+    categories: (string | number)[];
+}
+/** The layer's active categorical filter — one entry per dimension, up to 4 (categorySize's own ceiling). Independent of, and combinable with, the numeric `LayerFilter`. */
+export type LayerCategoryFilter = LayerCategoryFilterDimension[];
 /** Async non-row asset resolution carried by the IR (currently ImageOverlay EXIF only). */
 export interface LayerAssetState {
     kind: "image-overlay";
@@ -67,6 +89,20 @@ export interface LayerIR {
     shape: Shape;
     /** The raw `data` URL attribute, if any (ctx.layers metadata) — inline-JSON layers have none. */
     dataUrl?: string;
+    /**
+     * The authored live-source options that select this layer's transport
+     * (spec: "Live & Streaming Data"), retained on the IR rather than consumed
+     * by `getData` alone. Both front-ends populate it, so anything asking "is
+     * this layer polling?" reads resolved state instead of querying the DOM —
+     * which only the HTML lane has (see telemetry's per-layer snapshot).
+     * Absent when the layer declares none.
+     */
+    live?: {
+        source?: string;
+        key?: string;
+        flush?: string;
+        refresh?: string;
+    };
     /**
      * A `{z}/{x}/{y}` tile URL template (spec: "Tiled layers"): deck's `data`
      * for TileLayer/MVTLayer. When set, the renderer passes THIS as `data`
@@ -81,8 +117,10 @@ export interface LayerIR {
      */
     asset?: LayerAssetState;
     meta: LayerMeta;
-    /** The layer's active declarative filter, if `filter-field`/`filter-range` are present. */
+    /** The layer's active declarative filter (one entry per dimension), if `filter-field`/`filter-fields` are present. */
     filter?: LayerFilter;
+    /** The layer's active categorical filter (one entry per dimension), if `filter-category`/`filter-category-fields` are present. Independent of `filter`. */
+    categoryFilter?: LayerCategoryFilter;
     /**
      * Per-layer terrain mode (spec: "Terrain") — the `terrain` attribute:
      * drape onto / sit on / ignore an active terrain surface. Absent = the

package/dist/layer-registry.d.ts

@@ -64,6 +64,13 @@ export interface LayerSchema {
      * one-source-of-truth reasoning as `carriesTileset`.
      */
     carriesGeoreference?: boolean;
+    /**
+     * Resolves its own route (spec: "Routing & Tracking") and supports the
+     * `onRouteResolved` deck prop — the runtime injects that hook only into
+     * these types (`Route`), same one-source-of-truth reasoning as
+     * `carriesTileset`. Drives `follow="fit-route"` camera behavior.
+     */
+    carriesRoute?: boolean;
     /** Layer-owned async asset resolver; keeps parse/runtime branching registry-driven rather than name-matched. */
     assetResolver?: "image-overlay";
 }

package/dist/layers/marker-icons.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Self-contained default marker icons (data: URIs) for Route/Tracking layers
+ * — no network fetch, no bundled asset, matching the library's own "sensible
+ * defaults" pillar (an author gets a working map with zero icon setup).
+ * Deliberately tiny/inline rather than a shared icon-atlas system: deck.gl's
+ * `IconLayer.getIcon` accepts a full per-object descriptor (`{url, width,
+ * height}`) and auto-packs it, so no `iconAtlas`/`iconMapping` is needed for
+ * this small a set.
+ */
+export interface IconDescriptor {
+    url: string;
+    width: number;
+    height: number;
+    anchorY?: number;
+}
+/** A dropped-pin marker (origin/destination waypoints on a `Route` layer). Anchored at its point (bottom of the pin), not its center. */
+export declare function pinIcon(color: string): IconDescriptor;
+/** A directional arrow marker (a `Tracking` layer's moving entity) — points "up" (north) at angle 0, rotated per-row via `getAngle`. */
+export declare function arrowIcon(color: string): IconDescriptor;

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

@@ -0,0 +1,71 @@
+/**
+ * RouteLayer — the Route half of "Routing & Tracking" (spec, v0.6.7).
+ * Expands into ordinary `PathLayer`/`IconLayer` instances, exactly the way
+ * `BIMLayer` expands into a `Tile3DLayer` — see that file's own doc comment
+ * for the pattern this mirrors (a `CompositeLayer` wrapping real deck.gl
+ * layers, not a new rendering path).
+ *
+ * Two authoring paths, mutually exclusive (`geometry` wins if both are
+ * present — validation.ts warns on the ambiguity):
+ *
+ *  - `geometry` — an already-computed GeoJSON LineString. Resolves
+ *    SYNCHRONOUSLY, no provider round-trip. Distance is derived locally
+ *    (great-circle length); duration is left `NaN` — no speed model exists
+ *    client-side, and a provider-computed route supplies its own.
+ *  - `provider` + `origin` + `destination` (+ optional `waypoints`,
+ *    `profile`) — resolves ASYNCHRONOUSLY via `RoutingProvider.computeRoute`
+ *    (mirrors BIMLayer's `loadModel`: state, staleness checks, abort on
+ *    supersede/teardown, `raiseError` on failure — see that file).
+ *
+ * `onRouteResolved` is injected by the runtime (`schema.carriesRoute`, the
+ * `onTilesetLoad`/`carriesTileset` precedent in runtime-core.ts) once a
+ * route is ready — that's what drives `follow="fit-route"` camera behavior.
+ * RouteLayer itself never touches the camera; camera side effects belong to
+ * runtime-core, not a deck.gl layer subclass.
+ */
+import { CompositeLayer } from "@deck.gl/core";
+import type { Layer } from "@deck.gl/core";
+import { type Route, type RouteWaypoint } from "../providers";
+export interface RouteBounds {
+    bounds: [[number, number], [number, number]];
+}
+type LineStringGeometry = {
+    type: "LineString";
+    coordinates: [number, number][];
+};
+export interface RouteLayerProps {
+    geometry?: LineStringGeometry | string;
+    origin?: [number, number] | string;
+    destination?: [number, number] | string;
+    waypoints?: RouteWaypoint[] | string;
+    provider?: string;
+    profile?: "driving" | "walking" | "cycling";
+    color?: string;
+    casingColor?: string;
+    /** Injected by runtime-core.ts (schema.carriesRoute) — never authored. */
+    onRouteResolved?: (route: Route & RouteBounds) => void;
+    [prop: string]: unknown;
+}
+export declare class RouteLayer extends CompositeLayer<RouteLayerProps> {
+    static layerName: string;
+    static defaultProps: {
+        color: string;
+        casingColor: string;
+        profile: string;
+    };
+    state: {
+        route: Route | null;
+        loadingFor: string | null;
+        destroyed: boolean;
+        abort: AbortController | null;
+    };
+    initializeState(): void;
+    updateState({ props, oldProps }: {
+        props: RouteLayerProps;
+        oldProps: RouteLayerProps;
+    }): void;
+    finalizeState(): void;
+    private resolveRoute;
+    renderLayers(): Layer[];
+}
+export {};

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

@@ -0,0 +1,52 @@
+/**
+ * TrackingLayer — the Tracking half of "Routing & Tracking" (spec, v0.6.7).
+ * Wraps a single `IconLayer`: renders the CURRENT (or smoothly interpolating)
+ * position of one tracked entity, with bearing-derived rotation.
+ *
+ * v1 scope: ONE tracked entity per layer — the LAST row in `data` is "the"
+ * position. Fleet/multi-entity tracking on one layer is a documented
+ * follow-on, not built here (mirrors this codebase's own "v1 supports one,
+ * generalizing to many is a later tier" precedent — e.g. BIM model
+ * federation's "multiple co-registered models... NOT implemented").
+ *
+ * Position data arrives through the ORDINARY `data`/`source` mechanism (the
+ * design doc is explicit: a tracking feed is "a thin registerSource decoder
+ * over existing machinery", not a new subscription abstraction) —
+ * TrackingLayer itself knows nothing about where the data came from, same as
+ * any other curated layer reading `data`.
+ *
+ * Interpolation between updates and camera-follow are driven EXTERNALLY by
+ * `src/tracking-interpolation.ts` via the per-frame channel
+ * (`RuntimeCore.patchAnimatedProps`) — never inside this class, matching how
+ * RouteLayer never touches the camera itself either. When
+ * `interpolatedPosition` is present (injected only, never authored) it
+ * overrides the raw data-derived position; the un-interpolated fallback
+ * keeps this layer fully functional — just not smooth — even before the
+ * first interpolation frame lands (e.g. the very first fix, headless mode,
+ * or `prefers-reduced-motion`).
+ */
+import { CompositeLayer } from "@deck.gl/core";
+import type { Layer } from "@deck.gl/core";
+export interface TrackingLayerProps {
+    data?: readonly unknown[];
+    getPosition?: (d: unknown, info: {
+        index: number;
+        data: readonly unknown[];
+    }) => [number, number];
+    bearingField?: string;
+    color?: string;
+    size?: number;
+    /** Injected by src/tracking-interpolation.ts — never authored. */
+    interpolatedPosition?: [number, number];
+    interpolatedBearing?: number;
+    [prop: string]: unknown;
+}
+export declare class TrackingLayer extends CompositeLayer<TrackingLayerProps> {
+    static layerName: string;
+    static defaultProps: {
+        bearingField: string;
+        color: string;
+        size: number;
+    };
+    renderLayers(): Layer[];
+}

package/dist/{lerc-gKDDtc69.js → lerc-BgzbFAc7.js}

@@ -1,4 +1,4 @@
-import { C as a, D as s } from "./raster-Cl5m3KsC.js";
+import { C as a, D as s } from "./raster-DtyMY54Z.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-D5in29tf.js");
+  const e = await import("./LercDecode.es-BzboSQ2U.js");
   return l || (await e.load(), l = !0), e;
 }
 async function i(e, r) {

package/dist/license.d.ts

@@ -15,20 +15,17 @@
  * packaged-app `apps` claim — they MAY appear in markup, unlike data
  * credentials.
  *
- * The two claims are NOT equally enforceable, and neither is a security
- * boundary. `domains` is checked against a hostname the browser pins;
- * `apps` is checked against an identifier the caller passes in, so any page
- * holding the key can assert any app id (bundle ids are public and app
- * bundles unpack trivially). Native shells must therefore read app identity
- * from trusted platform APIs, never from bridge JSON controlled by page
- * code — but that is a host obligation this module cannot verify. No
- * origin-sniffing gate guards it either: packaged hosts land on origins
- * indistinguishable from the web (Capacitor Android serves http://localhost,
- * WebViewAssetLoader serves any configured https domain), so a heuristic
- * would downgrade paying customers to the free tier — and the packaged
- * contexts worth protecting already lift every cap as DEV contexts below.
- * Both claims are deterrents that make reuse attributable via `keyId`;
- * packaged-app enforcement is LEGAL, not technical (see LICENSE.md).
+ * Both claims are deployment SCOPING, not access control: keys are
+ * publishable by design, and commercial-use enforcement is LEGAL rather than
+ * technical (see LICENSE.md) — `keyId` is what makes a deployment
+ * attributable. `appId` reaches this module as a plain argument whose
+ * provenance it cannot verify, so a native host MUST source it from trusted
+ * platform build metadata and never from page script or bridge JSON.
+ *
+ * NOTE: this header is emitted verbatim into the published dist/license.d.ts.
+ * Keep it to the contract a consumer needs. Comparative analysis of how far
+ * each claim can be trusted, and why no origin heuristic guards the app
+ * claim, lives in agent-map-library-architecture.md (internal, not shipped).
  *
  * Decisions (spec, RESOLVED 2026-07-14; REVISED 2026-08-05): free tier =
  * 5 layers / 25k rows per layer / 20 MB fetch; any paid plan hides the