@nika-js/onlymap 0.1.0

package/dist/runtime-core.d.ts

@@ -0,0 +1,170 @@
+import type { LayerIR } from "./ir";
+import { type Selection } from "./selection";
+import type { ValidationEntry } from "./validation";
+import type { MapViewport } from "./basemap";
+/** `basemap="mapbox-*"` isn't implemented — kept maplibre-free so validation/runtime can check without loading the chunk. */
+export declare function isMapboxBasemap(raw: string): boolean;
+export interface InitialView {
+    longitude: number;
+    latitude: number;
+    zoom: number;
+    /** Initial camera tilt/rotation — first-class for 3D content (`<om-map pitch="55">`). */
+    pitch?: number;
+    bearing?: number;
+}
+interface ViewState extends InitialView {
+    pitch: number;
+    bearing: number;
+}
+/** Animated-camera options (spec: "Map Stories / Animation primitives"). Omit `duration` (or 0) for an instant move. */
+export interface CameraOptions {
+    duration?: number;
+    /** Arc the move (zoom-out-and-in) instead of easing directly — MapLibre `flyTo` / deck `FlyToInterpolator`. */
+    curve?: boolean;
+}
+export interface RuntimeCoreCallbacks {
+    /** Fired whenever the view state changes (pan/zoom/pitch/bearing) — a notification, not a value. */
+    onViewportChange?: () => void;
+    onSelectionChange?: (selection: Selection | null) => void;
+    /** Fired once the map (deck.gl standalone, or the basemap) has finished its async init (spec: Behavior Engine "load" event). */
+    onLoad?: () => void;
+    /**
+     * Continuous drag-pick events (spec: Behavior Engine "drag" event) — kept
+     * separate from `onSelectionChange`/`ctx.selection`, which is scoped to
+     * discrete hover/click picks; a widget watching `selection` shouldn't
+     * re-render on every drag-move.
+     */
+    onDragPick?: (selection: Selection) => void;
+    /**
+     * Every click/hover's map coordinate (spec: "Manual Drawing"), fired
+     * ALONGSIDE onSelectionChange but INCLUDING empty-map events — which
+     * `toSelection` discards (no picked object, index < 0), yet sketch capture
+     * needs (a vertex dropped in blank space). Coordinate is null only when
+     * deck reports none (e.g. off-globe).
+     */
+    onMapPoint?: (coordinate: [number, number] | null, kind: "click" | "hover") => void;
+    /**
+     * Runtime error boundary (spec: "Runtime error boundary") — deck.gl-level
+     * failures (a crashing accessor, an incompatible prop) formatted into the
+     * same structured shape Manifest Validation uses, so the agent sees one
+     * consistent error contract regardless of origin.
+     */
+    onRuntimeError?: (entry: ValidationEntry) => void;
+}
+/** Headless mode config (spec: "Consumer Testing Surface") — an explicit size, since jsdom layout reports 0×0. */
+export interface HeadlessOptions {
+    width: number;
+    height: number;
+}
+export declare class RuntimeCore {
+    private deck?;
+    private basemap?;
+    /**
+     * Which renderer owns the view. Branching happens on the MODE, not on
+     * `this.basemap` — in basemap mode the adapter arrives asynchronously
+     * (the maplibre chunk lazy-loads), and during that window camera/layer
+     * calls must route to the (not-yet-present) adapter, never fall through
+     * to a standalone Deck that doesn't exist.
+     */
+    private mode;
+    /** Layers reconciled while the basemap chunk is still loading — applied on adapter arrival. */
+    private pendingLayers?;
+    /** Retained descriptors — what the per-frame channel re-applies against. */
+    private lastIRs;
+    /** layerId → effect-driven plain-prop patches (the per-frame channel). */
+    private animatedProps;
+    private headless?;
+    private destroyed;
+    private viewState;
+    private callbacks;
+    constructor(parent: HTMLElement, initialView: InitialView, callbacks?: RuntimeCoreCallbacks, basemapAttr?: string, headless?: HeadlessOptions);
+    /**
+     * Rebuilds every deck.gl Layer instance from the current IR and hands the
+     * full array to deck.gl (or the basemap's MapboxOverlay) on every
+     * reconcile — the underlying layer manager's own id-keyed prop diffing
+     * decides what actually needs to change. Accessor props carry
+     * `updateTriggers` fingerprints (Layer Reconciliation) so deck.gl
+     * recomputes an attribute iff the accessor's source actually changed,
+     * rather than never (deck.gl ignores accessor function identity on its
+     * own) or on every pass.
+     */
+    reconcile(irs: LayerIR[]): void;
+    private buildLayers;
+    private applyLayers;
+    /**
+     * The sanctioned per-frame DOM bypass (spec: "Map Stories / per-frame
+     * channel"): merge plain-prop patches into a layer's descriptor and
+     * re-apply immediately from the retained IRs — rebuilding deck layer
+     * instances per frame is the deck-idiomatic rAF pattern. `null` clears a
+     * layer's patches. Headless stores the patches (inspectable via the map's
+     * internal getter) with no renderer to drive.
+     */
+    patchAnimatedProps(layerId: string, props: Record<string, unknown> | null): void;
+    clearAnimatedProps(): void;
+    getAnimatedProps(layerId: string): Record<string, unknown> | undefined;
+    /**
+     * The current resolved viewport (for `ctx.viewport`'s bounds/project) —
+     * always fresh, never cached. Standalone: `Deck#getViewports()` asserts
+     * its internal `viewManager` is set, which only happens after Deck's own
+     * async init — `isInitialized` guards the window between construction
+     * (widgets can register and request a ctx synchronously, before that init
+     * resolves) and the first frame. With a basemap: the MapLibre-backed
+     * adapter, once the basemap's style has loaded.
+     */
+    getViewport(): MapViewport | undefined;
+    /** Renderer init state — feeds the `om-map-ready` signal. Headless has nothing async to wait for. */
+    isReady(): boolean;
+    /**
+     * Synthetic pick injection (spec: "Consumer Testing Surface") — invokes
+     * the SAME onSelectionChange callback deck.gl's real picks arrive through,
+     * so flattening, columnar row materialization, widget notification,
+     * behavior dispatch, and the overlay flush are same-path by construction.
+     * Available in every mode (a browser-level test may use it too).
+     */
+    injectPick(selection: Selection | null): void;
+    getViewState(): Readonly<ViewState>;
+    /**
+     * Sketch capture (spec: "Manual Drawing", D4) — while a draw tool is active,
+     * disable the map's double-click-zoom so double-clicking to close a
+     * line/polygon doesn't also zoom. Honored in both mount paths. Headless is a
+     * no-op (no controller). Deliberately narrow: click-to-place-vertex doesn't
+     * fight drag-pan, so pan stays live.
+     */
+    setDrawCapture(active: boolean): void;
+    /**
+     * Used by the built-in `zoom-controls` widget's emitted zoom-in/zoom-out
+     * intents. Programmatic, so — unlike a user drag/scroll — standalone mode
+     * never goes through deck.gl's own `onViewStateChange` controller
+     * callback; fire `onViewportChange` directly so `viewport`-watching
+     * widgets (scale-bar) still pick up the change. With a basemap, MapLibre's
+     * own `jumpTo` already fires a `move` event (wired to `onViewportChange`
+     * in the constructor), so no manual notification is needed there.
+     */
+    zoomBy(delta: number): void;
+    /**
+     * Recenters (and optionally rezooms) the view — `map.flyTo(coords)`
+     * (spec: "Runtime Core" programmatic API) and the `zoom-to-feature`
+     * action's point form both go through this. Instant, not an animated
+     * fly, in both modes — smooth transitions are a future addition (deck.gl
+     * `transitions` / MapLibre's own animated `flyTo`), not implemented here.
+     */
+    flyTo(center: [number, number], zoom?: number, opts?: CameraOptions): void;
+    /**
+     * Merges a partial view state — the harness's `setView` (and the only
+     * path that reaches pitch/bearing, which `flyTo`/`zoomBy` don't touch).
+     * Standalone/headless update the tracked state directly; with a basemap,
+     * center/zoom delegate to the basemap's camera (which owns the view) and
+     * pitch/bearing are a documented not-yet gap there.
+     */
+    setViewState(partial: Partial<ViewState>, opts?: CameraOptions): void;
+    /**
+     * Recenters and rezooms to fit a `[[minLng,minLat],[maxLng,maxLat]]` box —
+     * the `zoom-to-feature` action's bbox form (GeoJSON polygons/lines).
+     * Standalone falls back to a plain `flyTo` at the box's midpoint if the
+     * viewport isn't initialized yet (mirrors `getViewport()`'s own guard);
+     * with a basemap, MapLibre's own `fitBounds` handles this directly.
+     */
+    flyToBounds(bounds: [[number, number], [number, number]], padding?: number, opts?: CameraOptions): void;
+    destroy(): void;
+}
+export {};

