@nika-js/onlymap 0.1.0

package/dist/basemap.d.ts

@@ -0,0 +1,72 @@
+import "maplibre-gl/dist/maplibre-gl.css";
+import type { DeckProps, Viewport } from "@deck.gl/core";
+export interface ViewportLike {
+    project(xyz: number[]): number[];
+    getBounds(): [number, number, number, number];
+    width: number;
+    height: number;
+}
+/** What `RuntimeCore.getViewport()` returns in either mode — deck.gl's own `Viewport` (standalone) or this adapter's narrower shape (with a basemap). */
+export type MapViewport = Viewport | ViewportLike;
+export interface BasemapViewState {
+    longitude: number;
+    latitude: number;
+    zoom: number;
+    pitch: number;
+    bearing: number;
+}
+export declare class MapLibreBasemapAdapter {
+    private map;
+    private overlay;
+    /**
+     * One-time "has the map initialized at least once" flag, set by the first
+     * `load` event. Deliberately NOT `this.map.loaded()` — that method means
+     * something different (and narrower): "is everything currently settled —
+     * no in-flight camera transition, no tiles still loading for the current
+     * viewport." It goes false for the ENTIRE DURATION of a pan/zoom (while
+     * new tiles fetch), which made `getViewport()` return `undefined` for the
+     * whole gesture — the CPU-side viewport-filter fallback ("no viewport
+     * resolved yet — include everything") kicked in for every intermediate
+     * frame, and since MapLibre's `move` event stops firing once the camera
+     * actually settles, the LAST widget render before settling was often
+     * still mid-gesture and never got superseded — visibly "stuck" showing
+     * unfiltered data after a pan, exactly the bug this fixes.
+     */
+    private initialized;
+    private loadCallbacks;
+    constructor(container: HTMLElement, basemapAttr: string, initialView: {
+        longitude: number;
+        latitude: number;
+        zoom: number;
+        pitch?: number;
+        bearing?: number;
+    }, deckProps: DeckProps);
+    private markInitialized;
+    onLoad(cb: () => void): void;
+    /** Fires continuously during pan/zoom/rotate — MapLibre's own camera-change event, standing in for deck's onViewStateChange (which doesn't apply — deck isn't driving the camera). */
+    onMove(cb: () => void): void;
+    setLayers(layers: DeckProps["layers"]): void;
+    /** Toggle map interactions (spec: "Manual Drawing", D4) — used to suspend double-click-zoom while a draw tool is active. */
+    setInteractive(opts: {
+        doubleClickZoom?: boolean;
+    }): void;
+    isLoaded(): boolean;
+    getViewport(): ViewportLike;
+    getViewState(): BasemapViewState;
+    /** Instant recenter/rezoom — the basemap's own camera jump, no deck viewState involved. */
+    jumpTo(center: [number, number], zoom?: number): void;
+    /**
+     * Animated camera (spec: "Map Stories / Animation primitives") — MapLibre's
+     * own easing. `curve` uses `flyTo` (the arcing zoom-out-and-in) instead of
+     * the direct `easeTo` interpolation. duration 0 degrades to an instant
+     * move, so this is also the one method that reaches pitch/bearing.
+     */
+    easeTo(view: {
+        center?: [number, number];
+        zoom?: number;
+        pitch?: number;
+        bearing?: number;
+    }, durationMs: number, curve?: boolean): void;
+    fitBounds(bounds: [[number, number], [number, number]], padding: number, durationMs?: number): void;
+    destroy(): void;
+}

package/dist/convert-arrow-schema-CvZ3cT5m.js

