@oceanmetrics/engine 0.0.0-stage → 0.1.1

package/dist/dataset.d.ts

@@ -0,0 +1,72 @@
+import type { Format } from './erddap.js';
+export interface CubeVariable {
+    name: string;
+    unit: string | null;
+    description: string;
+    categorical: boolean;
+    /** class value -> label, for categorical variables (from `erddap-places:classes`). */
+    classes?: Record<string, string>;
+}
+/** the long-format columns of a tabledap table: `measurement_type` / `measurement_value`. */
+export interface LongFormat {
+    typeColumn: string;
+    valueColumn: string;
+}
+export interface Dataset {
+    id: string;
+    title: string;
+    baseUrl: string;
+    datasetId: string;
+    protocol: 'griddap' | 'tabledap';
+    /** set when the table keeps its variables in a column (tabledap, long format) */
+    longFormat?: LongFormat;
+    version?: string;
+    cors: boolean;
+    formats: string[];
+    lonRange: [number, number];
+    latDescending: boolean;
+    variables: CubeVariable[];
+    timeStep?: string;
+    timeExtent?: [string | null, string | null];
+    /** `erddap-places:depth`: the depth level (m) to slice on a grid with a depth axis (the surface) */
+    depth?: number;
+    /** `erddap-places:status`: 'pending' when the server does not serve it yet (list it, greyed out) */
+    status?: string;
+    format: Format;
+    collection: any;
+}
+/**
+ * The SQL expression for a variable's value, converting Kelvin to °C.
+ *
+ * For a long-format table the variable is not a column: the rows were already filtered to
+ * `measurement_type = '<name>'` by the request, so the expression is the value column.
+ */
+export declare function valueExpr(v: CubeVariable, alias?: string, long?: LongFormat): string;
+/** the axis label for a variable, after any unit conversion. */
+export declare function valueLabel(v: CubeVariable): string;
+/** the `erddap-places:categorical` flag as published in the catalog (boolean, or the string). */
+export declare function isCategorical(v: any): boolean;
+/** `erddap-places:long_format` -> the two column names, or undefined. */
+export declare function toLongFormat(f: any): LongFormat | undefined;
+/**
+ * The SQL template a run is summarised with: point (tabledap) data rolls up by month, a flagged
+ * categorical grid gets per-class fractions, everything else is the daily grid statistics.
+ */
+export declare function statsTemplate(v: Pick<CubeVariable, 'categorical'> | null | undefined, protocol?: 'griddap' | 'tabledap'): 'stats_daily' | 'stats_categorical' | 'stats_tabledap';
+/** one STAC Collection -> the fields the app uses. */
+export declare function toDataset(c: any): Dataset;
+/**
+ * The dataset a link names. The app writes the STAC collection id (`erddap/dhw_5km`), but links written elsewhere name
+ * ERDDAP's own dataset id (`dhw_5km`, `IMERG_monthly_global_precip`), and one collection id differs from its dataset id
+ * in case (`erddap/imerg_monthly_global_precip`). Tried in turn, each ignoring case: the collection id, the collection
+ * id with `erddap/` before it, ERDDAP's dataset id. A pending dataset is never picked; null when nothing matches.
+ */
+export declare function resolveDataset<D extends Pick<Dataset, 'id' | 'datasetId' | 'status'>>(datasets: D[], wanted: string): D | null;
+/** ERDDAP wants a lon in the dataset's own range: [-180, 180] or [0, 360]. */
+export declare function toDatasetLon(lon: number, range: [number, number]): number;
+/**
+ * A lobe's longitude span in the dataset's own frame, [min, max], clamped to `erddap:lon_range`:
+ * a lobe that runs to 180 on a grid ending at 179.75 (CMEMS 0.25°) would otherwise ask for a
+ * longitude past the axis maximum, which ERDDAP refuses (404).
+ */
+export declare function lobeLonSpan(bbox: [number, number, number, number] | number[], range: [number, number]): [number, number];