package/dist/selection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Selection (picking) state — spec: "Runtime Context API / Selection".
+ * Converts a deck.gl PickingInfo into the documented, deck.gl-independent
+ * ctx.selection shape (HU2: ctx never leaks deck.gl internals).
+ */
+export interface Selection {
+    layerId: string;
+    object: unknown;
+    /**
+     * The picked row's index in the layer's data. Columnar layers pick with NO
+     * object (deck.gl's non-iterable data path only knows the index) — the
+     * runtime materializes `object` from the columns at this index (om-map's
+     * onSelectionChange), so downstream consumers still always see an object.
+     */
+    index: number;
+    coordinate: [number, number] | null;
+    pixel: [number, number];
+    type: "hover" | "click";
+}
+interface PickingInfoLike {
+    layer?: {
+        id: string;
+    } | null;
+    object?: unknown;
+    index?: number;
+    coordinate?: number[];
+    x: number;
+    y: number;
+}
+export declare function toSelection(info: PickingInfoLike, type: "hover" | "click"): Selection | null;
+export {};

package/dist/stats.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ctx.stats() — spec: "Runtime Context API / Data access". Path-resolved
+ * (via getField, no per-feature copying) aggregation: count/min/max/mean/
+ * stddev/p50/p95/histogram, matching the documented return shape exactly.
+ */
+import type { Shape } from "./ir";
+export interface HistogramBin {
+    x0: number;
+    x1: number;
+    count: number;
+}
+export interface Stats {
+    count: number;
+    min: number;
+    max: number;
+    mean: number;
+    stddev: number;
+    p50: number;
+    p95: number;
+    histogram: HistogramBin[];
+}
+export declare function computeStats(rows: readonly unknown[], field: string, shape: Shape): Stats;
+/**
+ * The columnar fast path (spec: "Columnar / GeoArrow Ingestion"): stats
+ * straight off a column's typed array — no row objects, no field lookups,
+ * no materialization. `values` is consumed (sorted in place after copying
+ * non-finite entries out).
+ */
+export declare function statsFromColumn(column: ArrayLike<unknown>): Stats;

