colbin 0.0.0-stage → 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Angulo Reyna
+
+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,207 @@
-# Temporary Holding Version
+# colbin
 
-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.
+A columnar binary format for the JSON a backend actually sends: lists of
+records, all the same shape. The field names travel once, as a schema, instead
+of once per record; the values travel as columns, bit-packed.
+
+This package is the browser and Node client — a WebAssembly module compiled
+from the Rust implementation, and a small wrapper that turns its output into
+JavaScript objects **without JSON text in the middle**.
+
+```
+npm install colbin
+```
+
+## Quickstart
+
+```js
+import { Codec } from 'colbin'
+
+const codec = await Codec.open()           // compiles the module, once
+
+const response = await fetch('/api/products')
+const rows = codec.unmarshal(new Uint8Array(await response.arrayBuffer()))
+```
+
+`Codec.open()` is async because compiling WebAssembly is. Everything after it
+is synchronous: `unmarshal`, `marshal`, `columns` and the rest are straight
+runs of wasm calls with no `await` in them.
+
+## The schema travels out of band
+
+The delivery the format is built for sends the schema **once per connection**
+and every message after it carries only its body:
+
+```js
+const codec = await Codec.open()
+codec.setSchema(section)                    // sent once, by whatever channel
+
+const rows = codec.unmarshal(message)       // every message after it
+```
+
+A message can also carry its own schema, for a file or a one-off response —
+that is what `marshal`'s `standalone` is, and `unmarshal` reads it with no
+`setSchema` call at all.
+
+## Writing
+
+```js
+const { message, section, standalone, warnings } = codec.marshal(rows)
+```
+
+`marshal` takes a value or JSON text. A string is handed to the encoder as it
+stands, which is the only way to carry an integer past 2^53 in: by the time it
+is a JavaScript `Number`, it has already been rounded.
+
+`standalone` is the same document with its section in front of it. It is
+composed on first read, not encoded a second time.
+
+Pass `{ verify: true }` to decode the message back and walk it against the
+input before it is returned. It costs about 65% on top of the encode and what
+it catches is a codec bug rather than a caller's mistake — worth having in a
+test suite, and in the first deployment of anything whose shapes are new.
+
+## The API
+
+| | |
+|---|---|
+| `Codec.open(opts?)` | compile + instantiate. `opts.module` takes a pre-compiled `WebAssembly.Module`, `opts.wasm` takes bytes, a `Response`, or a URL |
+| `Codec.fromModule(module)` | a second handle over a module compiled already — an instance, no compile |
+| `Codec.preload()` | start the compile without waiting for it |
+| `codec.unmarshal(bytes, opts?)` | **the headline** — objects, no JSON text when the shape allows it |
+| `codec.columns(bytes, opts?)` | the columns themselves, for a grid or a chart that never wants row objects. `null` when the message is not that shape |
+| `codec.toJSONText(bytes, opts?)` | the text path, for every shape |
+| `codec.marshal(value \| jsonText, opts?)` | `{ message, section, standalone, warnings }` |
+| `codec.setSchema(section \| null)` | hold a section for the messages that follow; `null` clears it |
+| `codec.inspect(bytes, opts?)` | the field tree, with a byte span on every node. Needs `colbin/inspect` — see below |
+| `codec.lastPath` | `'materialize'` or `'json'` — which path the last `unmarshal` took |
+| `codec.canInspect` | whether this handle's module has the span walk in it |
+| `unmarshal` / `columns` / `toJSONText` / `marshal` / `inspect` | the same, without holding a handle, each `await`ed |
+| `ColbinError` | `code`, `offset`, `line`, `path`, `message`, `warnings` |
+
+Every call that can fail throws a `ColbinError` carrying the module's whole
+diagnostic — the byte offset, the line for a failure in JSON text, and the path
+through the document. A *successful* `marshal` can still have something to say
+(an always-null column, a null where an object belongs), so warnings ride on
+the result rather than being thrown.
+
+## Two paths, and which one you got
+
+When the message is a table — a list of records, which is the shape this format
+is for — `unmarshal` never writes JSON text. The module hands over columns in a
+flat typed buffer and the objects are built in JavaScript from a generated,
+monomorphic row builder cached per schema.
+
+Anything else (a nested document, a heterogeneous list, a bare object) falls
+back to the JSON-text path automatically. `codec.lastPath` says which ran, so a
+caller can find out they are on the slower one without guessing.
+
+The fast path is also the one that is **exact past 2^53**: a column whose values
+do not fit a `Number` comes back as `bigint`, per column, using range
+information the column header already carries. The JSON fallback goes through
+`JSON.parse` and rounds like any other JSON reader would.
+
+Under a Content-Security-Policy without `unsafe-eval`, the generated row builder
+cannot be compiled. The package detects that once and falls back to a generic
+builder, which costs about ten times as much as the generated one and is still
+two orders of magnitude below the decode.
+
+## Numbers
+
+1000 product records, seven fields. Node 24 / V8, best of twelve runs, no
+network. `bun run bench` in this directory reproduces it.
+
+| | wire | gzipped |
+|---|---:|---:|
+| minified JSON | 106 670 B | 12 124 B |
+| colbin — 30 411 B of message, 64 B of section | **30 475 B** | **3 250 B** |
+
+The section is the 64 bytes, and it is sent once per connection rather than
+once per message.
+
+| | |
+|---|---:|
+| `codec.unmarshal` — objects in hand, no JSON text | **0.14 ms** |
+| `JSON.parse` of the same document, as a reference point | 0.26 ms |
+| `codec.toJSONText` | 0.20 ms |
+| `JSON.stringify` of the same document | 0.15 ms |
+| `codec.marshal` — parse, infer, build | 1.15 ms |
+| `codec.marshal` with `{ verify: true }` | 1.88 ms |
+
+The reference rows are there to calibrate the others, not as a bar the design
+had to clear. What the project optimises for is backend CPU, backend RAM and
+transfer size; client CPU is budget to spend in service of those.
+
+## Entry points
+
+| | |
+|---|---|
+| `colbin` | the module inline as base64. No bundler configuration, no runtime 404 mode |
+| `colbin` on Node | the `node` condition: reads `colbin.wasm` from beside the JavaScript |
+| `colbin/asset` | `new URL('./colbin.wasm', import.meta.url)` — Vite, webpack 5, Rollup and Parcel all emit it as an asset, and it works unbundled in a browser too |
+| `colbin/inspect` | the same, over the **other module**: the one built with `inspect`. See below |
+| `colbin/colbin.wasm` | the module file itself, for a build step that wants to place it |
+
+Measured, on the modules this version ships:
+
+| | raw | gzipped |
+|---|---:|---:|
+| `colbin.wasm` — what `colbin/asset` serves | 209 109 B | **84 195 B** |
+| the same module as inline base64 | 279 124 B | **114 271 B** |
+| `colbin.inspect.wasm` — what `colbin/inspect` serves | 224 199 B | 90 127 B |
+| the wrapper's own JavaScript, all entries | 36 085 B | 10 651 B |
+
+Inline costs **36% more over the wire** than the asset, gzipped. Base64 breaks
+the byte alignment gzip's matcher works on, so gzip recovers much less of the
+33% expansion than the raw ratio suggests. Inline is still the default because
+it needs no configuration and cannot 404; a page that cares about the transfer
+should import `colbin/asset`, or hand `Codec.open` its own source:
+
+```js
+const codec = await Codec.open({ wasm: fetch('/colbin.wasm') })
+```
+
+### `inspect` is a separate module
+
+`codec.inspect()` — the field tree with a byte span on every node — is the one
+thing here that only a tool wants: something that *draws* the bytes rather than
+reads them. It is 15 KB of module, and it used to be in the module everybody
+downloaded.
+
+So it is not. `colbin` and `colbin/asset` carry the build without it, and
+`colbin/inspect` carries the build with it:
+
+```js
+import { Codec } from 'colbin/inspect'
+
+const codec = await Codec.open()
+const report = codec.inspect(message, { section })   // fields, with byte spans
+```
+
+`codec.canInspect` says which build a handle is over, and calling `inspect()`
+on one that cannot throws an error naming the entry that can, rather than
+failing as `inspect_message is not a function` several frames away.
+
+Both modules go through `wasm-opt -O3`, which is worth 12% of the raw bytes and
+4% gzipped over what `cargo` emits, and costs nothing measurable in throughput.
+
+## Version pinning
+
+> colbin 0.x makes no wire-compatibility promise across minor versions. A Go
+> service on 0.3 and a browser on 0.2 will not interoperate, and the failure
+> will look like corrupt data rather than a version error. Pin both.
+
+One tag drives all three implementations: `v0.1.0` publishes `colbin@0.1.0`, and
+is the Go module tag and the Rust crate version. Compatibility while on `0.x` is
+by matching **minor** version.
+
+## What this does not do
+
+No streaming — the ABI is bytes in, bytes out, and allocates the whole input.
+No worker wrapper: decoding off the main thread is your choice, and shipping one
+would mean owning a message protocol. No types generated from the schema. The
+column fast path covers tables; deeply nested or heterogeneous documents go
+through the JSON-text path, which is correct but slower.
+
+MIT. Source, format notes and the Go and Rust implementations:
+<https://github.com/ivanjoz/colbin>.

