@human-synthesis/norns-tron 0.0.1 → 0.0.3

package/README.md

@@ -12,9 +12,9 @@ The encoder/decoder core is absorbed from the `apitron` research library; this
 package adds the Norns framework glue as subpath exports.
 
 ```
-@human-synthesis/norns-tron           encode / decode / defineSchema / registry
+@human-synthesis/norns-tron           encode / decode / defineSchema / registry / columnar
 @human-synthesis/norns-tron/server    tronSerializer() for norns route()
-@human-synthesis/norns-tron/client    api fetch wrapper that speaks TRON
+@human-synthesis/norns-tron/client    createApi() fetch wrapper that speaks TRON
 @human-synthesis/norns-tron/valibot   derive wire schemas from valibot schemas
 ```
 
@@ -38,8 +38,9 @@ line to roll the whole thing back.
 Per-route control:
 
 ```coffee
-export GET  := route serializer: tronSerializer({ schema: noteWire }), handler: ...
-export POST := route serializer: null, handler: ...   # force plain JSON
+export GET  := route serializer: tronSerializer({ schema: noteWire }), handler: ...   # schema mode
+export GET  := route serializer: tronSerializer({ columnar: true }), handler: ...     # numeric tables
+export POST := route serializer: null, handler: ...                                   # force plain JSON
 ```
 
 ## Call it from the client
@@ -52,12 +53,33 @@ await api.post '/api/notes', { title, body } # body goes out as TRON too
 
 # inside a load function, keep SvelteKit's fetch semantics:
 api := createApi { fetch }
+
+# endpoints served in schema mode tag the wire; hand the client the contracts:
+api := createApi { schemas: [noteWire, userWire] }   # or a createRegistry()
 ```
 
+Responses are decoded by content type: self-describing TRON on its own,
+tagged schema-mode documents (`#notes.v1`) through the matching compiled
+schema, JSON as JSON. A tag with no registered schema throws instead of
+handing you positional arrays. Non-2xx responses throw `ApiError` with the
+decoded body (`status`, `body.message`, `body.issues` from a `route()` 400).
+
 The 1.7 KB WASM scanner ships embedded as base64 — no asset wiring, works in
 Node, Bun, and the browser. Under a strict CSP without `unsafe-eval` the
 decoder transparently falls back to the JS scanner (~1.1–1.5x).
 