package/dist/table-accessors-DBjWgN0C.js

@@ -0,0 +1,204 @@
+function w(e) {
+  var a;
+  switch (typeof e == "object" && (e == null ? void 0 : e.shape)) {
+    case "array-row-table":
+    case "object-row-table":
+      return Array.isArray(e.data);
+    case "geojson-table":
+      return Array.isArray(e.features);
+    case "columnar-table":
+      return e.data && typeof e.data == "object";
+    case "arrow-table":
+      return ((a = e == null ? void 0 : e.data) == null ? void 0 : a.numRows) !== void 0;
+    default:
+      return !1;
+  }
+}
+function l(e) {
+  switch (e.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return e.data.length;
+    case "geojson-table":
+      return e.features.length;
+    case "arrow-table":
+      return e.data.numRows;
+    case "columnar-table":
+      for (const a of Object.values(e.data))
+        return a.length || 0;
+      return 0;
+    default:
+      throw new Error("table");
+  }
+}
+function g(e) {
+  if (e.schema)
+    return e.schema.fields.length;
+  if (l(e) === 0)
+    throw new Error("empty table");
+  switch (e.shape) {
+    case "array-row-table":
+      return e.data[0].length;
+    case "object-row-table":
+      return Object.keys(e.data[0]).length;
+    case "geojson-table":
+      return Object.keys(e.features[0]).length;
+    case "columnar-table":
+      return Object.keys(e.data).length;
+    case "arrow-table":
+      return e.data.numCols;
+    default:
+      throw new Error("table");
+  }
+}
+function j(e, r, a) {
+  var o;
+  switch (e.shape) {
+    case "array-row-table":
+      const n = m(e, a);
+      return e.data[r][n];
+    case "object-row-table":
+      return e.data[r][a];
+    case "geojson-table":
+      return e.features[r][a];
+    case "columnar-table":
+      return e.data[a][r];
+    case "arrow-table":
+      const c = e.data, u = c.schema.fields.findIndex((s) => s.name === a);
+      return (o = c.getChildAt(u)) == null ? void 0 : o.get(r);
+    default:
+      throw new Error("todo");
+  }
+}
+function y(e, r, a) {
+  var o;
+  switch (e.shape) {
+    case "array-row-table":
+      return e.data[r][a];
+    case "object-row-table":
+      const n = i(e, a);
+      return e.data[r][n];
+    case "geojson-table":
+      const f = i(e, a);
+      return e.features[r][f];
+    case "columnar-table":
+      const c = i(e, a);
+      return e.data[c][r];
+    case "arrow-table":
+      return (o = e.data.getChildAt(a)) == null ? void 0 : o.get(r);
+    default:
+      throw new Error("todo");
+  }
+}
+function m(e, r) {
+  var o;
+  const a = (o = e.schema) == null ? void 0 : o.fields.findIndex((n) => n.name === r);
+  if (a === void 0)
+    throw new Error(r);
+  return a;
+}
+function i(e, r) {
+  var o, n;
+  const a = (n = (o = e.schema) == null ? void 0 : o.fields[r]) == null ? void 0 : n.name;
+  if (!a)
+    throw new Error(`${r}`);
+  return a;
+}
+function T(e, r, a, o) {
+  switch (e.shape) {
+    case "object-row-table":
+      return o ? Object.fromEntries(Object.entries(e.data[r])) : e.data[r];
+    case "array-row-table":
+      if (e.schema) {
+        const s = a || {};
+        for (let t = 0; t < e.schema.fields.length; t++)
+          s[e.schema.fields[t].name] = e.data[r][t];
+        return s;
+      }
+      throw new Error("no schema");
+    case "geojson-table":
+      if (e.schema) {
+        const s = a || {};
+        for (let t = 0; t < e.schema.fields.length; t++)
+          s[e.schema.fields[t].name] = e.features[r][t];
+        return s;
+      }
+      throw new Error("no schema");
+    case "columnar-table":
+      if (e.schema) {
+        const s = a || {};
+        for (let t = 0; t < e.schema.fields.length; t++)
+          s[e.schema.fields[t].name] = e.data[e.schema.fields[t].name][r];
+        return s;
+      } else {
+        const s = a || {};
+        for (const [t, h] of Object.entries(e.data))
+          s[t] = h[r];
+        return s;
+      }
+    case "arrow-table":
+      const n = e.data, f = a || {}, c = n.get(r), u = n.schema;
+      for (let s = 0; s < u.fields.length; s++)
+        f[u.fields[s].name] = c == null ? void 0 : c[u.fields[s].name];
+      return f;
+    default:
+      throw new Error("shape");
+  }
+}
+function d(e, r, a, o) {
+  switch (e.shape) {
+    case "array-row-table":
+      return o ? Array.from(e.data[r]) : e.data[r];
+    case "object-row-table":
+      if (e.schema) {
+        const s = a || [];
+        for (let t = 0; t < e.schema.fields.length; t++)
+          s[t] = e.data[r][e.schema.fields[t].name];
+        return s;
+      }
+      return Object.values(e.data[r]);
+    case "geojson-table":
+      if (e.schema) {
+        const s = a || [];
+        for (let t = 0; t < e.schema.fields.length; t++)
+          s[t] = e.features[r][e.schema.fields[t].name];
+        return s;
+      }
+      return Object.values(e.features[r]);
+    case "columnar-table":
+      if (e.schema) {
+        const s = a || [];
+        for (let t = 0; t < e.schema.fields.length; t++)
+          s[t] = e.data[e.schema.fields[t].name][r];
+        return s;
+      } else {
+        const s = a || [];
+        let t = 0;
+        for (const h of Object.values(e.data))
+          s[t] = h[r], t++;
+        return s;
+      }
+    case "arrow-table":
+      const n = e.data, f = a || [], c = n.get(r), u = n.schema;
+      for (let s = 0; s < u.fields.length; s++)
+        f[s] = c == null ? void 0 : c[u.fields[s].name];
+      return f;
+    default:
+      throw new Error("shape");
+  }
+}
+function* p(e, r = []) {
+  const a = l(e);
+  for (let o = 0; o < a; o++)
+    yield d(e, o, r);
+}
+export {
+  g as a,
+  y as b,
+  j as c,
+  d,
+  T as e,
+  l as g,
+  w as i,
+  p as m
+};