package/dist/asset.d.ts

@@ -0,0 +1,11 @@
+import { Codec as CodecClass } from './core.ts';
+export * from './shared.ts';
+/** Where the module is, as the bundler resolved it. Exported so a caller can
+ * prefetch it, or hand it to a service worker to cache. */
+export declare const wasmURL: URL;
+/** The handle. See `colbin`'s README for the shape. */
+export declare const Codec: import("./core.ts").CodecEntry;
+/** The same name as a type, for `let codec: Codec`. */
+export type Codec = CodecClass;
+export declare const unmarshal: (message: Uint8Array, options?: import("./core.ts").UnmarshalOptions) => Promise<unknown>, columns: (message: Uint8Array, options?: import("./core.ts").DecodeOptions) => Promise<import("./materialize.ts").ColumnTable | null>, toJSONText: (message: Uint8Array, options?: import("./core.ts").DecodeOptions) => Promise<string>, marshal: (value: unknown, options?: import("./core.ts").MarshalOptions) => Promise<import("./core.ts").Marshaled>, inspect: (message: Uint8Array, options?: import("./core.ts").DecodeOptions) => Promise<import("./core.ts").Report>;
+//# sourceMappingURL=asset.d.ts.map

package/dist/asset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset.d.ts","sourceRoot":"","sources":["../src/asset.ts"],"names":[],"mappings":"AAYA,OAAO,EAAyB,KAAK,IAAI,UAAU,EAAmB,MAAM,WAAW,CAAA;AAEvF,cAAc,aAAa,CAAA;AAE3B;2DAC2D;AAC3D,eAAO,MAAM,OAAO,KAA4C,CAAA;AAMhE,uDAAuD;AACvD,eAAO,MAAM,KAAK,gCAAoB,CAAA;AAEtC,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,UAAU,CAAA;AAE9B,eAAO,MAAQ,SAAS,6FAAE,OAAO,gIAAE,UAAU,yFAAE,OAAO,4GAAE,OAAO,2GAAuB,CAAA"}

