vastgrid-js 0.0.0-stage → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vastgrid contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,212 @@
-# Temporary Holding Version
+# vastgrid-js
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The memory engine of [vastgrid](https://www.npmjs.com/package/vastgrid), for the browser and Node.js, in the page or
+a Web Worker. It opens tables of rows of typed JSON, Apache Arrow, CSV, TSV, JSON Lines and Excel files, and Parquet
+files (also over HTTP Range requests), and sorts, filters, searches, groups, pivots, derives formulas, writes cells
+and exports, answering the grid's messages
+([§8 of the specification](https://github.com/yhay81/vastgrid/blob/main/docs/spec.md#8-messages)).
+
+```sh
+npm install vastgrid vastgrid-js
+```
+
+```tsx
+import { DataGrid, localTransport } from "vastgrid";
+import "vastgrid/styles.css";
+import { memoryEngine } from "vastgrid-js";
+
+const engine = memoryEngine({
+  tables: {
+    orders: {
+      columns: [
+        { name: "id", type: "bigint" },
+        { name: "price", type: "decimal", precision: 10, scale: 2 },
+      ],
+      rows: [
+        [1, "12.50"],
+        [2, "8.00"],
+      ],
+      editable: true,
+    },
+  },
+});
+
+export function Orders() {
+  return <DataGrid transport={localTransport(engine)} table="orders" style={{ height: 480 }} />;
+}
+```
+
+In a Web Worker, the engine answers through `serveEngine` of `vastgrid/core`, and the page talks to it with
+`workerTransport(worker)`, so that the page never stops while the engine reads a file or sorts a million rows:
+
+```ts
+// engine.worker.ts: the page posts the file that the person dropped or chose
+import { serveEngine, type WorkerLike } from "vastgrid/core";
+import { memoryEngine } from "vastgrid-js";
+
+self.addEventListener(
+  "message",
+  (event: MessageEvent<File>) => {
+    const file = event.data;
+    const table = /\.parquet$/i.test(file.name) ? { parquet: file } : { file, editable: true };
+    serveEngine(memoryEngine({ tables: { [file.name]: table } }), self as unknown as WorkerLike);
+  },
+  { once: true },
+);
+```
+
+The engine can also be called directly: `await engine.handle({ v: 2, id: 1, op: "open", ref: "orders" })`.
+
+## Reference
+
+- `memoryEngine({ tables })` takes the tables that `open` opens, by their `ref`: columns of §2.1 and rows of
+  typed JSON values (§2.2) in row ID order. The form of a table (its columns and rows of one value per column)
+  is checked when it is first opened, and its values as they are read (a column whole before it is sorted or
+  summed), so that opening a table of millions of rows takes milliseconds; a table that does not follow §2 is
+  answered with `load_failed` and the JSON Pointer of the place at fault. Its rows are read as they are,
+  without a copy, so they must not change afterwards.
+- A table may also be given as Arrow: `{ arrow }`, the bytes of an Arrow IPC stream or file of any number of
+  record batches (as `tableToIPC` of Flechette or Apache Arrow writes them), with `editable` as for rows. Its
+  columns have the logical types of their Arrow types (§2.3), and none is `readOnly`. The engine keeps them as
+  Arrow holds them, without a copy: integers, floats, dates, bigints, decimals of up to 18 digits, times and
+  timestamps as typed arrays, which checks and sorts read as numbers, and the other values read from their
+  buffers when they are asked for (`decodeColumns` of `vastgrid-spec/columns`). A million rows of integers,
+  floats, dates, decimals, timestamps and strings take 258 MB as Arrow against 494 MB as rows, the host's rows
+  included, and sort by a date, a decimal or a timestamp in 50–70 ms against 170–250 ms. Bytes that are not
+  Arrow, Arrow types that have no logical type (lists, structs, …) and names that two columns share fail with
+  `load_failed` at `/arrow`; values that have no typed JSON (text that is not UTF-8, dates after 9999-12-31)
+  fail when they are read, at `/rows/{row}/{column}`. The code that reads Arrow loads with the first such table.
+- A table may also be a text file: `{ file, format }`, with `file` a `Blob` or a `File` of CSV, TSV or JSON Lines
+  in UTF-8, in a Web Worker or the page, and `format` `csv`, `tsv` or `jsonl`, by default from the file's name
+  (`.csv`, `.tsv` or `.tab`, `.jsonl` or `.ndjson`); `editable` as for rows. It is read when it is first opened, in
+  slices of 4 MiB and twice: once to find its columns, the types that all their values fit and the memory they
+  take, then into typed columns, numbers in typed arrays (sorted as an Arrow table's are) and text as UTF-8,
+  without making rows of JSON. The open waits for both; opens of a file share one reading, and a table that every
+  ID has closed is read again. A CSV file of a million rows of six columns (55 MB) opens in about 0.9 seconds into
+  32 MB, where the same rows as JSON take 248 MB. The code that reads files loads with the first such table.
+- A table may also be a sheet of an Excel workbook (`.xlsx`, `.xlsm`): `{ file, format: "xlsx" }`, the format by
+  default from the file's name. `open`'s `read` (§8.2) chooses the sheet (the first visible one by default), the
+  row of the names (`headerRow`: by default the first row with a value; `0` for none, which names the columns by
+  their letters) and whether empty rows and columns are kept (`keepEmptyRows`, `keepEmptyColumns`); `TableInfo`
+  lists the workbook's `sheets`, the `sheet` read and `notes` (`merged_cells`, `formulas_without_values`). The sheet
+  is read with `vastgrid-spec/workbook`, as the DuckDB engine reads it: a column has one type (`bigint`, `float`,
+  `boolean`, `date`, `timestamp`, `time` or `string`) by its cells and their number formats, a formula its saved
+  value, and a date the workbook's calendar. Its rows are kept as lines of CSV in a `Blob` and read as a CSV file
+  is, within `maxBytes`; each set of `read` options is a table of its own, and other tables ignore `read`. A file
+  that is not a workbook, and one that is encrypted or in the old `.xls` format, fail with `load_failed` at
+  `/file`. The code that reads workbooks loads with the first such table.
+- A file's column has the first of these types that every value of it fits, and is a `string` otherwise:
+  `boolean` (`true` and `false` in any case), `integer` and `bigint` by their range, `float` (with `nan`, `inf`
+  and `infinity`), `time` (`HH:MM:SS` with up to 6 fraction digits), `date` (`YYYY-MM-DD` of the years 0001 to
+  9999), `timestamp` (a date, a space or `T` and a time; dates fit too) and `timestamptz` (a timestamp with `Z`,
+  `+HH`, `+HH:MM` or `+HHMM`, kept in UTC). Text that is almost a value (`24:00:00`, ` 1`, `2023-02-29`) makes a
+  string column, which keeps every value as it is written.
+- CSV and TSV: the first line names the columns unless `header: false` (empty names are `column0`, `column1`, …,
+  and a repeated name gets `_1`, `_2`, …). CSV's separator is `delimiter`, or the one of `,`, tab, `;` and `|` that
+  splits the first line into the most fields. A quote switches quoting on and off wherever it is, so that quotes
+  hold separators and line breaks and `""` within them is a quote; lines end with LF or CRLF, and empty lines are
+  no rows. An empty field is null, and so are the fields that a row shorter than the others lacks; a quoted empty
+  field (`""`) is an empty string, and null in a column of another type.
+- JSON Lines: an object per line, and a column per key in the order the keys first come, null where a line lacks
+  it. Numbers are what `JSON.parse` reads (integers beyond 2^53 are floats), strings are strings unless they are
+  times, dates or timestamps, and a column of objects and lists only is their JSON text (`sourceType: "JSON"`,
+  `readOnly: true`); a column of other values mixed is strings, with numbers and booleans as their JSON.
+- A UTF-8 byte order mark is left out. A file in UTF-16, text that is not UTF-8 (at `/rows/{row}/{column}`; §2.2
+  does not allow replacing it), a line of JSON Lines that is not an object (at `/rows/{row}`) and a file that cannot
+  be read fail with `load_failed`. Answering the first rows while a file loads (§9) is a later step.
+- `maxBytes` (default 1 GiB) is the most memory that a file's columns may take. A file whose columns would take
+  more is not kept: its first reading notes where every 1,024th row starts, and
+  the open answers then. Rows are read by those blocks, wherever they lie in a view, and the last 32 MiB of blocks
+  read are kept; a sort, a filter, a group, a summary, `find`, `export` and `locate` by value read the columns they
+  go through whole, in a reading of the file, while they fit `maxBytes`. A column read whole stays so until a
+  request needs its room while no request reads it: the least recently used are forgotten first, and read again
+  when a request needs them. A request that would read more at once fails with `load_failed` at `/maxBytes`, and
+  the table stays open. The 10-million-row CSV file of the benchmarks (701 MB)
+  opens so in 5 to 6 seconds into no memory with a `maxBytes` of 256 MiB, where kept it opens in 10 seconds into
+  590 MB.
+- A table may also be a Parquet file: `{ parquet }`, a `Blob` or a `File`, or the URL of a file whose server answers
+  HTTP range requests (`headers` such as `Authorization` go with every request, and `fetch` replaces the global
+  one); `editable` as for rows. Opening it reads its footer only. `rows` reads the row groups that hold its rows,
+  column by column (hyparquet, with the codecs of hyparquet-compressors), and keeps them in a cache of 4 million
+  cells; a sort, a filter, a group or a summary reads the columns it names whole into typed arrays, a row group at
+  a time, and `find`, `export` and `locate` by value the columns they go through. The rows of a view that lie in
+  more than two row groups, as a sorted or filtered view's do, read their columns whole too, so that scrolling
+  the view reads memory rather than every row group again. `maxBytes` (default 1 GiB) is about the most memory
+  that the columns read whole may take (numbers in typed arrays, booleans in a byte, text as strings, which the rows
+  of a dictionary's value share), and columns read whole are forgotten as a text file's are: a request that would
+  read more at once fails with `load_failed` at `/maxBytes`, the table stays open, and its rows are read by row
+  groups. A million rows of eight columns (13 MB of Parquet) open in
+  30 ms into 2 MB, show their first rows in 0.2 seconds, and take 130 MB once every column is read
+  ([measurements](https://github.com/yhay81/vastgrid/blob/main/docs/benchmarks/memory-engine.md)).
+- A Parquet file's columns have the types that DuckDB reads them as, with DuckDB's names as `sourceType`: integers
+  by their width and sign (UINTEGER as `bigint`, UBIGINT as `decimal(38, 0)`), FLOAT and DOUBLE, decimals,
+  BOOLEAN, DATE, TIME, timestamps of their unit (`timestamptz` when adjusted to UTC), INTERVAL, UUID, VARCHAR and
+  enums as strings, BLOB as `binary`, and JSON as `readOnly` strings. Lists, structs and maps are `readOnly`
+  strings of their JSON text, named as DuckDB names them (`INTEGER[]`, `STRUCT(a INTEGER)`). A URL's first answer
+  gives its size and its `ETag` or `Last-Modified`, which every later answer must match: a file that changed fails
+  with `file_changed`. Ranges read are kept in a cache of 32 MiB; a server that ignores `Range` sends the file
+  whole, which is kept when it is at most 16 MiB and fails with `load_failed` otherwise. A server of another
+  origin must expose `Content-Length`, `Content-Range` and `ETag` by CORS. The code that reads Parquet loads with
+  the first such table.
+- Float32 table values and writes must already be binary32 numbers (`Math.fround(0.1)`, not `0.1`);
+  `readCellText` converts typed input to them. Invalid timestamps, intervals and lone Unicode surrogates
+  are rejected by the same specification checks used to write Arrow blocks. An invalid write changes
+  no cells and identifies the offending value with `/updates/{index}/value`.
+- `engine.handle(message)` answers a request with its response or error, with blocks in the structured
+  encoding (`{ bytes }`, §8.8), and never throws; `cancel` has no answer. `engine.subscribe(listener)` listens
+  to the events of §8.5: `changed` after every write.
+- The engine offers what `MEMORY_CAPABILITIES` reports (§4.10): every plan of §4.1 (derive, `where`, search,
+  `aggregate` with `pivot`, `having` and sort), with every function of §4.4 and every measure of §4.5,
+  `summarize`, `find`, `locate`, `export` of CSV, TSV, JSON and xlsx, and `write` for tables given with
+  `editable: true` (§7.2: by row ID or by `rowKey`, every update or none, with `previous` checked, and a `changed`
+  event). Written values are kept apart from the host's rows, bytes or file, which stay as they were: the engine keeps
+  them by row and column over the column, without a copy of it, so that a write takes the memory of the values
+  written. A table that holds them keeps them when it is closed. Other plans fail with
+  `invalid_plan` (`unsupported`) only when they name functions or members that a later version adds, `write` on
+  other tables with `read_only`, `save` with `save_unsupported`, and an `export` of Parquet with `invalid_request`
+  at `/format`.
+- `find` goes through the view's cells row by row from the cell after `from` and compares their text forms (§2.4)
+  by `lower`, as the DuckDB engine does. `export` answers the file's bytes as `data` (`delivery` `data`, §8.2) and
+  takes no `target`: CSV, TSV and JSON as DuckDB's `COPY` writes them (`vastgrid-spec/export`) and workbooks with
+  `vastgrid-spec/xlsx`, compressed with the platform's `CompressionStream`. The file is made in memory, a batch of
+  rows at a time, so it takes about its size besides the table; a grid downloads it as a file
+  (`URL.createObjectURL`). That is how a page saves: the engine writes no file, and the `File` that a table was
+  opened from stays as it was.
+- A request that goes through many rows (`find`, `export`), reads a file's columns whole or ranks the text of the
+  columns that a view sorts or groups by lets other messages in every 40 ms or so, so that a `cancel` of it is read:
+  it then stops with `cancelled` (§8.6) within a few milliseconds. The rest of a view (ranking numbers, sorting,
+  filtering, grouping and deriving) runs to its end, and the view is kept; a cancel of it answers `cancelled` after.
+- Expressions are compiled once per view to functions of a row ID (§3.6, §3.7, §4.4): exact numbers are
+  computed as integers at their scale, with BigInt where a number would not be exact, so a result that does not
+  fit its type is null rather than rounded; floats are 64-bit, and results that are not finite are null.
+  Strings compare by code point, and `lower` and `upper` map code points one by one as DuckDB 2.0 does (`İ` →
+  `i`, `ß` → `ẞ`). Derived columns are computed for every row of the table, then `where` keeps the rows of the
+  view; `locate` gives null for rows that it leaves out. A million rows derive a decimal product, filter by it
+  and sort by it in about 0.7 seconds.
+- Groups are made from the ranks of their keys, so that values equal by §3.1 make one group (every NaN, −0.0 and
+  0.0) and groups come in the order of §3.9; each measure keeps its state per group, or per group and pivot
+  combination. Sums of exact numbers are exact, and null when they do not fit decimal(38, s); averages come
+  from the exact sum; `stddev` is Welford's sample standard deviation and `quantile` interpolates as DuckDB's
+  `quantile_cont`. Approximate measures are computed exactly. A view of groups has no row IDs: `rows` answers
+  `rowIds` null, `locate` finds values of a key of the view (by `rowKey`) and nothing by row ID. A million rows
+  group by 1,000 keys with four measures and sort in about 0.5 seconds.
+- Plans that derive, filter or group are run by a module of their own, loaded with the first such plan, so that
+  pages whose plans only sort do not load it.
+- Views are in the order of §3.3. Each column's values are ranked once, by a radix sort of their bits for
+  values of fixed width and by code point for strings; a view is then one counting sort per sort key. A
+  million floats sort in about 0.2 seconds. Intervals compare as DuckDB 2.0 compares them (`normalizeInterval`
+  of `vastgrid-spec`): by their length, with months of 30 days and days of 24 hours, so that `1 month -1 day`
+  equals `29 days`.
+- `locate` finds a value of `rowKey` at its first position in the view; `summarize` counts each cell of
+  `ranges` × `columns` once, sums exact numbers exactly, and gives floats that are not finite as cells but
+  not as numbers.
+
+The tests run every case of the conformance corpus of [`vastgrid-spec`](https://www.npmjs.com/package/vastgrid-spec), with its tables as rows and as
+Arrow, check the order of both against a comparison of values one pair at a time on generated tables, and check
+every response with `checkResponse`. Files are read in slices of every size from 1 byte, and a generated CSV file
+answers sorts, filters, groups and summaries as the same rows given as typed JSON. The
+DuckDB engine's tests compare this engine's answers with its own on a generated table and generated plans
+(`packages/duckdb-engine/test/memory-engine.test.ts`), with the table as a Parquet file that DuckDB wrote too: the
+same columns, and the same answers. Another test serves a Parquet file over HTTP and counts the bytes that opening,
+reading rows and sorting read. `packages/duckdb-engine/bench/memory-engine.ts` measures a million rows as CSV and as
+Parquet ([results](https://github.com/yhay81/vastgrid/blob/main/docs/benchmarks/memory-engine.md)).

package/dist/aggregate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Groups (docs/spec.md §3.8, §3.9, §4.5, §4.6): the rows that `where` keeps, one group for each combination
+ * of the ranks of their keys, with the measures of each group and the generated columns of a pivot.
+ *
+ * Ranks make groups by §3.1 equality (all NaNs are one value, −0.0 and 0.0 are one) and order them as §3.9 does:
+ * values ascending, then the empty string, then null. Groups are numbered in that order, so a view without
+ * `sort` is the groups in number order, and a sort is stable over them.
+ */
+import { type CheckedAggregate, type Column, type JsonValue, type TypedExpr } from "vastgrid-spec";
+import type { ColumnRanks } from "./order.js";
+import type { Vector } from "./table.js";
+/** What grouping reads: the columns of the rows before grouping, by name, and the rows that `where` keeps. */
+export interface GroupInput {
+    aggregate: CheckedAggregate;
+    /** The view's columns that the checked plan knows: the keys, then the measures unless there is a pivot. */
+    columns: Column[];
+    /** The row IDs that `where` keeps, in order; null for every row of the table. */
+    rows: Uint32Array | null;
+    /** The rows of the table. */
+    count: number;
+    /** A column's values by row ID: a column of the table or a derived one. */
+    values(name: string): Vector;
+    /** A column's ranks by row ID (§3.3). */
+    ranks(name: string): ColumnRanks;
+}
+/** A column of groups: its values by group number. */
+export interface GroupColumn {
+    column: Column;
+    values: JsonValue[];
+}
+/** The groups of a view: its columns, their values by group number, and the groups that `having` keeps. */
+export interface Groups {
+    columns: Column[];
+    values: Map<string, GroupColumn>;
+    count: number;
+    /** The groups that `having` keeps, in order; null without `having`. */
+    kept: Uint32Array | null;
+}
+/**
+ * The groups of the rows that `where` keeps, with the measures of each, or with a pivot's generated columns, and
+ * those that `having` keeps. Throws a `SpecError` (`too_many_columns`) for a pivot that would make more columns
+ * than `maxColumns`.
+ */
+export declare function groupRows(input: GroupInput, having: TypedExpr | null): Groups;
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../src/aggregate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,MAAM,EACX,KAAK,SAAS,EAEd,KAAK,SAAS,EAKf,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,8GAA8G;AAC9G,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,2GAA2G;IAC3G,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,iFAAiF;IACjF,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACzB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,yCAAyC;IACzC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CAClC;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAED,2GAA2G;AAC3G,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;CAC1B;AAiOD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,MAAM,CAS7E"}

package/dist/aggregate.js

@@ -0,0 +1,305 @@
+/**
+ * Groups (docs/spec.md §3.8, §3.9, §4.5, §4.6): the rows that `where` keeps, one group for each combination
+ * of the ranks of their keys, with the measures of each group and the generated columns of a pivot.
+ *
+ * Ranks make groups by §3.1 equality (all NaNs are one value, −0.0 and 0.0 are one) and order them as §3.9 does:
+ * values ascending, then the empty string, then null. Groups are numbered in that order, so a view without
+ * `sort` is the groups in number order, and a sort is stable over them.
+ */
+import { SpecError, textOf, uniqueName, valueType, } from "vastgrid-spec";
+import { comparer, decimalText, exactJson, filter, toFloat, unscaled } from "./evaluate.js";
+/** Numbers the combinations of the ranks of columns among the rows, in the order of their ranks. */
+function combine(ranks, rows, count) {
+    const length = rows ? rows.length : count;
+    const of = new Uint32Array(length);
+    if (ranks.length === 0)
+        return { of, firsts: length > 0 ? [rows ? rows[0] : 0] : [] };
+    // Each combination as one number while their product fits, otherwise as text.
+    const sizes = ranks.map((item) => item.distinct + 2);
+    const numeric = sizes.reduce((product, size) => product * size, 1) <= Number.MAX_SAFE_INTEGER;
+    const found = new Map();
+    const firsts = [];
+    for (let at = 0; at < length; at++) {
+        const row = rows ? rows[at] : at;
+        let key;
+        if (ranks.length === 1)
+            key = ranks[0].ranks[row];
+        else if (numeric) {
+            key = 0;
+            for (let which = 0; which < ranks.length; which++)
+                key = key * sizes[which] + ranks[which].ranks[row];
+        }
+        else
+            key = ranks.map((item) => item.ranks[row]).join(",");
+        let id = found.get(key);
+        if (id === undefined) {
+            id = firsts.length;
+            found.set(key, id);
+            firsts.push(row);
+        }
+        of[at] = id;
+    }
+    // Renumber in the order of the ranks.
+    const order = firsts.map((_, id) => id);
+    order.sort((a, b) => {
+        for (const item of ranks) {
+            const difference = item.ranks[firsts[a]] - item.ranks[firsts[b]];
+            if (difference !== 0)
+                return difference;
+        }
+        return 0;
+    });
+    const renumbered = new Uint32Array(order.length);
+    order.forEach((id, place) => {
+        renumbered[id] = place;
+    });
+    for (let at = 0; at < length; at++)
+        of[at] = renumbered[of[at]];
+    return { of, firsts: order.map((id) => firsts[id]) };
+}
+/** Whether a value counts for a measure (§3.8): not null, and for floats, finite except for counts. */
+function counted(column, measure) {
+    if (column.type !== "float" || measure.fn === "count" || measure.fn === "count_distinct") {
+        return (value) => value !== null;
+    }
+    return (value) => value !== null && typeof value === "number";
+}
+function accumulator(measure, input, cells) {
+    const column = measure.column;
+    if (!column) {
+        const counts = new Float64Array(cells);
+        return {
+            add: (cell) => {
+                counts[cell]++;
+            },
+            result: (cell) => counts[cell],
+        };
+    }
+    const values = input.values(column.name);
+    const takes = counted(column, measure);
+    switch (measure.fn) {
+        case "count": {
+            const counts = new Float64Array(cells);
+            return {
+                add: (cell, row) => {
+                    if (values.at(row) !== null)
+                        counts[cell]++;
+                },
+                result: (cell) => counts[cell],
+            };
+        }
+        case "count_distinct": {
+            const { ranks, distinct } = input.ranks(column.name);
+            const seen = new Array(cells);
+            return {
+                add: (cell, row) => {
+                    const rank = ranks[row];
+                    if (rank > distinct)
+                        return;
+                    let set = seen[cell];
+                    if (!set) {
+                        set = new Set();
+                        seen[cell] = set;
+                    }
+                    set.add(rank);
+                },
+                result: (cell) => seen[cell]?.size ?? 0,
+            };
+        }
+        case "sum":
+        case "avg":
+            return column.type === "float" ? floatSum(measure, values, cells) : exactSum(measure, column, values, cells);
+        case "stddev": {
+            // Welford's running mean and sum of squared differences.
+            const counts = new Float64Array(cells);
+            const means = new Float64Array(cells);
+            const squares = new Float64Array(cells);
+            return {
+                add: (cell, row) => {
+                    const value = values.at(row);
+                    if (!takes(value))
+                        return;
+                    const number = toFloat(value, column);
+                    const count = ++counts[cell];
+                    const delta = number - means[cell];
+                    means[cell] += delta / count;
+                    squares[cell] += delta * (number - means[cell]);
+                },
+                result: (cell) => (counts[cell] < 2 ? null : finite(Math.sqrt(squares[cell] / (counts[cell] - 1)))),
+            };
+        }
+        case "min":
+        case "max": {
+            const compare = comparer(column, column);
+            const greatest = measure.fn === "max";
+            const best = new Array(cells).fill(null);
+            return {
+                add: (cell, row) => {
+                    const value = values.at(row);
+                    if (!takes(value))
+                        return;
+                    const now = best[cell];
+                    if (now === null || (greatest ? compare(value, now) > 0 : compare(value, now) < 0))
+                        best[cell] = value;
+                },
+                result: (cell) => best[cell],
+            };
+        }
+        case "quantile": {
+            const p = measure.p ?? 0.5;
+            const numbers = new Array(cells);
+            return {
+                add: (cell, row) => {
+                    const value = values.at(row);
+                    if (!takes(value))
+                        return;
+                    let list = numbers[cell];
+                    if (!list) {
+                        list = [];
+                        numbers[cell] = list;
+                    }
+                    list.push(toFloat(value, column));
+                },
+                // Linear interpolation between the two closest ranks (DuckDB's quantile_cont).
+                result: (cell) => {
+                    const list = numbers[cell];
+                    if (!list)
+                        return null;
+                    const sorted = Float64Array.from(list).sort();
+                    const place = p * (sorted.length - 1);
+                    const low = Math.floor(place);
+                    const high = Math.ceil(place);
+                    return finite(sorted[low] + (sorted[high] - sorted[low]) * (place - low));
+                },
+            };
+        }
+    }
+}
+function finite(value) {
+    return Number.isFinite(value) ? value + 0 : null;
+}
+/** `sum` and `avg` of floats, leaving out NaN and the infinities (§3.8). */
+function floatSum(measure, values, cells) {
+    const counts = new Float64Array(cells);
+    const sums = new Float64Array(cells);
+    return {
+        add: (cell, row) => {
+            const value = values.at(row);
+            if (typeof value !== "number")
+                return;
+            counts[cell]++;
+            sums[cell] += value;
+        },
+        result: (cell) => {
+            if (counts[cell] === 0)
+                return null;
+            return measure.fn === "avg" ? finite(sums[cell] / counts[cell]) : finite(sums[cell]);
+        },
+    };
+}
+/**
+ * `sum` and `avg` of exact numbers: an exact sum, in numbers while they stay exact and in BigInt beyond; a sum
+ * that does not fit decimal(38, s) is null, and the average is computed from the exact sum (§3.8).
+ */
+function exactSum(measure, column, values, cells) {
+    const scale = column.type === "decimal" ? (column.scale ?? 0) : 0;
+    const counts = new Float64Array(cells);
+    const small = new Float64Array(cells);
+    const large = new Array(cells);
+    return {
+        add: (cell, row) => {
+            const value = values.at(row);
+            if (value === null)
+                return;
+            counts[cell]++;
+            let number = Number.NaN;
+            if (typeof value === "number")
+                number = value;
+            else if (value.length <= 16)
+                number = Number(scale === 0 ? value : value.replace(".", ""));
+            const total = small[cell] + number;
+            if (Number.isSafeInteger(number) && Number.isSafeInteger(total))
+                small[cell] = total;
+            else
+                large[cell] = (large[cell] ?? 0n) + unscaled(value, column);
+        },
+        result: (cell) => {
+            if (counts[cell] === 0)
+                return null;
+            const total = BigInt(small[cell]) + (large[cell] ?? 0n);
+            if (measure.fn === "avg")
+                return finite(Number(decimalText(total, scale)) / counts[cell]);
+            return exactJson(total, measure.type);
+        },
+    };
+}
+/**
+ * The groups of the rows that `where` keeps, with the measures of each, or with a pivot's generated columns, and
+ * those that `having` keeps. Throws a `SpecError` (`too_many_columns`) for a pivot that would make more columns
+ * than `maxColumns`.
+ */
+export function groupRows(input, having) {
+    const { columns, values, count } = groupColumns(input);
+    const byName = new Map();
+    for (const column of columns)
+        byName.set(column.name, { column, values: values.get(column.name) });
+    const read = (name) => {
+        const found = byName.get(name).values;
+        return (group) => found[group];
+    };
+    return { columns, values: byName, count, kept: having ? filter(having, read, count) : null };
+}
+function groupColumns(input) {
+    const { aggregate, rows, count } = input;
+    const { keys, measures, pivot } = aggregate;
+    const length = rows ? rows.length : count;
+    const groups = combine(keys.map((key) => input.ranks(key.name)), rows, count);
+    // Without keys, one group, also over no rows.
+    const groupCount = keys.length === 0 ? 1 : groups.firsts.length;
+    const combinations = pivot
+        ? combine(pivot.columns.map((column) => input.ranks(column.name)), rows, count)
+        : null;
+    const width = combinations ? combinations.firsts.length : 1;
+    if (pivot && width * measures.length > pivot.maxColumns) {
+        throw new SpecError("too_many_columns", `The pivot makes more than ${pivot.maxColumns} columns (§4.6).`);
+    }
+    const accumulators = measures.map((measure) => accumulator(measure, input, groupCount * width));
+    for (let at = 0; at < length; at++) {
+        const row = rows ? rows[at] : at;
+        const cell = groups.of[at] * width + (combinations ? combinations.of[at] : 0);
+        for (const item of accumulators)
+            item.add(cell, row);
+    }
+    const columns = [...input.columns];
+    const values = new Map();
+    for (const key of keys) {
+        const source = input.values(key.name);
+        values.set(key.name, groups.firsts.map((row) => source.at(row)));
+    }
+    const results = (measure, combination) => Array.from({ length: groupCount }, (_, group) => accumulators[measure].result(group * width + combination));
+    if (!pivot || !combinations) {
+        measures.forEach((measure, index) => {
+            values.set(measure.name, results(index, 0));
+        });
+        return { columns, values, count: groupCount };
+    }
+    const taken = new Set(columns.map((column) => column.name));
+    combinations.firsts.forEach((row, combination) => {
+        const combinationValues = pivot.columns.map((column) => input.values(column.name).at(row));
+        const labels = combinationValues.map((value, index) => {
+            const text = textOf(value, pivot.columns[index]);
+            return text === null ? "(null)" : text === "" ? "(empty)" : text;
+        });
+        measures.forEach((measure, index) => {
+            const name = uniqueName([...labels, measure.name].join(" / "), taken);
+            columns.push({
+                name,
+                ...valueType(measure.type),
+                pivot: { values: combinationValues, measure: measure.name },
+            });
+            values.set(name, results(index, combination));
+        });
+    });
+    return { columns, values, count: groupCount };
+}
+//# sourceMappingURL=aggregate.js.map

package/dist/aggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.js","sourceRoot":"","sources":["../src/aggregate.ts"],"names":[],"mappings":"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"}

package/dist/arrow.d.ts

@@ -0,0 +1,7 @@
+import { type CheckedTable } from "./table.js";
+/**
+ * Checks a table given as Arrow and reads its columns: their logical types, and their values kept as Arrow holds
+ * them. Throws a `TableProblem` at `/arrow` for bytes that are not an Arrow table of §2.3.
+ */
+export declare function checkArrow(bytes: unknown): CheckedTable;
+//# sourceMappingURL=arrow.d.ts.map

package/dist/arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow.d.ts","sourceRoot":"","sources":["../src/arrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,YAAY,EAA4B,MAAM,YAAY,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAYvD"}