package/dist/template-interpolation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Interpolates `template` against `data` (a plain object — `ctx.selection.object`,
+ * already shape-flattened per Feature Field Resolution). Missing fields
+ * interpolate to an empty string, same as a normal template-literal `undefined`.
+ */
+export declare function interpolateTemplate(template: string, data: Record<string, unknown>): string;

package/dist/testing.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Consumer test harness (spec: "Consumer Testing Surface — Headless Harness
+ * & Readiness"). Mounts a manifest headlessly — no Deck, no WebGL, no canvas
+ * — in a consumer's own jsdom/happy-dom test environment, with a real
+ * WebMercatorViewport doing the projection math and synthetic picks feeding
+ * the exact selection path deck.gl's real picks take.
+ *
+ * Assertions are deliberately plain DOM: widgets and overlays use OPEN
+ * shadow roots, so `el.shadowRoot.textContent` works with standard tooling —
+ * there is no bespoke assertion API to learn.
+ */
+import type { OmMapElement } from "./elements/om-map";
+import type { LayerIR } from "./ir";
+export interface MountOptions {
+    /** Headless viewport size — jsdom layout reports 0×0, so size is declared, not measured. Default 800×600. */
+    width?: number;
+    height?: number;
+}
+export interface PickOptions {
+    /** The `<om-layer id>` to pick from. */
+    layer: string;
+    /** Feature id (matched the same way the highlight-feature action matches ids) — or give an explicit `index`. */
+    featureId?: string;
+    index?: number;
+    /**
+     * Pick type — drives which `<om-behavior on="...">` fires. Default
+     * "click". "drag" takes the drag-dispatch path (fires `on="drag"`
+     * behaviors, never touches ctx.selection — mirroring live semantics).
+     */
+    type?: "hover" | "click" | "drag";
+}
+export interface ViewOptions {
+    center?: [number, number];
+    zoom?: number;
+    pitch?: number;
+    bearing?: number;
+}
+export interface TestHarness {
+    /** The upgraded <om-map> element — query it (and shadow roots) with plain DOM. */
+    map: OmMapElement;
+    /** The wrapper div the manifest was mounted into. */
+    container: HTMLElement;
+    /** The live layer IRs — the same descriptors snapshotIR serializes. */
+    layers(): readonly LayerIR[];
+    /**
+     * Synthetic pick: resolves the feature, derives its coordinate through the
+     * layer's own compiled getPosition (columnar layers pick object-less with
+     * an index, exactly as deck.gl does), and routes it through the same
+     * selection path a real pick takes. Settles before resolving.
+     */
+    pick(opts: PickOptions): Promise<void>;
+    /** Ends the current selection (a hover-off) — the path that auto-hides tooltips. */
+    clearSelection(): Promise<void>;
+    /**
+     * Sets the camera directly (center/zoom/pitch/bearing) — everything
+     * viewport-derived reacts for real: `viewport`-watching widgets,
+     * viewport-scoped stats, overlay projection/culling. This drives the
+     * camera the way `flyTo` does; gesture→camera translation (deck.gl's
+     * controller) is deliberately not simulated.
+     */
+    setView(view: ViewOptions): Promise<void>;
+    /** Dispatches an action through the normal payload contract (same as ctx.emit / data-emit). Settles before resolving. */
+    emit(action: string, payload?: Record<string, unknown>): Promise<void>;
+    /** Settles pending work: microtask-batched reconciles and the rAF overlay flush. */
+    flush(): Promise<void>;
+    /**
+     * Deterministic story control (spec: "Map Stories"): `advance(ms)` drives
+     * the story's clock manually — rAF never runs for a harness-driven story,
+     * so "after 5s the overlay is visible" is exact, not timing-dependent.
+     */
+    story(id?: string): StoryHandle;
+    unmount(): void;
+}
+export interface StoryHandle {
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(ms: number): Promise<void>;
+    /** Advance the manual clock by ms (starts playback if idle). */
+    advance(ms: number): Promise<void>;
+    readonly state: string;
+    readonly currentTime: number;
+    readonly duration: number;
+}
+/**
+ * Mounts a manifest for behavioral testing and resolves once the map is
+ * ready (renderer up — immediate when headless — and no declared data URL
+ * still in flight). Forces `headless` + an explicit size onto the
+ * `<om-map>` before the element upgrades.
+ */
+export declare function mountForTest(html: string, opts?: MountOptions): Promise<TestHarness>;

package/dist/timeline.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Story timeline math (spec: "Map Stories / Clock, seek, and the scrub
+ * model") — a pure module: step timings in, absolute intervals out. No DOM,
+ * no clock, fully unit-testable.
+ *
+ * Sequencing semantics:
+ * - Sequential (default): a step starts when EVERYTHING before it has
+ *   finished (max end of all prior steps) — so a short parallel step never
+ *   pulls the next step into the middle of a longer one.
+ * - `parallel`: joins the PREVIOUS step's start (Animaps' "scenes" without
+ *   a grouping element).
+ * - `delay` staggers either form's start.
+ */
+export interface StepTiming {
+    /** How long the step's animation runs (ms). 0 = instantaneous state change. */
+    duration: number;
+    /** Stagger before the step starts (ms), applied after sequential/parallel placement. */
+    delay: number;
+    /** Start with the previous step instead of after everything so far. */
+    parallel: boolean;
+}
+export interface StepInterval {
+    start: number;
+    end: number;
+}
+export interface Timeline {
+    intervals: StepInterval[];
+    /** Total running time — max end across all steps. */
+    total: number;
+}
+export declare function computeTimeline(steps: readonly StepTiming[]): Timeline;
+/**
+ * `"800"` / `"800ms"` / `"2s"` → milliseconds. The shared duration grammar
+ * for step timings and camera payloads (returns `fallback` on anything
+ * unparseable — callers decide whether to warn).
+ */
+export declare function parseDurationMs(raw: string | number | undefined | null, fallback?: number): number;

package/dist/validation.d.ts

@@ -0,0 +1,22 @@
+export interface ValidationEntry {
+    severity: "error" | "warning";
+    /** e.g. "om-layer#points" — tag name, plus #id when the element has one. */
+    element: string;
+    attribute?: string;
+    message: string;
+    /** An instruction, not just a diagnosis — what makes this useful to an agent. */
+    fix: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationEntry[];
+    warnings: ValidationEntry[];
+}
+/**
+ * Validates a manifest already parsed into a DOM tree — a live `<om-map>`
+ * (mounted or not) or a detached `Document`/`DocumentFragment` (what
+ * `validateManifestString` builds via `DOMParser`).
+ */
+export declare function validateManifest(root: ParentNode): ValidationResult;
+/** `OmMap.validate(htmlString)` — the pre-flight agent feedback loop. */
+export declare function validateManifestString(htmlString: string): ValidationResult;

package/dist/vega-loader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Vega-Lite lazy loading (spec: "Available globals in widget script blocks").
+ * Vega + Vega-Lite + vega-embed (~500KB) are not bundled — injected from a
+ * CDN on first actual use and cached thereafter. `vegaEmbedProxy` is the
+ * stable function reference handed to every widget script's closure; only
+ * *calling* it triggers the load, so passing it around before first use is free.
+ */
+declare global {
+    interface Window {
+        vegaEmbed?: (el: Element, spec: unknown, opts?: unknown) => Promise<{
+            view: {
+                finalize(): void;
+            };
+        }>;
+    }
+}
+export declare function ensureVegaLoaded(): Promise<void>;
+export declare function vegaEmbedProxy(el: Element, spec: unknown, opts?: unknown): Promise<{
+    view: {
+        finalize(): void;
+    };
+}>;

package/dist/viewport-filter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ctx.dataInViewport() — spec: "Viewport Filtering & Statistics" (#6),
+ * scoped pragmatically for Phase 4: a per-feature bbox test against
+ * `viewport.getBounds()`, using the layer's own compiled `getPosition`
+ * accessor for point layers or each GeoJSON feature's own geometry
+ * coordinates — no spatial index (kdbush/flatbush) yet, no per-layer
+ * `featureBounds` registry descriptor. Correct for reasonable dataset
+ * sizes; the optimization is deferred, not the correctness.
+ */
+import type { MapViewport } from "./basemap";
+import type { Shape, ColumnarData } from "./ir";
+export declare function filterInViewport(rows: readonly unknown[], shape: Shape, viewport: MapViewport | undefined, getPosition?: (d: unknown) => number[] | undefined): unknown[];
+/**
+ * The columnar counterpart (spec: "Columnar / GeoArrow Ingestion"). A
+ * columnar layer's compiled `getPosition` reads `info.data.columns[...]
+ * [info.index]`, never a row object — so filtering must run over INDICES.
+ * The (memoized) row view is taken here, not passed in, so its index
+ * alignment with `data` is true by construction; `rowFilter` (the
+ * declarative filter, applied to the materialized flat row) rides the same
+ * loop so a pre-pass can never break that alignment either.
+ */
+export declare function filterColumnarInViewport(data: ColumnarData, viewport: MapViewport | undefined, getPosition: ((d: unknown, info: {
+    index: number;
+    data: ColumnarData;
+}) => unknown) | undefined, rowFilter?: (row: unknown) => boolean): unknown[];

package/dist/widget-registry.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Widget registry (spec: "Widget System — three tiers, one registry").
+ * Built-ins are just pre-registered entries here — not special-cased —
+ * symmetric with registerLayer/registerAction/registerSource.
+ */
+import type { RuntimeContext } from "./ctx";
+/** What a widget implementation gets instead of the raw OmWidgetElement (keeps this module decoupled from the elements/ layer). */
+export interface WidgetHost {
+    root: ShadowRoot;
+    $(sel: string): Element | null;
+    $$(sel: string): NodeListOf<Element>;
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+    /** Per-instance mutable stash for state that must survive across renders (e.g. a Vega view to `.finalize()` before re-embedding). */
+    state: Record<string, unknown>;
+}
+export interface WidgetImpl {
+    /** Default watch tokens when the element has no `watch` attribute. */
+    watch?: string[];
+    render(ctx: RuntimeContext, host: WidgetHost): void | Promise<void>;
+}
+export declare function registerWidget(name: string, impl: WidgetImpl): void;
+export declare function getWidget(name: string): WidgetImpl | undefined;

package/dist/widget-script.d.ts

@@ -0,0 +1 @@
+export declare function runWidgetScript(scriptText: string, thisArg: object): void;

package/dist/widgets/built-in.d.ts

@@ -0,0 +1 @@
+export {};