@@ -0,0 +1,94 @@
+import { S as c, F as o, h as u, o as l, L as w, n as m, x as d, b7 as b, b3 as p, bx as f, bt as h, bv as M, bz as S, bo as z, bk as F, bm as I, bq as v, ay as y, aw as x, k as A, aT as D, aR as U, aP as N, bG as k, bE as B, bC as E, bI as L, aZ as j, f as W, aW as q, a$ as C, B as G, m as O, N as P } from "./recordbatch-HRu0SMKp.js";
+function Z(e) {
+  return R(e);
+}
+function R(e) {
+  return new c(e.fields.map((n) => r(n)), a(e.metadata));
+}
+function a(e) {
+  return e ? new Map(Object.entries(e)) : /* @__PURE__ */ new Map();
+}
+function r(e) {
+  return new o(e.name, T(e.type), e.nullable, a(e.metadata));
+}
+function T(e) {
+  if (typeof e == "object")
+    switch (e.type) {
+      case "decimal":
+        return new d(e.precision, e.scale, e.bitWidth);
+      case "map":
+        let n = e.children.map((t) => r(t));
+        return new m(n, e.keysSorted);
+      case "list":
+        const s = r(e.children[0]);
+        return new w(s);
+      case "fixed-size-list":
+        const i = r(e.children[0]);
+        return new l(e.listSize, i);
+      case "struct":
+        return n = e.children.map((t) => r(t)), new u(n);
+      default:
+        throw new Error("array type not supported");
+    }
+  switch (e) {
+    case "null":
+      return new P();
+    case "binary":
+      return new O();
+    case "bool":
+      return new G();
+    case "int8":
+      return new C();
+    case "int16":
+      return new q();
+    case "int32":
+      return new W();
+    case "int64":
+      return new j();
+    case "uint8":
+      return new L();
+    case "uint16":
+      return new E();
+    case "uint32":
+      return new B();
+    case "uint64":
+      return new k();
+    case "float16":
+      return new N();
+    case "float32":
+      return new U();
+    case "float64":
+      return new D();
+    case "utf8":
+      return new A();
+    case "date-day":
+      return new x();
+    case "date-millisecond":
+      return new y();
+    case "time-second":
+      return new v();
+    case "time-millisecond":
+      return new I();
+    case "time-microsecond":
+      return new F();
+    case "time-nanosecond":
+      return new z();
+    case "timestamp-second":
+      return new S();
+    case "timestamp-millisecond":
+      return new M();
+    case "timestamp-microsecond":
+      return new h();
+    case "timestamp-nanosecond":
+      return new f();
+    case "interval-daytime":
+      return new p();
+    case "interval-yearmonth":
+      return new b();
+    default:
+      throw new Error("array type not supported");
+  }
+}
+export {
+  Z as c
+};

package/dist/csp-sandbox.d.ts

@@ -0,0 +1,20 @@
+/** The static page a caller should host (with a `script-src 'unsafe-eval'` CSP scoped to that path) for genuine strict-CSP compatibility — see this module's doc comment. */
+export declare function sandboxHtml(): string;
+/**
+ * Evaluates `source` (a `new Function(source)` body, no params) inside the
+ * sandbox iframe and returns its result. Pass `sandboxUrl` for genuine
+ * strict-CSP compatibility (see this module's doc comment) — without it,
+ * this still isolates the code's execution context but does not itself
+ * regain `unsafe-eval` under a CSP that already forbids it.
+ */
+export declare function evaluateInSandbox(source: string, sandboxUrl?: string): Promise<unknown>;
+/**
+ * The sandboxed counterpart to `compileFullJsAccessorBlock` — same
+ * strip-export/collect-names transform, but the actual `new Function`
+ * evaluation happens in the iframe rather than the main page. Async,
+ * unlike its synchronous counterpart, for the reasons in this module's doc
+ * comment.
+ */
+export declare function compileFullJsAccessorBlockInSandbox(blockText: string, sandboxUrl?: string): Promise<Record<string, unknown>>;
+/** Tears down the sandbox iframe — mainly for tests/dev cleanup, not needed in normal page-lifetime usage. */
+export declare function destroySandbox(): void;

package/dist/ctx.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Runtime Context object (spec: "Runtime Context API") — injected into
+ * every widget render. A stable contract that deliberately never exposes
+ * deck.gl internals (no layerManager, no raw Deck instance) — only the
+ * viewport (for projection) crosses that boundary, per the spec's own
+ * rationale.
+ */
+import type { LayerIR, LayerFilter } from "./ir";
+import type { RuntimeCore } from "./runtime-core";
+import type { Selection } from "./selection";
+import { type Stats } from "./stats";
+export interface LayerMetaSnapshot {
+    id: string;
+    label?: string;
+    color?: string;
+    visible: boolean;
+    type: string;
+    dataUrl?: string;
+    /** The layer's active declarative filter, if any (spec: "Filtering") — read by the built-in `filter` widget. */
+    filter?: LayerFilter;
+}
+export interface DataOpts {
+    /** Set `false` to bypass the layer's active declarative filter (spec: "Filter-aware stats & data (the coherence rule)"). Default `true`. */
+    filtered?: boolean;
+}
+export interface RuntimeContext {
+    layers: LayerMetaSnapshot[];
+    viewport: {
+        bounds: [[number, number], [number, number]];
+        zoom: number;
+        center: [number, number];
+        project(lngLat: [number, number]): [number, number];
+    };
+    selection: Selection | null;
+    emit(event: string, payload?: Record<string, unknown>): void;
+    data(layerId: string, opts?: DataOpts): Promise<unknown[]>;
+    dataInViewport(layerId: string, opts?: DataOpts): Promise<unknown[]>;
+    stats(layerId: string, field: string, opts?: {
+        scope?: "all" | "viewport";
+    } & DataOpts): Stats;
+}
+export interface BuildCtxDeps {
+    layerIRs: ReadonlyMap<string, LayerIR>;
+    core: RuntimeCore;
+    mapEl: Element;
+    selection: Selection | null;
+}
+/** Built fresh on every widget-render invocation — never mutated, never reused. */
+export declare function buildCtx({ layerIRs, core, mapEl, selection }: BuildCtxDeps): RuntimeContext;