package/dist/asset.js

@@ -0,0 +1,23 @@
+// `colbin/asset` — the module as a file the bundler emits, not as base64.
+//
+// `new URL('./colbin.wasm', import.meta.url)` is the one spelling Vite,
+// webpack 5, Rollup and Parcel all understand natively: each of them rewrites
+// it to the hashed asset it emitted, and none of them needs a plugin or a
+// loader rule to do it. Unbundled in a browser it is simply a relative URL, so
+// the same file works from a plain `<script type="module">`.
+//
+// The cost against the default entry is a second request; the saving is that
+// the module is not parsed as JavaScript and is cached by the browser as the
+// `application/wasm` it is, which is what lets `compileStreaming` run.
+import { codecFor, convenience, Codec as CodecClass } from "./core.js";
+export * from "./shared.js";
+/** Where the module is, as the bundler resolved it. Exported so a caller can
+ * prefetch it, or hand it to a service worker to cache. */
+export const wasmURL = new URL('./colbin.wasm', import.meta.url);
+function fetched() {
+    return fetch(wasmURL);
+}
+/** The handle. See `colbin`'s README for the shape. */
+export const Codec = codecFor(fetched);
+export const { unmarshal, columns, toJSONText, marshal, inspect } = convenience(Codec);
+//# sourceMappingURL=asset.js.map

package/dist/asset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset.js","sourceRoot":"","sources":["../src/asset.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,EAAE;AACF,wEAAwE;AACxE,8EAA8E;AAC9E,0EAA0E;AAC1E,+EAA+E;AAC/E,6DAA6D;AAC7D,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,uEAAuE;AAEvE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,IAAI,UAAU,EAAmB,MAAM,WAAW,CAAA;AAEvF,cAAc,aAAa,CAAA;AAE3B;2DAC2D;AAC3D,MAAM,CAAC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AAEhE,SAAS,OAAO;IACd,OAAO,KAAK,CAAC,OAAO,CAAC,CAAA;AACvB,CAAC;AAED,uDAAuD;AACvD,MAAM,CAAC,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;AAKtC,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,CAAA"}