+## Where it pays off
+
+| Payload | Mode | Why |
+|---|---|---|
+| Paged / sorted tables (`DataTable`, admin lists) | schema (`tronSerializer({ schema })` + `createApi({ schemas })`) | no shape on the wire, row constructor compiled once; pairs with norns `listQuery()` / `listResult()` and norns-ui `useList()` |
+| Picker options (`Autocomplete` / `MultiSelect` `source`) | default | small responses ship as JSON automatically; TRON kicks in past ~1 KB |
+| Charts, aggregations, exports of numbers | columnar (`tronSerializer({ columnar: true })` + `api.tape()`) | decodes into one `Float64Array`, ~3x faster than `JSON.parse`, no row objects |
+| Agent / LLM-facing reads (search results, indexes) | self-describing (`tronSerializer()`) | a cold reader gets the declarations in-band; 26–61% fewer tokens on tabular data |
+| Cached lists on Workers (`route({ cache: { ttl } })`) | any | the encoded body is stored per `Accept` variant, so encode runs once per TTL and clients revalidate with `ETag` |
+
+The [norns-demo](https://github.com/human-synthesis/norns-demo) has one page per row under `/examples/tron`.
+
 ## Schema mode — the fastest path for internal endpoints
 
 Both ends already know the shape from the feature contract, so nothing
@@ -80,7 +102,30 @@ export noteWire := tronSchemaFromValibot noteSchema, { id: 'notes.v1', path: '$.
 `picklist`/`enum` fields become dictionary columns (integers on the wire),
 booleans become 0/1. Compile once at module scope — never per request.
 The `#notes.v1` tag makes version mismatches fail loudly instead of
-misdecoding; use `createRegistry()` on a client that consumes several shapes.
+misdecoding; use `createRegistry()` (or the `schemas` array) on a client that
+consumes several shapes. Derivation is for flat object schemas; nested rows
+still work through the self-describing mode.
+
+## Columnar mode — numbers without objects
+
+For a table whose values are all numbers (or dictionary-able strings /
+booleans), skip row objects entirely:
+
+```coffee
+# server
+export GET := route
+  serializer: tronSerializer({ columnar: true })
+  cache: { ttl: 30 }
+  handler: ({ container }) => stats(container).perDay()   # [{ day, count, chars }, …]
+
+# client
+{ fields, rows, cols, tape } := await api.tape '/api/stats'
+count := tape[i * cols + fields.indexOf('count')]
+```
+
+`api.tape()` always returns the same `{ fields, rows, cols, tape }` shape:
+the WASM fast path when the server answered columnar TRON, and a packed
+fallback (`tableFromRows`) when it answered JSON or WASM is unavailable.
 
 ## Semantics and limits
 
@@ -89,19 +134,21 @@ misdecoding; use `createRegistry()` on a client that consumes several shapes.
   serialize as `{}` and `BigInt` throws, exactly like `JSON.stringify`; dev
   mode logs a warning when a route returns them.
 - **Not for `load` / form actions** — SvelteKit serializes those with devalue
-  (which preserves Dates, Maps, Sets). This package targets `route()`
-  endpoints, LLM-facing output, and service-to-service payloads.
+  (which preserves Dates, Maps, Sets) and only dispatches form-encoded POSTs
+  to actions. This package targets `route()` endpoints, LLM-facing output,
+  and service-to-service payloads; norns-ui's `Form` has an API mode
+  (`submit`) for posting through `api.post()`.
 - Payloads under ~1 KB are emitted as plain JSON automatically (still decoded
   transparently) — below that size TRON's fixed costs don't pay for themselves.
 - The wire content type is `application/tron`, not `application/json`: a TRON
   body may carry a declaration preamble that is not valid JSON.
-- Schema mode uses `new Function` for the row constructor (server-side this is
-  a non-issue; in CSP-restricted browsers the fallback scanner takes over).
+- Schema mode uses `new Function` for the row constructor where allowed and a
+  closure fallback elsewhere (Cloudflare Workers, CSP-restricted browsers).
 
 ## Development
 
 ```sh
-bun test              # 38 tests: core roundtrips, Date regression, server/client glue, valibot derivation
+bun test              # 50 tests: core roundtrips, Date regression, server/client glue, schema registry, columnar tape, valibot derivation
 bun run embed-wasm    # regenerate src/core/wasm-bytes.js after replacing wasm/parserTron2.wasm
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@human-synthesis/norns-tron",
-	"version": "0.0.1",
+	"version": "0.0.3",
 	"description": "TRON serialization for the Norns ecosystem — token-efficient, faster-than-JSON wire format for APIs and LLM-facing output.",
 	"license": "MIT",
 	"author": "Daniel Teodoroiu (https://humansynthesis.ai)",

package/src/client.d.ts

@@ -1,3 +1,5 @@
+import type { ColumnarResult, CompiledSchema, SchemaRegistry } from './index.js';
+
 export const TRON_CONTENT_TYPE: 'application/tron';
 
 export class ApiError extends Error {
@@ -6,8 +8,17 @@ export class ApiError extends Error {
 	response: Response;
 }
 
+/** Compiled schemas (from defineSchema / tronSchemaFromValibot) or a createRegistry() registry. */
+export type Schemas = CompiledSchema[] | SchemaRegistry;
+
+/** Decode a TRON/JSON body; tagged schema-mode documents need `schemas`. */
+export function decodeText(text: string, schemas?: Schemas): unknown;
+
 /** Decode a Response by its content-type (TRON, JSON, or raw text). */
-export function parseResponse(res: Response): Promise<unknown>;
+export function parseResponse(res: Response, schemas?: Schemas): Promise<unknown>;
+
+/** Pack row objects into the `{fields, rows, cols, tape}` shape decodeColumnar returns. */
+export function tableFromRows(rows: Array<Record<string, unknown>>, fields?: string[]): ColumnarResult;
 
 export interface ApiDefaults {
 	/** fetch impl — pass SvelteKit's `fetch` inside load functions. */
@@ -16,12 +27,21 @@ export interface ApiDefaults {
 	base?: string;
 	/** Headers sent on every request. */
 	headers?: Record<string, string>;
+	/** Contracts for endpoints served with `tronSerializer({ schema })`. */
+	schemas?: Schemas;
 }
 
 export interface RequestOptions {
 	fetch?: typeof fetch;
 	headers?: Record<string, string>;
 	init?: RequestInit;
+	/** Per-call override of the schemas given to createApi. */
+	schemas?: Schemas;
+}
+
+export interface TapeOptions extends RequestOptions {
+	/** Column order when the server answered with row objects instead of a columnar body. */
+	fields?: string[];
 }
 
 export interface Api {
@@ -31,6 +51,8 @@ export interface Api {
 	post(url: string, body?: unknown, opts?: RequestOptions): Promise<any>;
 	put(url: string, body?: unknown, opts?: RequestOptions): Promise<any>;
 	patch(url: string, body?: unknown, opts?: RequestOptions): Promise<any>;
+	/** GET a numeric table as a flat Float64Array (see `tronSerializer({ columnar: true })`). */
+	tape(url: string, opts?: TapeOptions): Promise<ColumnarResult>;
 }
 
 export function createApi(defaults?: ApiDefaults): Api;

package/src/client.js

@@ -9,11 +9,20 @@
  * de-duplication keep working:
  *   const api = createApi({ fetch });
  *
+ * Endpoints served in SCHEMA mode (`tronSerializer({ schema })`) tag the wire
+ * with `#id` and carry no shape declarations, so the client must know the
+ * contract too. Hand the compiled schemas (or a registry) to createApi and
+ * responses are routed to the right decoder by their tag:
+ *   const api = createApi({ schemas: [noteWire, userWire] });
+ *
+ * Numeric tables served with `tronSerializer({ columnar: true })` can be read
+ * straight into a Float64Array with `api.tape(url)` — no row objects at all.
+ *
  * The WASM scanner ships embedded (~2.3 KB base64) and initializes lazily, so
  * no asset wiring is needed in the browser. Under a strict CSP without
  * `unsafe-eval` the decoder transparently falls back to the JS scanner.
  */
-import { decode, encode } from './index.js';
+import { decode, decodeColumnar, encode } from './index.js';
 
 export const TRON_CONTENT_TYPE = 'application/tron';
 const ACCEPT = 'application/tron, application/json;q=0.9, */*;q=0.1';
@@ -33,25 +42,98 @@ export class ApiError extends Error {
 	}
 }
 
-/** Decode a Response by its content-type (TRON, JSON, or raw text). */
-export async function parseResponse(res) {
-	if (res.status === 204) return null;
+/**
+ * Normalize the `schemas` option into something with `decode(text)` that
+ * routes by the `#id` tag: a registry from createRegistry(), or an array of
+ * compiled schemas from defineSchema() / tronSchemaFromValibot().
+ */
+function toRegistry(schemas) {
+	if (!schemas) return null;
+	if (typeof schemas.decode === 'function' && !Array.isArray(schemas)) return schemas;
+	const byId = new Map();
+	for (const s of schemas) {
+		if (!s || typeof s.decode !== 'function') throw new Error('createApi: `schemas` must contain compiled schemas (defineSchema / tronSchemaFromValibot)');
+		if (s.id) byId.set(s.id, s);
+	}
+	return {
+		decode(text) {
+			const nl = text.indexOf('\n');
+			const id = text.slice(1, nl === -1 ? text.length : nl);
+			const s = byId.get(id);
+			if (!s) throw new Error(`unknown schema id "${id}" — register it via createApi({ schemas })`);
+			return s.decode(text);
+		}
+	};
+}
+
+/**
+ * Decode a TRON (or JSON) body. Tagged schema-mode documents (`#id\n…`) need
+ * the matching compiled schema; pass a registry or the array given to
+ * createApi. Untagged documents are self-describing and decode on their own.
+ *
+ * @param {string} text
+ * @param {any} [schemas]
+ */
+export function decodeText(text, schemas) {
+	if (text.charCodeAt(0) === 35 /* # */) {
+		const registry = toRegistry(schemas);
+		if (!registry) {
+			const nl = text.indexOf('\n');
+			throw new Error(`response is schema-tagged (${text.slice(0, nl === -1 ? 40 : nl)}) but no schemas were given to createApi()`);
+		}
+		return registry.decode(text);
+	}
+	return decode(text);
+}
+
+/**
+ * Decode a Response by its content-type (TRON, JSON, or raw text).
+ * @param {Response} res
+ * @param {any} [schemas] compiled schemas / registry for tagged TRON bodies
+ */
+export async function parseResponse(res, schemas) {
+	if (res.status === 204 || res.status === 304) return null;
 	const type = res.headers.get('content-type')?.split(';', 1)[0]?.trim() ?? '';
 	const text = await res.text();
 	if (text === '') return null;
-	if (type === TRON_CONTENT_TYPE) return decode(text);
+	if (type === TRON_CONTENT_TYPE) return decodeText(text, schemas);
 	if (type === 'application/json' || type.endsWith('+json')) return JSON.parse(text);
 	return text;
 }
 
+/**
+ * Row objects -> the same `{fields, rows, cols, tape}` shape decodeColumnar
+ * returns. Used when the server answered JSON (no Accept negotiation, small
+ * payload) or the WASM scanner is unavailable, so `api.tape()` has one shape.
+ *
+ * @param {Array<Record<string, unknown>>} rows
+ * @param {string[]} [fields] column order (default: keys of the first row)
+ */
+export function tableFromRows(rows, fields) {
+	if (!Array.isArray(rows) || rows.length === 0) {
+		return { fields: fields ?? [], rows: 0, cols: fields?.length ?? 0, tape: new Float64Array(0) };
+	}
+	const f = fields ?? Object.keys(rows[0]);
+	const cols = f.length;
+	const tape = new Float64Array(rows.length * cols);
+	for (let i = 0; i < rows.length; i++) {
+		const r = rows[i];
+		for (let k = 0; k < cols; k++) tape[i * cols + k] = Number(r[f[k]]);
+	}
+	return { fields: f, rows: rows.length, cols, tape };
+}
+
 /**
  * @param {object} [defaults]
  * @param {typeof fetch} [defaults.fetch] fetch impl (pass SvelteKit's in load functions)
  * @param {string} [defaults.base] URL prefix, e.g. 'https://api.example.com'
  * @param {Record<string, string>} [defaults.headers] headers sent on every request
+ * @param {any} [defaults.schemas] compiled schemas (array) or a createRegistry()
+ *        registry, for endpoints served in schema mode
  */
 export function createApi(defaults = {}) {
 	const base = defaults.base ?? '';
+	const registry = toRegistry(defaults.schemas);
 
 	async function request(method, url, body, opts = {}) {
 		// Resolve fetch per call: in the browser `globalThis.fetch` must not be
@@ -67,18 +149,44 @@ export function createApi(defaults = {}) {
 			init.body = encode(body);
 		}
 		const res = await doFetch(base + url, init);
-		const parsed = await parseResponse(res);
+		const parsed = await parseResponse(res, opts.schemas ?? registry);
 		if (!res.ok) throw new ApiError(res.status, parsed, res);
 		return parsed;
 	}
 
+	/**
+	 * GET a numeric table as a flat Float64Array tape. Fast path: the server
+	 * used `tronSerializer({ columnar: true })` and WASM is available. Fallback:
+	 * decode rows and pack them, so callers always get the same shape.
+	 */
+	async function tape(url, opts = {}) {
+		const doFetch = opts.fetch ?? defaults.fetch ?? globalThis.fetch;
+		const headers = { accept: ACCEPT, ...defaults.headers, ...opts.headers };
+		const res = await doFetch(base + url, { method: 'GET', headers, ...opts.init });
+		const type = res.headers.get('content-type')?.split(';', 1)[0]?.trim() ?? '';
+		const text = await res.text();
+		if (!res.ok) {
+			let parsed = text;
+			try { parsed = type === TRON_CONTENT_TYPE ? decodeText(text, registry) : JSON.parse(text); } catch { /* keep text */ }
+			throw new ApiError(res.status, parsed, res);
+		}
+		if (text === '') return tableFromRows([], opts.fields);
+		if (type === TRON_CONTENT_TYPE) {
+			const col = decodeColumnar(text, true);
+			if (col) return col;
+			return tableFromRows(decodeText(text, registry), opts.fields);
+		}
+		return tableFromRows(JSON.parse(text), opts.fields);
+	}
+
 	return {
 		request,
 		get: (url, opts) => request('GET', url, undefined, opts),
 		del: (url, opts) => request('DELETE', url, undefined, opts),
 		post: (url, body, opts) => request('POST', url, body, opts),
 		put: (url, body, opts) => request('PUT', url, body, opts),
-		patch: (url, body, opts) => request('PATCH', url, body, opts)
+		patch: (url, body, opts) => request('PATCH', url, body, opts),
+		tape
 	};
 }
 

package/src/core/codegen.js

@@ -0,0 +1,120 @@
+// Row-constructor factories shared by every decoder.
+//
+// The compiled form (`new Function`) hands V8 a monomorphic object literal
+// `{k1:r[0],k2:r[1],...}` — one hidden-class allocation per row. Runtimes
+// that forbid code generation from strings (Cloudflare Workers, strict CSP)
+// throw an EvalError on the first `new Function`, so every call site goes
+// through here and falls back to an equivalent closure: same fields, same
+// order, same dictionary handling — only the allocation is a little slower.
+
+let codegenAllowed = null;
+
+// Probed once per isolate. `new Function` throws at construction time when
+// code generation is disallowed, which is exactly the signal we want.
+export function canCodegen() {
+  if (codegenAllowed === null) {
+    try { new Function('return 1')(); codegenAllowed = true; }
+    catch (e) { codegenAllowed = false; }
+  }
+  return codegenAllowed;
+}
+
+// ---- plain row constructor -------------------------------------------
+// Returns a factory `fac(D) -> ctor(r)` where D is the per-field dictionary
+// table (index -> value, or null for non-dictionary columns).
+//
+//   fields     ordered field names
+//   dictFlags  1 for dictionary columns, 0 otherwise
+//   offset     index of the first field inside the wire row (marker mode = 1)
+//   typed      when true, a dictionary column only dereferences NUMBERS and
+//              passes any other wire value through literally (schema mode:
+//              the encoder may emit an out-of-set string as-is)
+
+export function compiledRowCtorFactory(fields, dictFlags, offset, typed) {
+  let body = 'return function(r){return {';
+  for (let k = 0; k < fields.length; k++) {
+    if (k) body += ',';
+    const i = k + offset;
+    let src;
+    if (dictFlags[k] !== 1) src = 'r[' + i + ']';
+    else if (typed) src = '(typeof r[' + i + ']==="number"?D[' + k + '][r[' + i + ']]:r[' + i + '])';
+    else src = 'D[' + k + '][r[' + i + ']]';
+    body += JSON.stringify(fields[k]) + ':' + src;
+  }
+  body += '}}';
+  return new Function('D', body);
+}
+
+export function closureRowCtorFactory(fields, dictFlags, offset, typed) {
+  const nf = fields.length;
+  const names = fields.slice();
+  const flags = dictFlags.slice();
+  return function (D) {
+    return function (r) {
+      const o = {};
+      for (let k = 0; k < nf; k++) {
+        const v = r[k + offset];
+        o[names[k]] = flags[k] === 1 && (!typed || typeof v === 'number') ? D[k][v] : v;
+      }
+      return o;
+    };
+  };
+}
+
+export function rowCtorFactory(fields, dictFlags, offset, typed) {
+  return canCodegen()
+    ? compiledRowCtorFactory(fields, dictFlags, offset, typed)
+    : closureRowCtorFactory(fields, dictFlags, offset, typed);
+}
+
+// ---- lazy row class ---------------------------------------------------
+// simdjson "On Demand" style: the row keeps the raw wire array and exposes
+// one getter per field, plus toJSON() so JSON.stringify sees a plain object.
+
+export function compiledLazyClassFactory(fields, dictFlags, offset) {
+  let body = 'return class{constructor(r){this._r=r}';
+  for (let k = 0; k < fields.length; k++) {
+    const fname = JSON.stringify(fields[k]);
+    const expr = dictFlags[k] === 1
+      ? ('D[' + k + '][this._r[' + (k + offset) + ']]')
+      : ('this._r[' + (k + offset) + ']');
+    body += 'get ' + fname + '(){return ' + expr + '}';
+  }
+  body += 'toJSON(){return {';
+  for (let k = 0; k < fields.length; k++) {
+    if (k) body += ',';
+    body += JSON.stringify(fields[k]) + ':this[' + JSON.stringify(fields[k]) + ']';
+  }
+  body += '}}}';
+  return new Function('D', body);
+}
+
+export function closureLazyClassFactory(fields, dictFlags, offset) {
+  const nf = fields.length;
+  const names = fields.slice();
+  const flags = dictFlags.slice();
+  return function (D) {
+    class Row {
+      constructor(r) { this._r = r; }
+      toJSON() {
+        const o = {};
+        for (let k = 0; k < nf; k++) o[names[k]] = this[names[k]];
+        return o;
+      }
+    }
+    for (let k = 0; k < nf; k++) {
+      const i = k + offset;
+      const get = flags[k] === 1
+        ? function () { return D[k][this._r[i]]; }
+        : function () { return this._r[i]; };
+      Object.defineProperty(Row.prototype, names[k], { get, enumerable: true, configurable: true });
+    }
+    return Row;
+  };
+}
+
+export function lazyClassFactory(fields, dictFlags, offset) {
+  return canCodegen()
+    ? compiledLazyClassFactory(fields, dictFlags, offset)
+    : closureLazyClassFactory(fields, dictFlags, offset);
+}

package/src/core/tron-schema.js

@@ -1,3 +1,5 @@
+import { rowCtorFactory } from './codegen.js';
+
 // SCHEMA PRE-REGISTRATION — "preload, peek, process".
 //
 // In a real API the client already knows the response shape from the interface
@@ -106,19 +108,12 @@ function compile(spec) {
   }
   const anyDict = decTables.some(d => d !== null);
 
-  // ---- row constructor, compiled ONCE at startup rather than per request ----
+  // ---- row constructor, built ONCE at startup rather than per request ----
   // A dictionary column may still carry a literal string if the encoder saw a
-  // value outside the declared set, so those columns test the wire type.
-  let body = 'return function(r){return {';
-  for (let k = 0; k < nf; k++) {
-    if (k) body += ',';
-    const src = decTables[k] === null
-      ? 'r[' + k + ']'
-      : '(typeof r[' + k + ']==="number"?D[' + k + '][r[' + k + ']]:r[' + k + '])';
-    body += JSON.stringify(fields[k]) + ':' + src;
-  }
-  body += '}}';
-  const ctor = new Function('D', body)(decTables);
+  // value outside the declared set, so those columns test the wire type
+  // (`typed` mode). Compiled via new Function where allowed, closure elsewhere.
+  const dictFlags = decTables.map(d => (d === null ? 0 : 1));
+  const ctor = rowCtorFactory(fields, dictFlags, 0, true)(decTables);
 
   // navigate to the table's container; compiled to a straight-line walk
   function locate(root) {

package/src/core/tron-table.js

@@ -1,3 +1,5 @@
+import { rowCtorFactory } from './codegen.js';
+
 // TABLE MODE — transform-free decoding.
 //
 // Profiling the remaining losses showed the decoder was paying for text
@@ -95,13 +97,7 @@ function getCtor(fields, dictFlags, dicts) {
   const key = dictFlags.join('') + '|' + fields.join(',');
   let fac = ctorCache.get(key);
   if (!fac) {
-    let body = 'return function(r){return {';
-    for (let k = 0; k < fields.length; k++) {
-      if (k) body += ',';
-      body += JSON.stringify(fields[k]) + ':' + (dictFlags[k] === 1 ? ('D[' + k + '][r[' + k + ']]') : ('r[' + k + ']'));
-    }
-    body += '}}';
-    fac = new Function('D', body);
+    fac = rowCtorFactory(fields, dictFlags, 0, false);
     ctorCache.set(key, fac);
   }
   return fac(dicts);

package/src/core/tron-trampoline.js

@@ -24,10 +24,12 @@
 // Safe because canonical TRON escapes "(" and ")" inside strings (see encStr
 // in tron.js), so every raw paren in the document is structural.
 //
-// Caveats: needs new Function (CSP-restricted environments fall back to
-// parseFast); a literal U+0001 in the source falls back to the scanner.
+// Caveats: row constructors are compiled with new Function when the runtime
+// allows it and built as closures otherwise (Cloudflare Workers, strict CSP —
+// see codegen.js); a literal U+0001 in the source falls back to the scanner.
 
 import { parsePrelude, parseFast, applyTables } from './tron.js';
+import { rowCtorFactory, lazyClassFactory } from './codegen.js';
 
 const MARK = '\u0001';
 const MARK_ESC = '\\u0001'; // the 6-character JSON escape, not the raw char
@@ -48,14 +50,7 @@ function getCtorFactory(fields, dictFlags, offset) {
   const key = offset + '|' + dictFlags.join('') + '|' + fields.join(',');
   let fac = ctorFactoryCache.get(key);
   if (fac) return fac;
-  let body = 'return function(r){return {';
-  for (let k = 0; k < fields.length; k++) {
-    if (k) body += ',';
-    body += JSON.stringify(fields[k]) + ':';
-    body += dictFlags[k] === 1 ? ('D[' + k + '][r[' + (k + offset) + ']]') : ('r[' + (k + offset) + ']');
-  }
-  body += '}}';
-  fac = new Function('D', body);
+  fac = rowCtorFactory(fields, dictFlags, offset, false);
   ctorFactoryCache.set(key, fac);
   return fac;
 }
@@ -77,21 +72,7 @@ function getLazyClass(fields, dictFlags, offset) {
   const key = offset + '|' + dictFlags.join('') + '|' + fields.join(',');
   let fac = lazyClassCache.get(key);
   if (fac) return fac;
-  let body = 'return class{constructor(r){this._r=r}';
-  for (let k = 0; k < fields.length; k++) {
-    const fname = JSON.stringify(fields[k]);
-    const expr = dictFlags[k] === 1
-      ? ('D[' + k + '][this._r[' + (k + offset) + ']]')
-      : ('this._r[' + (k + offset) + ']');
-    body += 'get ' + fname + '(){return ' + expr + '}';
-  }
-  body += 'toJSON(){return {';
-  for (let k = 0; k < fields.length; k++) {
-    if (k) body += ',';
-    body += JSON.stringify(fields[k]) + ':this[' + JSON.stringify(fields[k]) + ']';
-  }
-  body += '}}}';
-  fac = new Function('D', body);
+  fac = lazyClassFactory(fields, dictFlags, offset);
   lazyClassCache.set(key, fac);
   return fac;
 }

package/src/core/tron.js

@@ -1,3 +1,5 @@
+import { rowCtorFactory } from './codegen.js';
+
 // TRON — Token Reduced Object Notation (interpretation of the documented format).
 // A superset of JSON that adds class declarations + positional instantiation:
 //
@@ -141,13 +143,7 @@ function _tblCtor(fields, dictFlags, dicts) {
   const key = dictFlags.join('') + '|' + fields.join(',');
   let fac = _tblCtorCache.get(key);
   if (!fac) {
-    let body = 'return function(r){return {';
-    for (let k = 0; k < fields.length; k++) {
-      if (k) body += ',';
-      body += JSON.stringify(fields[k]) + ':' + (dictFlags[k] === 1 ? ('D[' + k + '][r[' + k + ']]') : ('r[' + k + ']'));
-    }
-    body += '}}';
-    fac = new Function('D', body);
+    fac = rowCtorFactory(fields, dictFlags, 0, false);
     _tblCtorCache.set(key, fac);
   }
   return fac(dicts);

package/src/server.d.ts

@@ -13,6 +13,12 @@ export interface Serializer {
 export interface TronSerializerOptions extends EncodeOptions {
 	/** Compiled schema from defineSchema() — skips shape detection (fastest mode). */
 	schema?: CompiledSchema;
+	/**
+	 * Emit the columnar form `api.tape()` / `decodeColumnar()` read into a
+	 * Float64Array. The handler must return a root array of flat numeric rows.
+	 * Mutually exclusive with `schema`.
+	 */
+	columnar?: boolean;
 }
 
 /** Build a serializer for norns route() / setSerializer() / boot({ serializer }). */

package/src/server.js

@@ -10,13 +10,14 @@
  * Per-route override / opt-out:
  *   export const POST = route({ serializer: null, handler });          // plain JSON
  *   export const GET  = route({ serializer: tronSerializer({ schema }), handler });
+ *   export const GET  = route({ serializer: tronSerializer({ columnar: true }), handler });
  *
  * The serializer only kicks in when the client asked for TRON via the Accept
  * header, so curl, third parties and existing consumers keep getting JSON.
  * Plain JSON is valid TRON, so clients may also send TRON request bodies
  * unconditionally — `parseBody` reads both.
  */
-import { encode, decode } from './index.js';
+import { encode, encodeColumnar, decode } from './index.js';
 
 export const TRON_CONTENT_TYPE = 'application/tron';
 
@@ -62,20 +63,29 @@ function devWarn(value, path) {
  * @param {object} [opts]
  * @param {{encode:Function, decode:Function}} [opts.schema] compiled schema from
  *        defineSchema() — skips shape detection entirely (fastest mode)
+ * @param {boolean} [opts.columnar] emit the form `decodeColumnar` / `api.tape()`
+ *        can read into a Float64Array. The handler must return a root array of
+ *        flat rows whose values are all numbers (or dictionary-able strings /
+ *        booleans). Anything else still round-trips, just through the object path.
  * @param {number}  [opts.minBytes] below this JSON size, emit plain JSON (default 1024)
  * @param {boolean} [opts.dict]     dictionary-encode low-cardinality columns (default true)
  * @param {boolean|'nested'} [opts.table] emit table declarations (default true)
  * @returns {{serialize: Function, parseBody: Function}}
  */
 export function tronSerializer(opts = {}) {
-	const { schema, ...encodeOpts } = opts;
+	const { schema, columnar, ...encodeOpts } = opts;
+	if (schema && columnar) throw new Error('tronSerializer: `schema` and `columnar` are mutually exclusive');
 	return {
 		/** @returns {Response|null} null = fall through to json() */
 		serialize(result, event) {
 			if (!acceptsTron(event.request)) return null;
 			const value = result ?? null;
 			if (DEV) devWarn(value, event.url?.pathname ?? '$');
-			const body = schema ? schema.encode(value) : encode(value, encodeOpts);
+			const body = schema
+				? schema.encode(value)
+				: columnar
+					? encodeColumnar(value, { minBytes: encodeOpts.minBytes, force: encodeOpts.force })
+					: encode(value, encodeOpts);
 			return new Response(body, {
 				headers: { 'content-type': TRON_CONTENT_TYPE }
 			});