package/dist/d3-bundle.d.ts

@@ -0,0 +1,218 @@
+/**
+ * The `d3` global exposed to widget script blocks (spec: "Available globals" —
+ * "D3 (bundled, tree-shaken to core + scale + array)"). Bundled directly
+ * (unlike Vega) since d3-scale is already a hard dependency of the accessor
+ * expression language (scale()).
+ */
+import * as d3Scale from "d3-scale";
+import * as d3Array from "d3-array";
+export declare const d3: {
+    min(iterable: Iterable<string>): string | undefined;
+    min<T extends d3Array.Numeric>(iterable: Iterable<T>): T | undefined;
+    min<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null): string | undefined;
+    min<T, U extends d3Array.Numeric>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null): U | undefined;
+    minIndex(iterable: Iterable<unknown>): number;
+    minIndex<TDatum>(iterable: Iterable<TDatum>, accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => unknown): number;
+    minIndex(iterable: Iterable<unknown>): number;
+    max(iterable: Iterable<string>): string | undefined;
+    max<T extends d3Array.Numeric>(iterable: Iterable<T>): T | undefined;
+    max<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null): string | undefined;
+    max<T, U extends d3Array.Numeric>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null): U | undefined;
+    maxIndex(iterable: Iterable<unknown>): number;
+    maxIndex<TDatum>(iterable: Iterable<TDatum>, accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => unknown): number;
+    extent(iterable: Iterable<string>): [string, string] | [undefined, undefined];
+    extent<T extends d3Array.Numeric>(iterable: Iterable<T>): [T, T] | [undefined, undefined];
+    extent<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null): [string, string] | [undefined, undefined];
+    extent<T, U extends d3Array.Numeric>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null): [U, U] | [undefined, undefined];
+    mode(iterable: Iterable<d3Array.Numeric | undefined | null>): number;
+    mode<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number;
+    sum(iterable: Iterable<d3Array.Numeric | undefined | null>): number;
+    sum<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number;
+    mean(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
+    mean<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number | undefined;
+    median(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
+    median<T>(iterable: Iterable<T>, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number | undefined;
+    medianIndex(iterable: Iterable<d3Array.Numeric | undefined | null>): number;
+    medianIndex<T>(iterable: Iterable<T>, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number;
+    cumsum(iterable: Iterable<d3Array.Numeric | undefined | null>): Float64Array;
+    cumsum<T>(iterable: Iterable<T>, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): Float64Array;
+    quantile(iterable: Iterable<d3Array.Numeric | undefined | null>, p: number): number | undefined;
+    quantile<T>(iterable: Iterable<T>, p: number, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number | undefined;
+    quantileIndex(iterable: Iterable<d3Array.Numeric | undefined | null>, p: number): number;
+    quantileIndex<T>(iterable: Iterable<T>, p: number, accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null): number;
+    quantileSorted(array: Array<d3Array.Numeric | undefined | null>, p: number): number | undefined;
+    quantileSorted<T>(array: T[], p: number, accessor: (element: T, i: number, array: T[]) => number | undefined | null): number | undefined;
+    rank(iterable: Iterable<d3Array.Numeric | undefined | null>): Float64Array;
+    rank<T>(iterable: Iterable<T>, accessorOrComparator: ((datum: T, index: number, array: Iterable<T>) => number | undefined | null) | ((a: T, b: T) => number | undefined | null)): Float64Array;
+    variance(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
+    variance<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number | undefined;
+    deviation(iterable: Iterable<d3Array.Numeric | undefined | null>): number | undefined;
+    deviation<T>(iterable: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number | undefined;
+    fsum(values: Iterable<d3Array.Numeric | undefined | null>): number;
+    fsum<T>(values: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): number;
+    fcumsum(values: Iterable<d3Array.Numeric | undefined | null>): Float64Array;
+    fcumsum<T>(values: Iterable<T>, accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null): Float64Array;
+    least<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T | undefined;
+    least<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T | undefined;
+    leastIndex(iterable: Iterable<unknown>): number | undefined;
+    leastIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
+    leastIndex<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): number | undefined;
+    greatest<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T | undefined;
+    greatest<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T | undefined;
+    greatestIndex(iterable: Iterable<unknown>): number | undefined;
+    greatestIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
+    greatestIndex<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): number | undefined;
+    bisectLeft(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+    bisectLeft(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+    bisectLeft(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+    bisectRight(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+    bisectRight(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+    bisectRight(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+    bisectCenter(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+    bisectCenter(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+    bisectCenter(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+    bisector<T, U>(comparator: (a: T, b: U) => number): d3Array.Bisector<T, U>;
+    bisector<T, U>(accessor: (x: T) => U): d3Array.Bisector<T, U>;
+    quickselect<T>(array: ArrayLike<T>, k: number, left?: number, right?: number, compare?: (a: d3Array.Primitive | undefined, b: d3Array.Primitive | undefined) => number): T[];
+    ascending(a: d3Array.Primitive | undefined, b: d3Array.Primitive | undefined): number;
+    descending(a: d3Array.Primitive | undefined, b: d3Array.Primitive | undefined): number;
+    group<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedInternMap<TObject, TObject[], TKeys>;
+    groups<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedArray<TObject, TObject[], TKeys>;
+    flatGroup<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): Array<[...TKeys, TObject[]]>;
+    index<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedInternMap<TObject, TObject, TKeys>;
+    indexes<TObject, TKeys extends unknown[]>(iterable: Iterable<TObject>, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedArray<TObject, TObject, TKeys>;
+    rollup<TObject, TReduce, TKeys extends unknown[]>(iterable: Iterable<TObject>, reduce: (values: TObject[]) => TReduce, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedInternMap<TObject, TReduce, TKeys>;
+    rollups<TObject, TReduce, TKeys extends unknown[]>(iterable: Iterable<TObject>, reduce: (values: TObject[]) => TReduce, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): d3Array.NestedArray<TObject, TReduce, TKeys>;
+    flatRollup<TObject, TReduce, TKeys extends unknown[]>(iterable: Iterable<TObject>, reduce: (values: TObject[]) => TReduce, ...keys: { [Index in keyof TKeys]: (value: TObject, index: number, values: TObject[]) => TKeys[Index]; }): Array<[...TKeys, TReduce]>;
+    groupSort<TObject, TKey>(iterable: Iterable<TObject>, comparator: (a: TObject[], b: TObject[]) => number, key: (value: TObject) => TKey): TKey[];
+    groupSort<TObject, TKey>(iterable: Iterable<TObject>, accessor: (value: TObject[]) => unknown, key: (value: TObject) => TKey): TKey[];
+    count(iterable: Iterable<unknown>): number;
+    count<TObject>(iterable: Iterable<TObject>, accessor: (a: TObject, b: TObject) => number | null | undefined): number;
+    cross<T extends unknown[]>(...iterables: { [K in keyof T]: Iterable<T[K]>; }): T[];
+    cross<T extends unknown[], U>(...args: [...iterables: { [K in keyof T]: Iterable<T[K]>; }, reducer: (...values: T) => U]): U[];
+    merge<T>(iterables: Iterable<Iterable<T>>): T[];
+    pairs<T>(iterable: Iterable<T>): Array<[T, T]>;
+    pairs<T, U>(iterable: Iterable<T>, reducer: (a: T, b: T) => U): U[];
+    permute<T>(source: {
+        [key: number]: T;
+    }, keys: Iterable<number>): T[];
+    permute<T, K extends keyof T>(source: T, keys: Iterable<K>): Array<T[K]>;
+    shuffle<T>(array: T[], lo?: number, hi?: number): T[];
+    shuffle(array: Int8Array, lo?: number, hi?: number): Int8Array;
+    shuffle(array: Uint8Array, lo?: number, hi?: number): Uint8Array;
+    shuffle(array: Uint8ClampedArray, lo?: number, hi?: number): Uint8ClampedArray;
+    shuffle(array: Int16Array, lo?: number, hi?: number): Int16Array;
+    shuffle(array: Uint16Array, lo?: number, hi?: number): Uint16Array;
+    shuffle(array: Int32Array, lo?: number, hi?: number): Int32Array;
+    shuffle(array: Uint32Array, lo?: number, hi?: number): Uint32Array;
+    shuffle(array: Float32Array, lo?: number, hi?: number): Float32Array;
+    shuffle(array: Float64Array, lo?: number, hi?: number): Float64Array;
+    shuffler(random: () => number): typeof d3Array.shuffle;
+    ticks(start: number, stop: number, count: number): number[];
+    tickIncrement(start: number, stop: number, count: number): number;
+    tickStep(start: number, stop: number, count: number): number;
+    nice(start: number, stop: number, count: number): [number, number];
+    range(stop: number): number[];
+    range(start: number, stop: number, step?: number): number[];
+    transpose<T>(matrix: ArrayLike<ArrayLike<T>>): T[][];
+    zip<T>(...arrays: Array<ArrayLike<T>>): T[][];
+    blur(data: ArrayLike<number>, radius: number): ArrayLike<number>;
+    blur2(data: d3Array.Matrix, rx: number, ry?: number): d3Array.Matrix;
+    blurImage(imageData: ImageData, rx: number, ry?: number): ImageData;
+    every<T>(iterable: Iterable<T>, test: (value: T, index: number, iterable: Iterable<T>) => unknown): boolean;
+    some<T>(iterable: Iterable<T>, test: (value: T, index: number, iterable: Iterable<T>) => unknown): boolean;
+    filter<T>(iterable: Iterable<T>, test: (value: T, index: number, iterable: Iterable<T>) => unknown): T[];
+    map<T, U>(iterable: Iterable<T>, mapper: (value: T, index: number, iterable: Iterable<T>) => U): U[];
+    reduce<T>(iterable: Iterable<T>, reducer: (previousValue: T, currentValue: T, currentIndex: number, iterable: Iterable<T>) => T, initialValue?: T): T;
+    reduce<T, U>(iterable: Iterable<T>, reducer: (previousValue: U, currentValue: T, currentIndex: number, iterable: Iterable<T>) => U, initialValue: U): U;
+    reverse<T>(iterable: Iterable<T>): T[];
+    sort<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T[];
+    sort<T>(iterable: Iterable<T>, ...accessors: Array<(a: T) => unknown>): T[];
+    difference<T>(iterable: Iterable<T>, ...others: Array<Iterable<T>>): d3Array.InternSet<T>;
+    union<T>(...iterables: Array<Iterable<T>>): d3Array.InternSet<T>;
+    intersection<T>(...iterables: Array<Iterable<T>>): d3Array.InternSet<T>;
+    superset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+    subset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+    disjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+    histogram(): d3Array.HistogramGeneratorNumber<number, number>;
+    histogram<Datum, Value extends number | undefined>(): d3Array.HistogramGeneratorNumber<Datum, Value>;
+    histogram<Datum, Value extends Date | undefined>(): d3Array.HistogramGeneratorDate<Datum, Value>;
+    bin(): d3Array.HistogramGeneratorNumber<number, number>;
+    bin<Datum, Value extends number | undefined>(): d3Array.HistogramGeneratorNumber<Datum, Value>;
+    bin<Datum, Value extends Date | undefined>(): d3Array.HistogramGeneratorDate<Datum, Value>;
+    thresholdFreedmanDiaconis(values: ArrayLike<number | undefined>, min: number, max: number): number;
+    thresholdScott(values: ArrayLike<number | undefined>, min: number, max: number): number;
+    thresholdSturges(values: ArrayLike<number | undefined>): number;
+    Adder: typeof d3Array.Adder;
+    bisect: typeof d3Array.bisectRight;
+    InternMap: typeof d3Array.InternMap;
+    InternSet: typeof d3Array.InternSet;
+    tickFormat(start: number, stop: number, count: number, specifier?: string): (d: d3Scale.NumberValue) => string;
+    scaleLinear<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleLinear<Range, Output, Unknown>;
+    scaleLinear<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleLinear<Range, Output, Unknown>;
+    scalePow<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
+    scalePow<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
+    scaleSqrt<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
+    scaleSqrt<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScalePower<Range, Output, Unknown>;
+    scaleLog<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleLogarithmic<Range, Output, Unknown>;
+    scaleLog<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleLogarithmic<Range, Output, Unknown>;
+    scaleSymlog<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleSymLog<Range, Output, Unknown>;
+    scaleSymlog<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleSymLog<Range, Output, Unknown>;
+    scaleIdentity<Unknown = never>(range?: Iterable<d3Scale.NumberValue>): d3Scale.ScaleIdentity<Unknown>;
+    scaleRadial<Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleRadial<Range, Range, Unknown>;
+    scaleRadial<Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleRadial<Range, Range, Unknown>;
+    scaleTime<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
+    scaleTime<Range, Output = Range, Unknown = never>(domain: Iterable<Date | d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
+    scaleUtc<Range = number, Output = Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
+    scaleUtc<Range, Output = Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleTime<Range, Output, Unknown>;
+    scaleSequential<Output = number, Unknown = never>(interpolator?: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequential<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialLog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialLog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialPow<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialPow<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialSqrt<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialSqrt<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialSymlog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialSymlog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequential<Output, Unknown>;
+    scaleSequentialQuantile<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleSequentialQuantile<Output, Unknown>;
+    scaleSequentialQuantile<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleSequentialQuantile<Output, Unknown>;
+    scaleDiverging<Output = number, Unknown = never>(interpolator?: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDiverging<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: ((t: number) => Output) | Iterable<Output>): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingLog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingLog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingPow<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingPow<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingSqrt<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingSqrt<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingSymlog<Output = number, Unknown = never>(interpolator?: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleDivergingSymlog<Output, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, interpolator: (t: number) => Output): d3Scale.ScaleDiverging<Output, Unknown>;
+    scaleQuantize<Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleQuantize<Range, Unknown>;
+    scaleQuantize<Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue>, range: Iterable<Range>): d3Scale.ScaleQuantize<Range, Unknown>;
+    scaleQuantile<Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleQuantile<Range, Unknown>;
+    scaleQuantile<Range, Unknown = never>(domain: Iterable<d3Scale.NumberValue | null | undefined>, range: Iterable<Range>): d3Scale.ScaleQuantile<Range, Unknown>;
+    scaleThreshold<Domain extends number | string | Date = number, Range = number, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleThreshold<Domain, Range, Unknown>;
+    scaleThreshold<Domain extends number | string | Date, Range, Unknown = never>(domain: Iterable<Domain>, range: Iterable<Range>): d3Scale.ScaleThreshold<Domain, Range, Unknown>;
+    scaleOrdinal<Range>(range?: Iterable<Range>): d3Scale.ScaleOrdinal<string, Range>;
+    scaleOrdinal<Domain extends {
+        toString(): string;
+    }, Range, Unknown = never>(range?: Iterable<Range>): d3Scale.ScaleOrdinal<Domain, Range, Unknown>;
+    scaleOrdinal<Domain extends {
+        toString(): string;
+    }, Range, Unknown = never>(domain: Iterable<Domain>, range: Iterable<Range>): d3Scale.ScaleOrdinal<Domain, Range, Unknown>;
+    scaleBand<Domain extends {
+        toString(): string;
+    } = string>(range?: Iterable<d3Scale.NumberValue>): d3Scale.ScaleBand<Domain>;
+    scaleBand<Domain extends {
+        toString(): string;
+    }>(domain: Iterable<Domain>, range: Iterable<d3Scale.NumberValue>): d3Scale.ScaleBand<Domain>;
+    scalePoint<Domain extends {
+        toString(): string;
+    } = string>(range?: Iterable<d3Scale.NumberValue>): d3Scale.ScalePoint<Domain>;
+    scalePoint<Domain extends {
+        toString(): string;
+    }>(domain: Iterable<Domain>, range: Iterable<d3Scale.NumberValue>): d3Scale.ScalePoint<Domain>;
+    scaleImplicit: {
+        name: "implicit";
+    };
+};

package/dist/data-emit.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `data-emit` delegation (spec: "Wiring DOM events to emits — two layers",
+ * Level 1). Shared between <om-widget> and <om-overlay> — both are
+ * shadow-DOM content hosts where an author's zero-script markup can declare
+ * `data-emit="event"` + `data-*` payload keys (DOM camel-casing, e.g.
+ * `data-feature-id` -> `featureId`) instead of writing a script block.
+ * Fires on click for non-form elements, change for form elements (which also
+ * get their own `.value` merged in).
+ */
+export declare function attachDataEmitDelegation(root: ShadowRoot, emit: (event: string, payload: Record<string, unknown>) => void): void;

package/dist/data-layer.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Data Layer (spec: "Module Breakdown / Data Layer").
+ * Fetches the `data` attribute URL and caches the parsed response by URL, or
+ * (Phase 3) reads inline JSON from a child `<script type="application/json">`
+ * synchronously with no fetch/cache involved. Full request-generation/
+ * AbortController handling (Q6: "Async data loading & the reconcile race") is
+ * still a minimal, safe subset here — a per-URL fetch generation so a
+ * superseded request can't clobber a newer one — not the full machinery.
+ *
+ * Columnar (spec: "Columnar / GeoArrow Ingestion"): the Data Layer is where
+ * columnar sources become `ColumnarData` — Arrow IPC files (`.arrow`,
+ * lazy-importing apache-arrow so it never weighs on the eager bundle) and
+ * column-oriented JSON (`{ columns: { field: [...] } }`, inline or fetched).
+ * Columnar data is handed to deck.gl as-is (zero row materialization on the
+ * render path); row objects are materialized lazily and memoized only when
+ * a row-consuming surface (ctx.data, picking, highlight-by-id) asks.
+ */
+import type { Shape, ColumnarData, LayerData } from "./ir";
+export declare function isColumnar(data: LayerData): data is ColumnarData;
+/** `Array` as-is, or a FeatureCollection's `.features`, or a lone object wrapped in an array. */
+export declare function normalizeFeatures(json: unknown): unknown[];
+/** Parsed-JSON → LayerData: columnar `{ columns }` form, or the usual feature-array normalization. */
+export declare function normalizeData(json: unknown): LayerData;
+/**
+ * The one place the runtime reads a column value out of the ColumnarData
+ * layout (compiled accessors emit the equivalent access as codegen — see
+ * expr/compile.ts `columnAccess`, the documented contract this mirrors). A
+ * missing column reads as an empty column, matching getField's
+ * undefined-not-throw semantics.
+ */
+export declare function getColumn(data: ColumnarData, field: string): ArrayLike<unknown>;
+/**
+ * Row view over any LayerData. Arrays pass through untouched (zero cost);
+ * columnar data materializes plain flat row objects ONCE per data object and
+ * memoizes — the spec's Tier-2 rule ("bulk raw features is inherently O(N)
+ * when requested") made concrete. Render/stats hot paths never call this;
+ * ctx.data()/dataInViewport(), picking, and highlight-by-id do.
+ */
+export declare function asRows(data: LayerData): readonly unknown[];
+/** A single row by index — shares the asRows memo so a picked row's identity is stable across picks. */
+export declare function rowAt(data: LayerData, index: number): unknown;
+/** Structural slice of an apache-arrow Table — keeps apache-arrow out of the static import graph. */
+export interface ArrowTableLike {
+    numRows: number;
+    schema: {
+        fields: {
+            name: string;
+            type: unknown;
+            metadata?: Map<string, string>;
+        }[];
+    };
+    getChild(name: string): {
+        get(i: number): unknown;
+        toArray(): ArrayLike<unknown>;
+    } | null;
+}
+/**
+ * Arrow Table → ColumnarData. Primitive columns come out as `toArray()`
+ * views (typed arrays for numerics — no per-value copying; Int64 coerces to
+ * Float64 because $field expressions reject BigInt — see expr/compile.ts).
+ * Geometry columns — FixedSizeList (interleaved), or `coordField` for the
+ * separated Struct{x, y} encoding — materialize to per-row [x, y(, z)]
+ * arrays once at load, so `get-position="$geometry"` works like any $field.
+ */
+export declare function arrowTableToColumnar(table: ArrowTableLike, coordField?: string): ColumnarData;
+/** Arrow table → LayerData: line/polygon GeoArrow becomes GeoJSON feature rows; everything else takes the columnar path. */
+export declare function arrowTableToLayerData(table: ArrowTableLike): LayerData;
+export interface DataFormat {
+    /** Claim a URL (extension test) and/or a response (Content-Type test — undefined during URL-only checks). */
+    match(url: string, contentType?: string): boolean;
+    /** Parse the claimed response. The parser module should be lazy-imported here (HU1 — the apache-arrow precedent). `url` is the requested URL (res.url is empty on constructed Responses — test fetches, service workers). */
+    parse(res: Response, url: string): Promise<LayerData>;
+}
+/**
+ * Row objects → ColumnarData (the memory-efficient shape: one array per
+ * column instead of N objects; all-numeric columns become Float64Array).
+ * Returns undefined for empty input — an empty flat array round-trips
+ * better than a zero-length columnar table.
+ */
+export declare function rowsToColumnar(rows: Record<string, unknown>[]): ColumnarData | undefined;
+/** `OmMap.registerFormat(format)` — plug in a parser for a format the library doesn't ship (spec: "v0.2 / Tier 1"). */
+export declare function registerFormat(format: DataFormat): void;
+/**
+ * A source plugin supplies domain decoding (and optionally a subscription
+ * handshake); the transport (WebSocket, reconnect, flush) is generic.
+ * Registered via `OmMap.registerSource(name, plugin)` and selected by the
+ * layer's `source` attribute.
+ */
+export interface SourcePlugin {
+    /** Called on every (re)connect — e.g. send a subscription message (aisstream.io-style APIs). */
+    onOpen?(send: (message: string) => void): void;
+    /** Raw (JSON-parsed, when parseable) socket message → entity object(s) to upsert, or null to ignore. */
+    decode(raw: unknown): Record<string, unknown> | Record<string, unknown>[] | null;
+}
+export declare function registerSource(name: string, plugin: SourcePlugin): void;
+/** Options carried by the layer's reserved live-source attributes (`source`, `key`, `flush` for streams; `refresh` for polling). */
+export interface StreamOptions {
+    source?: string;
+    key?: string;
+    flush?: string;
+    refresh?: string;
+}
+/**
+ * Request configuration for every `data` URL the Data Layer fetches
+ * (including polling refreshes and Arrow files). Deliberately a
+ * PROGRAMMATIC surface, not manifest attributes: credentials in markup
+ * would put secrets into the DOM — and into agent-generated manifests.
+ *
+ *   OmMap.configureData({ headers: { Authorization: `Bearer ${token}` } });
+ *   OmMap.configureData({ headers: (url) => url.startsWith("/api/") ? auth : undefined });
+ */
+export interface DataRequestConfig {
+    /** Static headers, or a per-URL function (return undefined to send none for that URL). */
+    headers?: HeadersInit | ((url: string) => HeadersInit | undefined);
+    credentials?: RequestCredentials;
+    /** Full fetch replacement (custom retry/signing/proxy logic). Receives the resolved RequestInit. */
+    fetch?: typeof fetch;
+}
+export declare function configureData(config: DataRequestConfig): void;
+/** `data="draw:sketch"` — the reserved scheme for a widget-fed sketch layer (never collides with http/ws/inline). */
+export declare function isDrawUrl(url: string): boolean;
+/**
+ * Push a new sketch snapshot into a `draw:<name>` store (the draw widget's
+ * DrawSession.onChange calls this). A FRESH array reference is stored so
+ * deck.gl's shallow `data` diff re-renders, then the bound layer's notify
+ * fires the reconcile — the exact path a stream flush takes. Safe to call
+ * before any layer has bound (the snapshot waits in the store).
+ */
+export declare function setDrawData(url: string, features: readonly unknown[]): void;
+/** Current snapshot for a draw store (autosave / save-to-file read the source of truth here). */
+export declare function getDrawData(url: string): LayerData;
+/**
+ * Returns the currently-known data for `url` (synchronously) — an empty
+ * array if not yet loaded (the Q6 "empty placeholder" pattern). Kicks off a
+ * fetch — or, for `ws:`/`wss:` URLs, a live stream (spec: "Live & Streaming
+ * Data"), or binds a `draw:` sketch store (spec: "Manual Drawing") — on first
+ * call for a given URL, and invokes `onLoaded` on every resolution/flush (the
+ * caller re-reconciles from there).
+ */
+export declare function getData(url: string, onLoaded: () => void, opts?: StreamOptions): LayerData;
+/** Is a fetch for this URL still in flight? Feeds the `om-map-ready` signal — errored fetches count as settled (readiness must not hang on a bad URL). */
+export declare function isPendingData(url: string): boolean;
+/**
+ * Minimal feature-shape detection (spec: "Feature Field Resolution & Data
+ * Shape" — full per-layer caching/registry treatment is a later phase; this
+ * is just enough to drive $field resolution for the accessor compiler).
+ * Columnar data self-identifies by construction; a GeoJSON feature has
+ * `{ type: "Feature", properties, geometry }`; any other shape is flat.
+ */
+export declare function detectShape(data: LayerData): Shape;

package/dist/declarative-filter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CPU-side mirror of the GPU `DataFilterExtension` test (spec: "Filter-aware
+ * stats & data (the coherence rule)") — `ctx.stats`/`ctx.dataInViewport`
+ * apply the SAME field+range test by default, so a chart/stat reflects what
+ * the map visibly shows. A row whose field isn't a finite number is treated
+ * as filtered-out, matching the GPU path (a non-numeric `getFilterValue`
+ * result can't land inside any finite `filterRange`).
+ */
+import type { Shape, LayerFilter } from "./ir";
+export declare function applyDeclarativeFilter(rows: readonly unknown[], shape: Shape, filter: LayerFilter): unknown[];
+/** The same test as a reusable predicate — the columnar viewport filter runs it inside its index-aligned loop. */
+export declare function declarativeFilterPredicate(shape: Shape, filter: LayerFilter): (row: unknown) => boolean;