tabulark 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -1,8 +1,73 @@
 # Changelog
 
 All notable changes to Tabulark are documented here. The project follows
-[Semantic Versioning](https://semver.org/); public JavaScript entry points are
-additive-only throughout the 0.1.x line.
+[Semantic Versioning](https://semver.org/).
+
+## 0.2.1
+
+- Read partial viewports from oversized Parquet row groups page by page instead
+  of staging every projected column chunk. Lazy reads enforce cumulative page
+  decompression, bounded page tracking and header parsing, compressed-cache
+  peak, and decoder-restart limits before returning data to parquet-rs.
+- Bound nested Arrow display previews without changing their native values;
+  oversized list, struct, map, and union text ends with an explicit
+  `... [truncated]` marker.
+- Add a separately built, experimental document-preview source package with a
+  Worker-isolated PDFium page pipeline, bounded RGBA page rendering, and an
+  accessible framework-free paged view. It is not part of the stable root npm
+  exports or official tabular-adapter manifest.
+
+## 0.2.0
+
+- Add bounded structured diagnostics and independent diagnostic subscriptions.
+- Add logical dataset/table capability snapshots and opt-in privacy-safe
+  performance samples.
+- Add Canvas `colorScheme` support with dynamic dark mode and forced-colors
+  precedence.
+- Add opt-in `sourceMode: "large"` for local Blob/File inputs through exactly
+  `2^31` bytes across CSV, Arrow File, Parquet, XLSX, and XLS; ArrayBuffer and
+  automatic-mode limits remain unchanged.
+- Add the stable `RangeSource` capability to every official format. Readers
+  validate exact lengths and snapshots, support independent reopen/close
+  lifecycles, and address at most `4,294,967,295` bytes (`2^32 - 1`).
+- Add `tabulark/http` with a `GET Range: bytes=0-0` capability probe, strict
+  `Content-Range` and validator checks, bounded transient retries, dynamic
+  headers/credentials, and an explicit bounded-download fallback. Network and
+  authentication remain on the main thread; no URL, headers, validator, or
+  snapshot ID is exposed in Worker messages, errors, or performance samples.
+- Add source-range request coalescing, dataset singleflight, a byte-budgeted
+  range LRU, four-way maximum provider concurrency, exact reader cleanup, and
+  cross-thread memory slices (75% Worker, 12.5% source staging, 12.5%
+  retained batches/fallback).
+- Add `SOURCE_UNAVAILABLE`, `SOURCE_CHANGED`, and `RANGE_UNSUPPORTED` source
+  errors. Extend `PerformanceSample` with `sourceReads` and
+  `sourceCacheHitBytes`; `cacheHit` remains the logical batch-cache metric.
+- Move every official adapter to private Worker protocol v4 and adapter ABI v3
+  resumable operations with checked revisions, bounded multi-range actions,
+  cooperative no-I/O yields, and one-transfer batch output.
+- Make the main thread the sole decoded-batch cache owner, with immutable
+  backings, logical-table keys, singleflight misses, and independent caller
+  cancellation. Remove the Worker decoded LRU.
+- Add Rust/WASM resource ledgers and native cache admission/reclamation
+  evidence, including 100-cycle lifecycle and WebAssembly-memory high-water
+  gates.
+- Add incremental Arrow File/Stream indexing, coalesced Parquet projection
+  reads, and Rust range-backed ZIP64/CFB Excel container indexing. Excel
+  compacts only required workbook content into its bounded compatibility
+  parser.
+- Add release-blocking Chromium, Firefox, and WebKit functional projects.
+  Chromium additionally owns pixel, performance, real-clipboard, and exact
+  2 GiB evidence.
+- Add paired baseline performance gates, shipped-JavaScript shrinkage gates,
+  and a native five-container exact-size generator/workflow.
+- Add HTTP contract, virtual/sparse 4 GiB−1, cancellation/lifecycle,
+  concurrency, cache, CORS, retry, validator-change, and explicit-fallback
+  release evidence in Chromium, Firefox, and WebKit. Keep a separate measured
+  raw/Brotli size budget for the new `/http` entry point.
+- Remove the private TypeScript large-XLSX parser and its shipped artifact.
+
+Version 0.1.1 was never tagged or published; its compatible work is included
+in 0.2.0. The immutable `v0.1.0` tag is unchanged.
 
 ## 0.1.0
 

package/README.md

@@ -1,40 +1,47 @@
 # Tabulark
 
-> **Status: M4 complete; 0.1.0 release candidate in progress.** The M4
-> CSV/TSV and Apache Arrow IPC milestone completed at `1d79837`, including CI,
-> GitHub Pages, and a deployed-URL smoke. The package has not yet been published
-> as 0.1.0; see the [M4 completion record](docs/m4-completion.md) and the
-> [release policy](docs/releasing.md).
-
-Tabulark is a WebAssembly-first browser primitive for previewing local tabular
-data without uploading it. A module Worker owns parsing, bounded byte access,
-adapter state, cancellation, and cleanup. A Canvas viewport renders visible
-cells while a bounded semantic grid supplies keyboard and screen-reader access.
+> **Status: 0.2.1.** The immutable `v0.1.0` tag and its registry/Pages
+> evidence remain recorded in
+> [the release evidence](docs/release-0.1.0-evidence.md); that tag is never
+> moved or reused. Version 0.2 adds bounded local and remote range sources,
+> structured diagnostics and capabilities, performance observation, and
+> synchronized Canvas themes without changing the documented 0.1.0 calling
+> patterns. Local `sourceMode: "large"` remains capped at 2 GiB; a validated
+> `RangeSource` may address at most `4,294,967,295` bytes (`2^32 - 1`).
+
+Tabulark is a WebAssembly-first browser primitive for previewing tabular data
+without uploading it. Local bytes stay local; an explicit `RangeSource` can
+read a remote object through a main-thread broker without giving its URL,
+credentials, or headers to the Worker. A module Worker owns parsing, bounded
+byte access, adapter state, cancellation, and cleanup. A Canvas viewport
+renders visible cells while a bounded semantic grid supplies keyboard and
+screen-reader access.
 
 [Try the playground](https://ronbb.github.io/tabulark/) · [Architecture](docs/architecture.md) · [API stability](docs/api-stability.md) · [Testing](docs/testing.md)
 
 ## Supported local formats
 
-The 0.1.0 source tree contains four immutable official adapters. Each adapter
+The 0.2.1 source tree contains four official adapters. Each adapter
 is a separate, lazily loaded WebAssembly artifact; creating an engine loads no
 WASM and opening one format does not fetch unused artifacts.
 
-| Format | Official ID | Stable entry point | 0.1 contract |
+| Format | Official ID | Stable entry point | 0.2 contract |
 | --- | --- | --- | --- |
 | CSV/TSV | `tabulark:delimited` | `tabulark` | Explicit delimiter, header, and strict/lenient modes |
 | Arrow IPC | `tabulark:arrow-ipc` | `tabulark/arrow` | File/Stream; none, LZ4, and Zstd IPC compression |
 | Parquet | `tabulark:parquet` | `tabulark/parquet` | Range-driven row-group/column projection and the documented codec set |
 | Excel | `tabulark:excel` | `tabulark/excel` | Excel 97–2003 BIFF8 XLS and OOXML XLSX, including static presentation |
 
-Remote sources, arbitrary adapter/module URLs, public third-party adapters,
-persistent caches, formula calculation, editing, and document-level Excel
-round-tripping are outside 0.1.
+Arbitrary adapter/module URLs, public third-party adapters, persistent caches,
+ReadableStream sources, formula calculation, editing, and document-level Excel
+round-tripping are outside 0.2. Remote input is available only through the
+explicit `RangeSource` contract (or the opt-in `tabulark/http` helper).
 
 ## Install and build
 
-The npm package has no production JavaScript dependencies. It targets modern
-Chromium and requires Node 20 or newer to build from source. Rust 1.85 is the
-minimum supported Rust version.
+The npm package has no production JavaScript dependencies. Its desktop release
+gate covers Chromium, Firefox, and WebKit, and it requires Node 20 or newer to
+build from source. Rust 1.85 is the minimum supported Rust version.
 
 ```sh
 npm ci
@@ -43,21 +50,23 @@ npm run check
 npm run test:browser
 ```
 
-`npm run build` creates five public JavaScript entry points, a generic Worker,
+`npm run build` creates six public JavaScript entry points, a generic Worker,
 and independent Delimited, Arrow, Parquet, and Excel WASM artifacts under
 `dist/wasm/`.
 
 ## Stable JavaScript API
 
 Register only the adapters an engine may use. The allow-list is immutable for
-that engine's lifetime, and the only accepted source inputs are `File`, `Blob`,
-and `ArrayBuffer`.
+that engine's lifetime. Local inputs are `File`, `Blob`, and `ArrayBuffer`; an
+explicit `RangeSource` is the bounded remote (or application-owned) source
+capability.
 
 ```ts
 import { createEngine, delimitedAdapter } from "tabulark";
 import { arrowIpcAdapter } from "tabulark/arrow";
 import { parquetAdapter } from "tabulark/parquet";
 import { excelAdapter } from "tabulark/excel";
+import { httpRangeSource } from "tabulark/http";
 
 const engine = await createEngine({
   adapters: [delimitedAdapter, arrowIpcAdapter, parquetAdapter, excelAdapter],
@@ -65,6 +74,7 @@ const engine = await createEngine({
 
 const csv = await engine.open(csvFile, {
   adapter: delimitedAdapter,
+  sourceMode: "auto", // use "large" for a local File/Blob up to 2 GiB
   adapterOptions: {
     dialect: "csv",
     header: "first-row",
@@ -81,16 +91,65 @@ const workbook = await engine.open(excelFile, {
   adapter: excelAdapter,
   adapterOptions: { format: "auto", sourceName: excelFile.name },
 });
+
+const remote = httpRangeSource("https://data.example.test/table.parquet", {
+  credentials: "include",
+  validation: "strong", // ETag, or Last-Modified + length when permitted
+  maxConcurrency: 2,
+});
+const remoteTable = await engine.open(remote, {
+  adapter: parquetAdapter,
+});
 ```
 
-Adapter selection is explicit. Excel's `format: "auto"` and Arrow's
+In the stable API, adapter selection is explicit. Excel's `format: "auto"` and Arrow's
 `container: "auto"` inspect source bytes; filename extensions never select or
 authenticate a format.
 
+The bundled playground is a convenience layer: it uses the local file name,
+MIME type, and (when needed) a bounded signature read to choose the explicit
+adapter call for you. Applications using the stable API should continue to
+select and register an adapter themselves.
+
 `ArrayBuffer` ownership is retained by default. Set `transferInput: true` only
 when intentionally detaching an `ArrayBuffer`; using it with a `Blob` or
 `File` returns `INVALID_ARGUMENT`.
 
+`sourceMode: "auto"` keeps the conservative source policy. The opt-in
+`sourceMode: "large"` path accepts only a local `File`/`Blob` no larger than
+exactly `2,147,483,648` bytes (`2^31`, 2 GiB); it does not raise the existing
+`ArrayBuffer` staging limit or allocate a work set proportional to the file. A
+larger source fails before an open request is sent to the Worker, with
+`RESOURCE_LIMIT` details containing `resource`, `requiredBytes`, and
+`availableBytes`.
+
+`RangeSource` readers report an exact size and snapshot validator and return
+exactly the requested bytes. `TabularkEngine.open()` creates an independent
+reader for each open and closes it exactly once on failure, cancellation, or
+dataset/engine close. `sourceMode` and `transferInput` are rejected for a
+`RangeSource`. The source ceiling is exactly `4,294,967,295` bytes; a 4 GiB
+source is rejected before adapter startup. The Worker receives only an opaque
+source handle, size, and bounded transferable byte buffers. Provider requests
+are merged for overlap/adjacency, limited to four concurrent reads, and
+covered by a dataset range-cache/singleflight layer.
+
+The `tabulark/http` helper probes with `GET Range: bytes=0-0`, requires a
+precise `Content-Range` and a trusted ETag (or an explicitly allowed weak
+Last-Modified-plus-length validator), and revalidates every `206` response.
+Retries are bounded and limited to transient network/status failures. A full
+download is never implicit: `fallback: { mode: "bounded-download", maxBytes }`
+must be supplied and must fit both that bound and the engine staging budget.
+Error messages and performance samples omit URLs, query strings, headers,
+validators, and snapshot identifiers.
+
+The exact-boundary local-file release gate covers five real containers: CSV,
+Arrow File, Parquet, XLSX, and XLS. Each fixture is exactly `2^31` bytes and
+the test reads the final bounded window ending at byte `2^31 - 1`. Remote
+RangeSource gates separately use a virtual/sparse source at
+`4,294,967,295` bytes and exercise non-adjacent offsets above `2^31` without
+allocating oversized browser fixtures. Overflow and 4 GiB rejection are
+checked before adapter startup.
+
 ### Tables, logical batches, and presentation
 
 ```ts
@@ -175,14 +234,30 @@ XLS support is deliberately limited to BIFF8. Earlier BIFF, XLSM, XLSB, ODS,
 and encrypted workbooks return `UNSUPPORTED_FEATURE`. XLS and XLSX share the
 same bounded static-presentation subset.
 
-## Memory and lifecycle
-
-One engine-wide reservation ledger accounts for adapter runtimes, source
-staging, compressed/decompressed pages, opened worksheets, batches, and caches.
-`RESOURCE_LIMIT` errors identify the resource category and the required and
-available amounts. Excel stages one bounded workbook; Parquet performs bounded
-range reads. ZIP/CFB entry counts, decompressed bytes, worksheet dimensions,
-cells, styles, layout entries, and merged regions are capped before allocation.
+For large XLSX, Rust indexes ZIP/ZIP64 metadata and fetches the workbook,
+relationships, shared resources, and selected worksheet ranges. For large XLS,
+Rust indexes CFB/DIFAT/FAT/miniFAT/directory data and fetches the referenced
+Workbook/Book stream ranges. In both cases it compacts only the needed content
+into a bounded workbook for the existing Calamine compatibility parser. This
+does not imply a custom XML/BIFF checkpoint engine or worksheet tile store.
+
+## Memory, cache, and lifecycle
+
+The main thread owns the only decoded-batch cache. It stores immutable backing
+objects keyed by dataset, logical table, revision, schema version, and
+normalized range; each API call receives a fresh logical facade. Concurrent
+identical misses are singleflight operations. Cancelling one caller does not
+cancel work shared by others, while cancelling every waiter sends one Worker
+cancel. A table handle may close without discarding its logical-table backing;
+dataset close or a revision/schema change evicts it.
+
+The Worker coordinates the engine-wide quota across adapters. Inside each
+Rust/WASM runtime, a checked ledger distinguishes persistent state, active
+operations, ingress/output, reclaimable native cache, and caller-owned
+telemetry. Admission clears soft native cache and retries once before returning
+`RESOURCE_LIMIT`, whose details identify required and available capacity.
+ZIP/CFB entries, decompression, worksheet dimensions, cells, styles, layout,
+merged regions, Parquet pages, and decoded batches remain bounded.
 
 Handles are nested and cleanup cascades downward:
 
@@ -215,7 +290,7 @@ cargo test --workspace --all-features --locked
 # Stable exports/declarations, clean package consumers, and Pages assembly
 npm run check
 
-# Real module Worker/WASM, Canvas, ARIA, keyboard, copy, forced-colors, visuals
+# Real module Worker/WASM, Canvas, ARIA, keyboard, copy, and forced-colors
 npm run test:browser
 
 # Independent core, Arrow, Parquet, Excel, npm, and Pages delivery budgets
@@ -225,20 +300,27 @@ npm run benchmark:size
 npm run benchmark:formats
 ```
 
-Chromium is the sole formal 0.1.0 browser gate. CI records its exact version.
-The Pages post-deploy smoke opens CSV, Arrow IPC, Parquet, XLS, and XLSX and
-asserts that only used adapter artifacts were requested.
+Chromium, Firefox, and WebKit are all release-blocking desktop functional gates.
+Chromium additionally owns exact pixel snapshots, performance comparison, real
+Clipboard API coverage, and the exact-2-GiB workflow. Firefox and WebKit cover
+the four adapters, lifecycle, Blob ranges, themes, ARIA, input behavior, copy
+through a deterministic clipboard seam, and Pages smoke. The Pages post-deploy
+smoke opens CSV, Arrow IPC, Parquet, XLS, and XLSX and asserts that only used
+adapter artifacts were requested.
 
 ## Stability and release
 
-The root, `/arrow`, `/parquet`, and `/excel` entry points are stable for 0.1.x:
-compatible additions are allowed, but removals and breaking changes wait for
-0.2.0. Rust APIs, the Worker protocol, adapter ABI, wire DTOs, and
+The root, `/arrow`, `/parquet`, `/excel`, and `/http` entry points are stable
+for 0.2.x. (`/experimental` remains explicitly unstable.)
+Version 0.2 preserves the documented 0.1.0 calls and adds diagnostics,
+capability queries, performance observation, `SourceMode`, and Canvas themes.
+Rust APIs, Worker protocol v4, adapter ABI v3, wire DTOs, batch layout v1, and
 `/experimental` remain experimental/private.
 
-No `v0.1.0` tag is created until every release gate and registry/OIDC
-precondition passes. npm and crates.io publishing is serialized behind protected
-GitHub Environments with required reviewer approval. See
+The `v0.1.0` tag is immutable and must never be moved or reused. npm and
+crates.io publishing is serialized behind protected GitHub Environments with
+required reviewer approval; recovery finalizes artifacts without republishing.
+See
 [docs/releasing.md](docs/releasing.md) for the immutable-release and patch
 recovery policy.
 
@@ -247,10 +329,11 @@ recovery policy.
 ```text
 src/                         shared Rust model, protocol, and native adapters
 crates/tabulark-*-wasm/      four independently built WASM entry crates
-js/                          stable API, private Worker host, batches, and view
+js/                          stable API, HTTP/range broker, private Worker host,
+                             batches, and view
 examples/csv-preview/        static six-format Playground
 test/fixtures/               pinned format fixtures and provenance
-test/browser/                Chromium, accessibility, visual, and Pages smoke
+test/browser/                three-browser behavior, Chromium visual/performance, and Pages smoke
 test/performance/            performance and per-artifact delivery budgets
 docs/                        architecture, testing, stability, and release policy
 ```

package/dist/client.d.ts

@@ -1,10 +1,23 @@
 import { TabularkError } from "./errors.js";
 import { type AdapterDescriptor, type OfficialAdapterId } from "./adapters.js";
-import { type RangeRequest, type PresentationRange, type TablePresentation, type TableBatch, type TableDescriptor, type TableMetadata } from "./model.js";
+import { type RangeRequest, type PresentationRange, type TablePresentation, type TableBatch, type TableCapabilities, type TableDescriptor, type TableMetadata } from "./model.js";
+import { type OfficialSourceAccess } from "./official-adapter-manifest.js";
+import { type SourceMode } from "./source.js";
+import { type RangeSource } from "./range-source.js";
+export type { SourceMode } from "./source.js";
+export type { ByteRange, RangeSource, RangeSourceReader, RangeSourceSnapshot, } from "./range-source.js";
 export interface OpenSourceOptions<Options = unknown> {
     /** One of the official descriptors registered when the engine was created. */
     readonly adapter: AdapterDescriptor<OfficialAdapterId, Options>;
     readonly adapterOptions?: Options;
+    /**
+     * Selects the bounded default source path or the local Blob path that may
+     * address files up to 2 GiB. Defaults to `auto`.
+     *
+     * Large mode is reserved for local `File`/`Blob` inputs and never changes
+     * ArrayBuffer staging limits.
+     */
+    readonly sourceMode?: SourceMode;
     /** Detaches an ArrayBuffer input. Defaults to false; Blob input cannot be transferred. */
     readonly transferInput?: boolean;
     /** Cancels opening and releases any Worker-side source created by the request. */
@@ -31,8 +44,57 @@ export interface SourceWarning {
     readonly handle: string;
     readonly kind: string;
     readonly message: string;
+    readonly tableId?: string;
+    readonly resource?: string;
+    readonly requiredBytes?: number;
+    readonly availableBytes?: number;
     readonly byteOffset?: number;
+    /** Compatible alias used by structured diagnostics. */
+    readonly sourceOffset?: number;
+    readonly row?: number;
+    readonly column?: number;
+}
+/** A safe, structured source or runtime diagnostic. */
+export interface TabularkDiagnostic {
+    readonly code: string;
+    readonly severity: "warning" | "error";
+    readonly message: string;
+    readonly recoverable: boolean;
+    readonly resource?: string;
+    readonly requiredBytes?: number;
+    readonly availableBytes?: number;
+    readonly sourceOffset?: number;
+    readonly tableId?: string;
+    readonly revision?: number;
     readonly row?: number;
+    readonly column?: number;
+}
+/** Logical capabilities of an opened dataset. */
+export interface DatasetCapabilities {
+    readonly adapterId: OfficialAdapterId;
+    readonly sourceAccess: OfficialSourceAccess;
+    readonly progressive: boolean;
+    readonly maxSourceBytes: number;
+    readonly multiTable: boolean;
+    readonly presentation: boolean;
+    readonly typedValues: boolean;
+}
+/** Optional, privacy-preserving operation timing sample. */
+export interface PerformanceSample {
+    /** Logical operation stage; implementation and transport names are omitted. */
+    readonly stage: string;
+    /** Elapsed duration relative to the operation start, in milliseconds. */
+    readonly durationMs: number;
+    /** Bytes read from the source during this stage, when known. */
+    readonly bytesRead: number;
+    /** Whether the result came from a retained range cache. */
+    readonly cacheHit: boolean;
+    /** Peak reservation observed by the host, when known. */
+    readonly peakReservationBytes: number;
+    /** Number of provider range reads represented by this operation. */
+    readonly sourceReads: number;
+    /** Bytes served from the Worker source-range cache. */
+    readonly sourceCacheHitBytes: number;
 }
 export type DatasetEvent = Readonly<{
     type: "progress";
@@ -57,6 +119,9 @@ export interface DatasetSession {
     readonly tables: readonly Readonly<TableDescriptor>[];
     openTable(tableId: string): Promise<TableHandle>;
     subscribe(listener: (event: DatasetEvent) => void): Unsubscribe;
+    getDiagnostics(): readonly TabularkDiagnostic[];
+    subscribeDiagnostics(listener: (diagnostic: TabularkDiagnostic) => void): Unsubscribe;
+    getCapabilities(): Readonly<DatasetCapabilities>;
     close(): Promise<void>;
 }
 export interface TableHandle {
@@ -65,10 +130,14 @@ export interface TableHandle {
     readPresentationRange(request: RangeRequest, options?: ReadRangeOptions): Promise<PresentationRange | null>;
     readRange(request: RangeRequest, options?: ReadRangeOptions): Promise<TableBatch>;
     subscribe(listener: (event: TableEvent) => void): Unsubscribe;
+    getDiagnostics(): readonly TabularkDiagnostic[];
+    subscribeDiagnostics(listener: (diagnostic: TabularkDiagnostic) => void): Unsubscribe;
+    getCapabilities(): Readonly<TableCapabilities>;
     close(): Promise<void>;
 }
 export interface TabularkEngine {
-    open<Options>(source: Blob | ArrayBuffer, options: OpenSourceOptions<Options>): Promise<DatasetSession>;
+    open<Options>(source: Blob | ArrayBuffer | RangeSource, options: OpenSourceOptions<Options>): Promise<DatasetSession>;
+    subscribePerformance(listener: (sample: PerformanceSample) => void): Unsubscribe;
     close(): Promise<void>;
     dispose(): Promise<void>;
 }

package/dist/errors.d.ts

@@ -1,5 +1,11 @@
 import type { SerializedError } from "./protocol.js";
-export type TabularkErrorCode = "INVALID_ARGUMENT" | "INVALID_RANGE" | "RANGE_NOT_INDEXED" | "RESOURCE_LIMIT" | "CANCELLED" | "HANDLE_CLOSED" | "PROTOCOL_INCOMPATIBLE" | "PARSE_FAILED" | "UNSUPPORTED_FEATURE" | "UNSUPPORTED_RUNTIME" | "RUNTIME_FAILURE" | (string & {});
+export type TabularkErrorCode = "INVALID_ARGUMENT" | "INVALID_RANGE" | "RANGE_NOT_INDEXED" | "RESOURCE_LIMIT" | "CANCELLED" | "HANDLE_CLOSED" | "PROTOCOL_INCOMPATIBLE" | "PARSE_FAILED" | "UNSUPPORTED_FEATURE" | "UNSUPPORTED_RUNTIME" | "RUNTIME_FAILURE"
+/** A remote/source provider could not be reached or did not return bytes. */
+ | "SOURCE_UNAVAILABLE"
+/** The provider validator or total length changed while a reader was open. */
+ | "SOURCE_CHANGED"
+/** The provider did not honor the required single-range protocol. */
+ | "RANGE_UNSUPPORTED" | (string & {});
 /** A stable, serializable error returned by Tabulark. */
 export declare class TabularkError extends Error {
     readonly code: TabularkErrorCode;