package/dist/core.d.ts

@@ -0,0 +1,199 @@
+import { type ColumnTable, type ReadRowsOptions } from './materialize.ts';
+/**
+ * Anything `Codec.open` can turn into a compiled module.
+ *
+ * A `Response` (or a promise of one, which is what `fetch(...)` is before it is
+ * awaited) takes the streaming path; bytes are compiled directly; a `URL` or a
+ * URL string is fetched first.
+ */
+export type WasmSource = WebAssembly.Module | BufferSource | Response | URL | string | Promise<WebAssembly.Module | BufferSource | Response>;
+export type OpenOptions = {
+    /** A module compiled already — by a service worker, a bundler plugin, or a
+     * previous `Codec.open()`. Skips every fetch and every compile. */
+    module?: WebAssembly.Module;
+    /** Where to get the module from, when it is not the entry's own default. */
+    wasm?: WasmSource;
+};
+/** One node of the field tree: a field, a table's column, or a list's element. */
+export type Field = {
+    name: string;
+    key: number;
+    /** The wire shape — `int64`, `string`, `[]struct`, `float64 column`. */
+    type: string;
+    /** A pointer field: the format's "absent, rather than zero". */
+    optional: boolean;
+    /** Absolute offsets into the message, so a hex view needs no arithmetic. */
+    start: number;
+    end: number;
+    bytes: number;
+    children: Field[];
+};
+/** What `codec.inspect` returns: the message, described. */
+export type Report = {
+    totalBytes: number;
+    /** The schema section, when the message carries one. Zero out of band. */
+    schemaBytes: number;
+    bodyBytes: number;
+    rootBytes: number;
+    /** Whether the run uses eight-bit keys, which costs a byte per present field. */
+    wide: boolean;
+    /** The row count of the root's list or table, or 1 for a lone record. */
+    rows: number;
+    /** Whether the document was wrapped, because its top level was not an object. */
+    envelope: boolean;
+    fields: Field[];
+};
+/** A message and the schema section that describes it. */
+export type Marshaled = {
+    /** The body. Carries no schema: send `section` once per connection. */
+    message: Uint8Array;
+    /** The schema for `message`, for the out-of-band delivery. */
+    section: Uint8Array;
+    /** The same document with its section in front of it — what a file with
+     * nowhere else to put a schema needs. Composed on first read rather than
+     * encoded a second time. */
+    readonly standalone: Uint8Array;
+    /** A successful encode can still have something to say: an always-null
+     * column, a null where an object belongs. */
+    warnings: string[];
+};
+export type MarshalOptions = {
+    /**
+     * Decode the message that was just built and walk it against the input
+     * before handing it back, failing rather than returning bytes that do not
+     * read back. Off by default: it costs about 70% on top of the encode, and
+     * what it catches is a codec bug rather than a
+     * caller's mistake. Worth turning on in a test suite, and in the first
+     * deployment of anything whose shapes are new.
+     */
+    verify?: boolean;
+};
+export type UnmarshalOptions = ReadRowsOptions & {
+    /** The schema for this message alone, in place of the held one. Does not
+     * replace what {@link Codec.setSchema} holds. */
+    section?: Uint8Array;
+};
+export type DecodeOptions = {
+    /** The schema for this message alone, in place of the held one. */
+    section?: Uint8Array;
+};
+/** Which path a call took. `materialize` never writes JSON text; `json` is the
+ * fallback for anything that is not the table shape INTERNALS.md §16.3 covers. */
+export type Path = 'materialize' | 'json';
+/**
+ * The handle. One WebAssembly instance, the schema it holds, and the module's
+ * whole surface.
+ *
+ * Construct it with `Codec.open()` from whichever entry point suits — `colbin`
+ * carries the module inline, `colbin/asset` resolves it as a URL beside
+ * itself.
+ */
+export declare class Codec {
+    #private;
+    private constructor();
+    /**
+     * Compiles the module and instantiates it. Async because compiling
+     * WebAssembly is; nothing after it is.
+     */
+    static open(options?: OpenOptions): Promise<Codec>;
+    /** A second handle over an already-compiled module — its own instance, its
+     * own schema, no compile. */
+    static fromModule(module: WebAssembly.Module): Codec;
+    /**
+     * Holds a schema section for the messages that follow — the delivery the
+     * format recommends, where the section is sent once per connection and every
+     * message after it carries only its body. `null` clears it.
+     *
+     * A self-describing message ignores this and uses its own.
+     */
+    setSchema(section: Uint8Array | null): void;
+    /** Which path the last {@link unmarshal} took: a caller that wants to know
+     * it landed on the slow one should not have to guess. */
+    get lastPath(): Path;
+    /**
+     * A message to real objects, without JSON text in the middle when the shape
+     * allows it.
+     *
+     * The fast path is the one that is exact past 2^53: a column whose values do
+     * not fit a `Number` comes back as `bigint`, where the JSON fallback goes
+     * through `JSON.parse` and rounds like any other JSON reader would.
+     * {@link lastPath} says which ran.
+     */
+    unmarshal(message: Uint8Array, options?: UnmarshalOptions): unknown;
+    /**
+     * The columns themselves, for a caller feeding a grid or a chart that never
+     * wants row objects — it skips even the 7 µs the row build costs.
+     *
+     * Returns `null` when the message is not the table shape the fast path covers, since
+     * there is no honest column view of a nested document; such a caller should
+     * fall back to {@link unmarshal}.
+     */
+    columns(message: Uint8Array, options?: DecodeOptions): ColumnTable | null;
+    /** A message back to JSON text. Every shape, and the only path for the ones
+     * {@link unmarshal} reports as `json`. */
+    toJSONText(message: Uint8Array, options?: DecodeOptions): string;
+    /**
+     * A value or JSON text to a colbin message.
+     *
+     * A string is taken as JSON text and handed to the module as it stands;
+     * anything else goes through `JSON.stringify` first — which means an integer
+     * past 2^53 must arrive as text, since by the time it is a JavaScript
+     * `Number` it has already been rounded.
+     */
+    marshal(value: unknown, options?: MarshalOptions): Marshaled;
+    /**
+     * The field tree of a message, with every node's byte span — absolute
+     * offsets into the bytes handed in, so a hex view needs no arithmetic.
+     *
+     * Needs a module built with the `inspect` feature, which is **not** the one
+     * `colbin` and `colbin/asset` carry: the span walk is 15 KB that nothing but
+     * a tool drawing the bytes ever calls, so it has a module of its own behind
+     * `colbin/inspect`.
+     */
+    inspect(message: Uint8Array, options?: DecodeOptions): Report;
+    /** Whether this handle's module can {@link inspect} — i.e. whether it came
+     * from `colbin/inspect` or another build with the feature on. */
+    get canInspect(): boolean;
+    /** Whether this handle's module carries the fast path. True of every build
+     * this package ships; false only for a module a caller supplied. */
+    get canMaterialize(): boolean;
+    /** The flag the encoder needs to write a document that carries its own
+     * schema, for a caller composing `encode` flags directly. */
+    static get SELF_DESCRIBING(): number;
+}
+/**
+ * The `Codec` an entry point exports: `open()` with the entry's own way of
+ * finding the module already wired in, overridable per call.
+ *
+ * Compiled once per entry and cached, so a page that opens a second handle
+ * pays for an instance and not for a compile.
+ */
+export declare function codecFor(source: () => WasmSource): CodecEntry;
+export type CodecEntry = {
+    /** Compile (once per entry) and instantiate. */
+    open(options?: OpenOptions): Promise<Codec>;
+    /** A handle over a module compiled already — no fetch, no compile. */
+    fromModule(module: WebAssembly.Module): Codec;
+    /** Start the compile without waiting for it, so the first real call is not
+     * the one that pays for it. Failures are deliberately swallowed — `open`
+     * will surface the same one. */
+    preload(): void;
+};
+/**
+ * The free functions each entry re-exports — `unmarshal(bytes)` without
+ * holding a handle, for the caller who has one message to read and no
+ * connection to hold a schema for.
+ *
+ * They share one lazily-opened codec rather than opening a fresh one per call:
+ * a fresh instance per message is what the handle exists to avoid, and none of these
+ * hold a schema across calls, so there is nothing for the sharing to leak.
+ */
+export declare function convenience(entry: CodecEntry): Convenience;
+export type Convenience = {
+    unmarshal(message: Uint8Array, options?: UnmarshalOptions): Promise<unknown>;
+    columns(message: Uint8Array, options?: DecodeOptions): Promise<ColumnTable | null>;
+    toJSONText(message: Uint8Array, options?: DecodeOptions): Promise<string>;
+    marshal(value: unknown, options?: MarshalOptions): Promise<Marshaled>;
+    inspect(message: Uint8Array, options?: DecodeOptions): Promise<Report>;
+};
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

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