package/dist/dataset.js

@@ -0,0 +1,115 @@
+import { pickFormat } from './erddap.js';
+const KELVIN = /^(k|kelvin|degree_?k(elvin)?)$/i;
+/**
+ * The SQL expression for a variable's value, converting Kelvin to °C.
+ *
+ * For a long-format table the variable is not a column: the rows were already filtered to
+ * `measurement_type = '<name>'` by the request, so the expression is the value column.
+ */
+export function valueExpr(v, alias = 's', long) {
+    const col = long ? `${alias}."${long.valueColumn}"` : `${alias}."${v.name}"`;
+    return KELVIN.test(v.unit ?? '') ? `(${col} - 273.15)` : col;
+}
+/** the axis label for a variable, after any unit conversion. */
+export function valueLabel(v) {
+    if (KELVIN.test(v.unit ?? ''))
+        return '°C';
+    const u = (v.unit ?? '').trim();
+    if (!u || u === '1' || u.toLowerCase() === 'none')
+        return v.name;
+    if (/^(celsius|degree_?c(elsius)?)$/i.test(u))
+        return '°C';
+    return u;
+}
+/** the `erddap-places:categorical` flag as published in the catalog (boolean, or the string). */
+export function isCategorical(v) {
+    const f = v?.['erddap-places:categorical'];
+    return f === true || f === 'true';
+}
+/** `erddap-places:long_format` -> the two column names, or undefined. */
+export function toLongFormat(f) {
+    const t = f?.type_column, v = f?.value_column;
+    return t && v ? { typeColumn: String(t), valueColumn: String(v) } : undefined;
+}
+/**
+ * The SQL template a run is summarised with: point (tabledap) data rolls up by month, a flagged
+ * categorical grid gets per-class fractions, everything else is the daily grid statistics.
+ */
+export function statsTemplate(v, protocol = 'griddap') {
+    if (protocol === 'tabledap')
+        return 'stats_tabledap';
+    return v?.categorical === true ? 'stats_categorical' : 'stats_daily';
+}
+function toVariable(name, v) {
+    return {
+        name,
+        unit: v?.unit ?? null,
+        description: v?.description ?? name,
+        categorical: isCategorical(v),
+        classes: v?.['erddap-places:classes'] ?? undefined,
+    };
+}
+/** one STAC Collection -> the fields the app uses. */
+export function toDataset(c) {
+    const vars = Object.entries(c['cube:variables'] ?? {})
+        .filter(([, v]) => (v?.type ?? 'data') === 'data')
+        .map(([k, v]) => toVariable(k, v));
+    const time = c['cube:dimensions']?.time ?? {};
+    return {
+        id: c.id,
+        title: c.title ?? c.id,
+        baseUrl: c['erddap:base_url'],
+        datasetId: c['erddap:dataset_id'],
+        protocol: c['erddap:protocol'] === 'tabledap' ? 'tabledap' : 'griddap',
+        longFormat: toLongFormat(c['erddap-places:long_format']),
+        version: c['erddap:version'],
+        cors: c['erddap:cors'] !== false,
+        formats: c['erddap:formats'] ?? [],
+        lonRange: c['erddap:lon_range'] ?? [-180, 180],
+        latDescending: c['erddap:lat_descending'] === true,
+        variables: vars,
+        timeStep: time.step,
+        timeExtent: time.extent,
+        depth: Number.isFinite(Number(c['erddap-places:depth'])) && c['erddap-places:depth'] != null
+            ? Number(c['erddap-places:depth']) : undefined,
+        status: c['erddap-places:status'] ?? undefined,
+        format: pickFormat({ erddap: { cors: c['erddap:cors'], formats: c['erddap:formats'] } }),
+        collection: c,
+    };
+}
+/**
+ * The dataset a link names. The app writes the STAC collection id (`erddap/dhw_5km`), but links written elsewhere name
+ * ERDDAP's own dataset id (`dhw_5km`, `IMERG_monthly_global_precip`), and one collection id differs from its dataset id
+ * in case (`erddap/imerg_monthly_global_precip`). Tried in turn, each ignoring case: the collection id, the collection
+ * id with `erddap/` before it, ERDDAP's dataset id. A pending dataset is never picked; null when nothing matches.
+ */
+export function resolveDataset(datasets, wanted) {
+    const w = String(wanted ?? '').trim().toLowerCase();
+    if (!w)
+        return null;
+    const live = datasets.filter((d) => d.status !== 'pending');
+    const eq = (a, b) => (a ?? '').toLowerCase() === b;
+    return live.find((d) => d.id === wanted)
+        ?? live.find((d) => eq(d.id, w))
+        ?? live.find((d) => eq(d.id, `erddap/${w}`))
+        ?? live.find((d) => eq(d.datasetId, w.replace(/^erddap\//, '')))
+        ?? null;
+}
+/** ERDDAP wants a lon in the dataset's own range: [-180, 180] or [0, 360]. */
+export function toDatasetLon(lon, range) {
+    if (range[1] > 180 && lon < 0)
+        return lon + 360;
+    if (range[0] < 0 && lon > 180)
+        return lon - 360;
+    return lon;
+}
+/**
+ * A lobe's longitude span in the dataset's own frame, [min, max], clamped to `erddap:lon_range`:
+ * a lobe that runs to 180 on a grid ending at 179.75 (CMEMS 0.25°) would otherwise ask for a
+ * longitude past the axis maximum, which ERDDAP refuses (404).
+ */
+export function lobeLonSpan(bbox, range) {
+    const lo = toDatasetLon(bbox[0], range), hi = toDatasetLon(bbox[2], range);
+    const clamp = (x) => Math.min(Math.max(x, range[0]), range[1]);
+    return [clamp(Math.min(lo, hi)), clamp(Math.max(lo, hi))];
+}

package/dist/engine.d.ts

@@ -0,0 +1,72 @@
+import type * as duckdbWasm from '@duckdb/duckdb-wasm';
+import type { MaskCell } from './mask.js';
+import type { Params } from './sql.js';
+/** the slice of a DuckDB-WASM database the engine uses: `AsyncDuckDB` in a browser, the node-blocking bindings in tests */
+export interface DuckDbLike {
+    registerFileBuffer(name: string, buf: Uint8Array): unknown;
+    copyFileToBuffer(name: string): Uint8Array | Promise<Uint8Array>;
+    dropFile(name: string): unknown;
+}
+/** the slice of a connection the engine uses: `AsyncDuckDBConnection`, or the blocking `DuckDBConnection` */
+export interface DuckConnLike {
+    /** an Arrow table (or a promise of one): iterable rows, `schema.fields`, `numRows` */
+    query(sql: string): any;
+    insertArrowFromIPCStream(buf: Uint8Array, opts: {
+        name: string;
+        create?: boolean;
+    }): unknown;
+}
+export interface Duck {
+    db: DuckDbLike;
+    conn: DuckConnLike;
+}
+/**
+ * The browser boot erddap-places' engine did itself: pick the bundle (eh or mvp), start its Web Worker, instantiate,
+ * connect. `duckdb` is the app's `import * as duckdb from '@duckdb/duckdb-wasm'`, `bundles` the module and worker
+ * URLs it serves (see the README, "Worker setup").
+ */
+export declare function connectBrowser(duckdb: typeof duckdbWasm, bundles: duckdbWasm.DuckDBBundles, logger?: duckdbWasm.Logger): Promise<Duck>;
+export type Row = Record<string, any>;
+/**
+ * an Arrow result as plain rows: BIGINT as a number, and DECIMAL scaled. DuckDB-WASM hands a DECIMAL back as its
+ * unscaled integer (`1.0 AS weight` in points_tabledap.sql arrived as 10, a `VALUES (20.05, ...)` latitude as 2005);
+ * erddap-places' toRows passed it through, which no ERDDAP slab (float axes, float values) ever exercised.
+ */
+export declare function toRows(t: any): Row[];
+export interface EngineEvent {
+    name: string;
+    ms: number;
+    note?: string;
+}
+export declare class Engine {
+    db: DuckDbLike;
+    conn: DuckConnLike;
+    ready: Promise<void>;
+    marks: EngineEvent[];
+    lastSql: string;
+    private q;
+    /** `connect` runs at once (construct the engine when the app first needs it) */
+    constructor(connect: () => Promise<Duck> | Duck);
+    private mark;
+    private init;
+    /** register an already-fetched slab (parquet bytes) under a virtual file name. */
+    registerBuffer(name: string, buf: Uint8Array): Promise<any>;
+    /** forget a registered file (a slab whose statistics are done). */
+    dropFile(name: string): Promise<any>;
+    /** the gridMask cells as a DuckDB table (via Arrow IPC, so no giant VALUES list). */
+    insertMask(cells: MaskCell[], table?: string): Promise<any>;
+    /** rows from a non-Parquet slab (.csvp / .jsonp) as a table, so the same SQL works on them. */
+    insertRows(rows: Record<string, unknown>[], table: string): Promise<any>;
+    exec(sql: string, label?: string): Promise<Row[]>;
+    /**
+     * The result table as Parquet bytes, written by DuckDB itself.
+     *
+     * The rows go back into a temporary table (Arrow IPC, as the mask does), `COPY … TO` writes a
+     * Parquet file into the WASM filesystem and `copyFileToBuffer` hands it back. Going through the
+     * rows rather than re-running the statistics keeps the download identical to what is on screen,
+     * whatever has happened to the registered slab since.
+     */
+    toParquet(rows: Record<string, unknown>[], table?: string, file?: string): Promise<Uint8Array>;
+    /** render a `sql/<name>.sql` template with {{params}} and run it. */
+    runTemplate(name: string, params: Params): Promise<Row[]>;
+}

package/dist/engine.js

@@ -0,0 +1,154 @@
+// DuckDB-WASM as the statistics engine: the slab goes in as a registered Parquet buffer, the mask as an Arrow table,
+// and every statistic is a sql/ template rendered with {{named}} params. moved from erddap-places
+// `app/src/lib/engine.ts`; the methods are unchanged, but the package never boots DuckDB itself: the app owns the
+// bundles and the Web Worker (Vite `?url` imports, a CDN, or the node-blocking bundle in tests) and hands the Engine a
+// `connect()` that resolves to `{ db, conn }`. `connectBrowser(duckdb, bundles)` is that boot for a browser app, with the
+// duckdb-wasm module passed in (a peer dependency, never imported at run time here).
+import { DataType, tableFromArrays, tableToIPC } from 'apache-arrow';
+import { render } from './sql.js';
+/**
+ * The browser boot erddap-places' engine did itself: pick the bundle (eh or mvp), start its Web Worker, instantiate,
+ * connect. `duckdb` is the app's `import * as duckdb from '@duckdb/duckdb-wasm'`, `bundles` the module and worker
+ * URLs it serves (see the README, "Worker setup").
+ */
+export async function connectBrowser(duckdb, bundles, logger = new duckdb.VoidLogger()) {
+    const bundle = await duckdb.selectBundle(bundles);
+    const worker = new Worker(bundle.mainWorker);
+    const db = new duckdb.AsyncDuckDB(logger, worker);
+    await db.instantiate(bundle.mainModule, bundle.pthreadWorker);
+    return { db, conn: await db.connect() };
+}
+/**
+ * an Arrow result as plain rows: BIGINT as a number, and DECIMAL scaled. DuckDB-WASM hands a DECIMAL back as its
+ * unscaled integer (`1.0 AS weight` in points_tabledap.sql arrived as 10, a `VALUES (20.05, ...)` latitude as 2005);
+ * erddap-places' toRows passed it through, which no ERDDAP slab (float axes, float values) ever exercised.
+ */
+export function toRows(t) {
+    const cols = t.schema.fields.map((f) => f.name);
+    const scale = t.schema.fields.map((f) => (DataType.isDecimal(f.type) ? 10 ** f.type.scale : 0));
+    const out = [];
+    for (const r of t) {
+        const o = {};
+        cols.forEach((c, i) => {
+            const v = r[c];
+            o[c] = typeof v === 'bigint' ? Number(v) : scale[i] && v !== null && v !== undefined ? Number(v) / scale[i] : v;
+        });
+        out.push(o);
+    }
+    return out;
+}
+const now = () => (globalThis.performance ?? Date).now();
+export class Engine {
+    db;
+    conn;
+    ready;
+    marks = [];
+    lastSql = '';
+    q = Promise.resolve(); // one connection: serialize everything
+    /** `connect` runs at once (construct the engine when the app first needs it) */
+    constructor(connect) { this.ready = this.init(connect); }
+    mark(name, ms, note) { this.marks.push({ name, ms: Math.round(ms), note }); }
+    async init(connect) {
+        const t = now();
+        const { db, conn } = await connect();
+        this.db = db;
+        this.conn = conn;
+        this.mark('connect', now() - t);
+    }
+    /** register an already-fetched slab (parquet bytes) under a virtual file name. */
+    async registerBuffer(name, buf) {
+        const run = async () => {
+            await this.ready;
+            const t = now();
+            await this.db.registerFileBuffer(name, buf);
+            this.mark(`register:${name}`, now() - t, `${(buf.byteLength / 1e3).toFixed(0)} kB`);
+        };
+        this.q = this.q.then(run, run);
+        return this.q;
+    }
+    /** forget a registered file (a slab whose statistics are done). */
+    async dropFile(name) {
+        const run = async () => {
+            await this.ready;
+            await this.db.dropFile(name);
+        };
+        this.q = this.q.then(run, run);
+        return this.q;
+    }
+    /** the gridMask cells as a DuckDB table (via Arrow IPC, so no giant VALUES list). */
+    async insertMask(cells, table = 'mask') {
+        const run = async () => {
+            await this.ready;
+            const t = now();
+            const arrow = tableFromArrays({
+                latitude: Float64Array.from(cells.map((c) => c.lat)),
+                longitude: Float64Array.from(cells.map((c) => c.lon)),
+                weight: Float64Array.from(cells.map((c) => c.weight)),
+            });
+            await this.conn.query(`DROP TABLE IF EXISTS ${table}`);
+            await this.conn.insertArrowFromIPCStream(tableToIPC(arrow, 'stream'), { name: table, create: true });
+            this.mark(`mask:${table}`, now() - t, `${cells.length} cells`);
+        };
+        this.q = this.q.then(run, run);
+        return this.q;
+    }
+    /** rows from a non-Parquet slab (.csvp / .jsonp) as a table, so the same SQL works on them. */
+    async insertRows(rows, table) {
+        const run = async () => {
+            await this.ready;
+            const t = now();
+            const cols = Object.keys(rows[0] ?? {});
+            const arrays = {};
+            for (const c of cols) {
+                const vals = rows.map((r) => r[c]);
+                arrays[c] = vals.every((v) => typeof v === 'number' || v === null)
+                    ? Float64Array.from(vals.map((v) => (v === null ? NaN : v)))
+                    : vals.map((v) => (v === null || v === undefined ? null : String(v)));
+            }
+            await this.conn.query(`DROP TABLE IF EXISTS ${table}`);
+            await this.conn.insertArrowFromIPCStream(tableToIPC(tableFromArrays(arrays), 'stream'), { name: table, create: true });
+            this.mark(`rows:${table}`, now() - t, `${rows.length} rows`);
+        };
+        this.q = this.q.then(run, run);
+        return this.q;
+    }
+    exec(sql, label = 'exec') {
+        const run = async () => {
+            await this.ready;
+            const t = now();
+            this.lastSql = sql;
+            const res = await this.conn.query(sql);
+            this.mark(`query:${label}`, now() - t, `${res.numRows} rows`);
+            return toRows(res);
+        };
+        this.q = this.q.then(run, run);
+        return this.q;
+    }
+    /**
+     * The result table as Parquet bytes, written by DuckDB itself.
+     *
+     * The rows go back into a temporary table (Arrow IPC, as the mask does), `COPY … TO` writes a
+     * Parquet file into the WASM filesystem and `copyFileToBuffer` hands it back. Going through the
+     * rows rather than re-running the statistics keeps the download identical to what is on screen,
+     * whatever has happened to the registered slab since.
+     */
+    async toParquet(rows, table = '_export', file = 'export.parquet') {
+        if (!rows.length)
+            throw new Error('nothing to export');
+        await this.insertRows(rows, table);
+        const run = async () => {
+            await this.ready;
+            const t = now();
+            await this.conn.query(`COPY (SELECT * FROM ${table}) TO '${file}' (FORMAT PARQUET)`);
+            const buf = await this.db.copyFileToBuffer(file);
+            await Promise.resolve(this.db.dropFile(file)).catch(() => { });
+            await this.conn.query(`DROP TABLE IF EXISTS ${table}`);
+            this.mark(`parquet:${file}`, now() - t, `${rows.length} rows, ${(buf.byteLength / 1e3).toFixed(0)} kB`);
+            return buf;
+        };
+        this.q = this.q.then(run, run);
+        return this.q;
+    }
+    /** render a `sql/<name>.sql` template with {{params}} and run it. */
+    runTemplate(name, params) { return this.exec(render(name, params), name); }
+}

package/dist/erddap.d.ts

@@ -0,0 +1,117 @@
+import { type RetryOpts } from './fetchRetry.js';
+export type Format = 'parquet' | 'parquetWMeta' | 'csvp' | 'jsonp';
+/** the two Parquet rungs are handled identically once the bytes are in hand. */
+export declare const isParquet: (f: Format) => f is "parquet" | "parquetWMeta";
+export interface ErddapMeta {
+    version?: string;
+    cors?: boolean;
+    formats?: string[];
+}
+export interface Collection {
+    erddap: ErddapMeta;
+}
+export interface GriddapSpec {
+    base: string;
+    datasetId: string;
+    variable: string;
+    time: [string, string];
+    lat: [number, number];
+    lon: [number, number];
+    latDescending?: boolean;
+    /** a depth axis between time and latitude (CMEMS): the single level to slice, e.g. 0.494 (surface) */
+    depth?: number;
+    format?: Format;
+    callback?: string;
+}
+/** one axis constraint, `[(lo):1:(hi)]` with the brackets encoded. */
+export declare function constraint(lo: string | number, hi: string | number, stride?: number): string;
+/** an ISO instant at 12:00Z for a Date or a yyyy-mm-dd string (ERDDAP daily grids sit at noon). */
+export declare function noonZ(d: Date | string): string;
+/** the griddap request URL for one lobe. */
+export declare function griddapUrl(s: GriddapSpec): string;
+/**
+ * the griddap URL for ONE time step (`[(t):1:(t)]`), for the map when the statistics come from the
+ * precomputed file: the same axis order, longitude range and depth as griddapUrl(), but a single step
+ * (`at` is the ISO instant of that step, e.g. the dataset's last time).
+ */
+export declare function griddapSliceUrl(s: Omit<GriddapSpec, 'time'> & {
+    at: string;
+}): string;
+/** one URL per polygon lobe (bbox = [lonMin, latMin, lonMax, latMax]). */
+export declare function griddapUrls(s: Omit<GriddapSpec, 'lat' | 'lon'>, bboxes: Array<[number, number, number, number]>): string[];
+export type TableOp = '>=' | '<=' | '>' | '<' | '=' | '!=' | '=~';
+export interface TableConstraint {
+    column: string;
+    op: TableOp;
+    value: string | number;
+}
+export interface TabledapSpec {
+    base: string;
+    datasetId: string;
+    columns: string[];
+    constraints?: TableConstraint[];
+    format?: Format;
+    callback?: string;
+    /** extra server-side functions, e.g. `distinct()` or `orderByMax("time")`, appended literally. */
+    functions?: string[];
+}
+/** one tabledap constraint, `column%3E=value`. */
+export declare function tableConstraint(c: TableConstraint): string;
+/** the tabledap request URL: the encoded column list, then one `&constraint` each. */
+export declare function tabledapUrl(s: TabledapSpec): string;
+/**
+ * The constraints for one place lobe and one time window: a bbox and a half-open-ish time range,
+ * plus the long-format row filter when the dataset keeps its variables in a `measurement_type`
+ * column (`erddap-places:long_format` in the STAC Collection).
+ */
+export declare function tabledapPlaceConstraints(o: {
+    bbox: [number, number, number, number];
+    from: string;
+    to: string;
+    typeColumn?: string;
+    typeValue?: string;
+}): TableConstraint[];
+/**
+ * per-attempt timeout of an axis request. small, but a busy server is slow whatever the size: PacIOOS answered
+ * `dhw_5km` latitude requests in 13–19 s on 2026-10-20, past the old 15 s, so a live run failed while the server
+ * was up ("did not answer (no response within 15 s, 2 tries)").
+ */
+export declare const AXIS_TIMEOUT_MS = 45000;
+/** per-attempt timeout of the map's one-step slice: as small, and as slow on a busy server (PacIOOS took 27–31 s for 45 days of one pixel) */
+export declare const SLICE_TIMEOUT_MS = 45000;
+/**
+ * `dataset.json?latitude[(min):1:(max)]` -> the axis values, in the server's own order. `AXIS_TIMEOUT_MS` per
+ * attempt and one retry by default (`retry` overrides them; the precompute waits longer).
+ */
+export declare function fetchAxis(base: string, datasetId: string, axis: string, min: number, max: number, descending?: boolean, signal?: AbortSignal, retry?: Omit<RetryOpts, 'signal'>): Promise<number[]>;
+/**
+ * Best format this server can serve us: Parquet -> CSV (`.csvp`) -> JSONP.
+ * CORS off means only JSONP (a `<script>` tag is not subject to CORS).
+ */
+export declare function pickFormat(collection: Collection): Format;
+export interface Slab {
+    url: string;
+    format: Format;
+    ms: number;
+    bytes?: number;
+    buffer?: Uint8Array;
+    rows?: Record<string, unknown>[];
+    text?: string;
+}
+/** load a `.json?...&.jsonp=cb` URL through a <script> tag (browser only; no CORS needed). */
+export declare function fetchJsonp(url: string, cbName: string, timeoutMs?: number, signal?: AbortSignal): Promise<any>;
+/** `{table:{columnNames, rows}}` -> array of objects. */
+export declare function tableToRows(t: {
+    table: {
+        columnNames: string[];
+        rows: unknown[][];
+    };
+}): Record<string, unknown>[];
+/** minimal CSV parse for `.csvp` (ERDDAP quotes with " and doubles inner quotes). */
+export declare function parseCsvp(text: string): Record<string, unknown>[];
+/**
+ * fetch one slab in the given format. Parquet comes back as bytes for `registerFileBuffer`. `retry`
+ * sets the per-attempt timeout and the tries (fetchRetry: 20 s and one retry unless the caller says
+ * otherwise: a whole live window can take longer than the one-step map slice).
+ */
+export declare function fetchSlab(url: string, format?: Format, callback?: string, signal?: AbortSignal, retry?: Omit<RetryOpts, 'signal'>): Promise<Slab>;