@human-synthesis/norns-tron 0.0.1

package/src/core/wasm-bytes.js

@@ -0,0 +1,4 @@
+// GENERATED by scripts/embed-wasm.mjs — do not edit by hand.
+// Source: wasm/parserTron2.wasm (1720 bytes).
+export const WASM_BASE64 =
+	'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';

package/src/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * APITRON — TRON encoder/decoder for LLM-oriented APIs.
+ */
+
+export interface EncodeOptions {
+  /**
+   * Below this many bytes of equivalent JSON, encode() returns plain JSON
+   * instead — under ~1 KB the fixed costs dominate and TRON is both slower and
+   * no smaller. decode() reads plain JSON transparently. Default: 1024.
+   * Set to 0 to always encode as TRON.
+   */
+  minBytes?: number;
+  /** Dictionary-encode low-cardinality string/boolean columns. Default: true. */
+  dict?: boolean;
+  /**
+   * Emit `table` declarations so decoding needs no text transform.
+   * `true`  — flat uniform rows only (faster AND fewer tokens: always a win).
+   * `'nested'` — also table-ify rows containing nested objects/arrays: faster
+   *   still, but the inner shapes lose their own compression, so tokens can get
+   *   worse. Opt in deliberately.
+   * Default: true.
+   */
+  table?: boolean | 'nested';
+  /** Skip the minBytes check entirely. */
+  force?: boolean;
+}
+
+export interface SchemaSpec {
+  /** Optional version tag, emitted as a `#id` line and used by the registry. */
+  id?: string;
+  /** Field names, in the exact order rows are serialized. */
+  fields: string[];
+  /**
+   * Per-field dictionaries. Values must be strings or booleans — numeric enum
+   * values are rejected because they are ambiguous with dictionary indices.
+   */
+  enums?: Record<string, Array<string | boolean>>;
+  /** Where the row array lives: `'$'` (root) or e.g. `'$.data'`. Default `'$'`. */
+  path?: string;
+}
+
+export interface CompiledSchema {
+  encode(value: unknown): string;
+  decode(text: string): unknown;
+  /** Read the `#id` tag without parsing the body. Returns null when untagged. */
+  peek(text: string): string | null;
+  readonly fields: string[];
+  readonly id: string | null;
+}
+
+export interface SchemaRegistry {
+  register(spec: SchemaSpec): CompiledSchema;
+  get(id: string): CompiledSchema | undefined;
+  /** PEEK the `#id` tag, then decode with the matching schema. */
+  decode(text: string): unknown;
+}
+
+export interface ColumnarResult {
+  fields: string[];
+  rows: number;
+  cols: number;
+  /** Row-major, length = rows * cols. */
+  tape: Float64Array;
+}
+
+/** Encode as self-describing TRON (or plain JSON when under `minBytes`). */
+export function encode(value: unknown, opts?: EncodeOptions): string;
+
+/** Decode any TRON document, including plain JSON. */
+export function decode(text: string): unknown;
+
+/**
+ * Encode specifically for `decodeColumnar`. The default `encode()` emits table
+ * declarations, which the WASM scanner cannot take; this emits the form it can.
+ */
+export function encodeColumnar(value: unknown, opts?: { minBytes?: number; force?: boolean }): string;
+
+/**
+ * Decode a numeric/dictionary table to a flat Float64Array, or undefined.
+ * The payload must come from `encodeColumnar()`.
+ */
+export function decodeColumnar(text: string, copy?: boolean): ColumnarResult | undefined;
+
+/** PRELOAD: compile a schema once at startup from your interface contract. */
+export function defineSchema(spec: SchemaSpec): CompiledSchema;
+
+/** A registry for services serving several response shapes. */
+export function createRegistry(): SchemaRegistry;
+
+/** True when the WASM fast path is usable here. */
+export function wasmAvailable(): boolean;
+
+/** Supply the WASM binary yourself (browsers, bundlers, Deno). */
+export function setWasmBinary(bytes: ArrayBuffer | Uint8Array): void;
+
+export const raw: {
+  stringify(value: unknown, opts?: EncodeOptions): string;
+  parse(text: string): unknown;
+  parseFast(text: string): unknown;
+  parsePrelude(text: string): {
+    classes: Record<string, { f: string[]; d: Array<Array<string | boolean> | null> }>;
+    tables: Array<{ cls: string; path: string }>;
+    end: number;
+  };
+};

package/src/index.js

@@ -0,0 +1,165 @@
+/**
+ * norns-tron — TRON encoder/decoder for LLM-oriented APIs.
+ * Core absorbed from the apitron research library (same authors).
+ *
+ * Two modes:
+ *
+ *   1. SELF-DESCRIBING — encode(value) / decode(wire)
+ *      The payload carries its own declarations, so any consumer can read it
+ *      cold (an LLM, a third party). Use for prompts and public responses.
+ *
+ *   2. SCHEMA-PRELOADED — defineSchema(spec) -> { encode, decode }
+ *      Both ends share an interface contract, so nothing describing the shape
+ *      travels on the wire and the row constructor is compiled once at startup.
+ *      Fastest on every axis. Use for internal APIs.
+ *
+ * Zero runtime dependencies. WASM is optional and loaded lazily.
+ */
+
+import * as TRON from './core/tron.js';
+import * as ENCODER from './core/tron-encode.js';
+import * as AUTO from './core/tron-auto.js';
+import * as SCHEMA from './core/tron-schema.js';
+import * as WASM from './core/tron-wasm.js';
+
+// Below this many bytes of equivalent JSON, the fixed costs of shape detection
+// dominate and plain JSON is simply faster and no smaller. Measured crossover
+// is ~1 KB for size and ~5 KB for decode; 1 KB is the conservative default.
+const DEFAULT_MIN_BYTES = 1024;
+
+/**
+ * Encode a value as self-describing TRON.
+ *
+ * Falls back to plain JSON for payloads under `minBytes` — decode() reads that
+ * transparently, since a document with no declarations is just JSON.
+ *
+ * @param {*} value
+ * @param {{minBytes?:number, dict?:boolean, table?:boolean|'nested', force?:boolean}} [opts]
+ * @returns {string}
+ */
+function encode(value, opts) {
+  const o = opts || {};
+  const minBytes = o.minBytes === undefined ? DEFAULT_MIN_BYTES : o.minBytes;
+  if (!o.force && minBytes > 0) {
+    const json = JSON.stringify(value);
+    if (json === undefined) return 'null';
+    if (json.length < minBytes) return json;       // too small to be worth it
+  }
+  return ENCODER.stringify(value, {
+    dict: o.dict === undefined ? true : o.dict,
+    table: o.table === undefined ? true : o.table,
+  });
+}
+
+/**
+ * Decode any TRON document — including plain JSON, which is valid TRON.
+ * Picks the fastest safe strategy automatically.
+ * @param {string} text
+ * @returns {*}
+ */
+function decode(text) {
+  return AUTO.decode(text);
+}
+
+/**
+ * Encode specifically for `decodeColumnar`.
+ *
+ * The default `encode()` emits `table` declarations, which makes the body plain
+ * JSON — great for the object path, but the WASM scanner looks for the `Ck(...)`
+ * row syntax and will not accept it. This helper emits the form the columnar
+ * decoder can actually take (dictionaries on, table declarations off).
+ *
+ * Use it only when the consumer calls `decodeColumnar`; for everything else
+ * `encode()` is the better default.
+ *
+ * @param {*} value
+ * @param {{minBytes?:number, force?:boolean}} [opts]
+ * @returns {string}
+ */
+function encodeColumnar(value, opts) {
+  const o = opts || {};
+  return encode(value, {
+    minBytes: o.minBytes,
+    force: o.force === undefined ? true : o.force,
+    dict: true,
+    table: false,
+  });
+}
+
+/**
+ * Decode an all-numeric (or fully dictionary-encoded) table into a flat
+ * Float64Array instead of JS objects.
+ *
+ * This is the fastest decode path — ~3x faster than JSON.parse — but the caller
+ * must be able to work columnar.
+ *
+ * NOTE: the payload must come from `encodeColumnar()`. Output of the default
+ * `encode()` is NOT eligible (it emits table declarations, which the WASM
+ * scanner does not accept) and this returns undefined for it.
+ *
+ * @param {string} text
+ * @param {boolean} [copy] copy the tape out of WASM memory (it is otherwise
+ *        invalidated by the next decode call)
+ * @returns {{fields:string[], rows:number, cols:number, tape:Float64Array}|undefined}
+ */
+function decodeColumnar(text, copy) {
+  return AUTO.decodeColumnar(text, copy);
+}
+
+/**
+ * PRELOAD — compile a schema once, at startup, from your interface contract.
+ *
+ *   const users = defineSchema({
+ *     id:     'users.v1',                       // optional #tag for routing
+ *     fields: ['id', 'name', 'role', 'score'],  // exact order matters
+ *     enums:  { role: ['admin', 'user'] },      // strings/booleans only
+ *     path:   '$.data',                         // '$' = root array
+ *   });
+ *
+ * @param {{id?:string, fields:string[], enums?:Object, path?:string}} spec
+ * @returns {{encode:Function, decode:Function, peek:Function, fields:string[], id:?string}}
+ */
+function defineSchema(spec) {
+  return SCHEMA.compile(spec);
+}
+
+/**
+ * A registry for services serving several response shapes. PEEK routes a
+ * document to its schema by its `#id` tag without parsing the body.
+ */
+function createRegistry() {
+  return SCHEMA.createRegistry();
+}
+
+/** True when the WASM fast path is usable in this environment. */
+function wasmAvailable() {
+  try { return AUTO.wasmAvailable(); } catch (e) { return false; }
+}
+
+/**
+ * Supply the WASM binary yourself (browsers, bundlers, Deno).
+ * @param {ArrayBuffer|Uint8Array} bytes contents of wasm/parserTron2.wasm
+ */
+function setWasmBinary(bytes) {
+  WASM.setWasmBinary(bytes);
+}
+
+// Lower-level entry points, for when you want to bypass the dispatcher.
+const raw = {
+  stringify: ENCODER.stringify,   // always encodes, no size threshold
+  parse: TRON.parse,              // tolerant scanner (accepts whitespace, unquoted keys)
+  parseFast: TRON.parseFast,      // strict scanner, no `new Function` needed
+  parsePrelude: TRON.parsePrelude,
+};
+
+export {
+  encode,
+  decode,
+  encodeColumnar,
+  decodeColumnar,
+  defineSchema,
+  createRegistry,
+  wasmAvailable,
+  setWasmBinary,
+  raw,
+};

package/src/server.d.ts

@@ -0,0 +1,19 @@
+import type { CompiledSchema, EncodeOptions } from './index.js';
+
+export const TRON_CONTENT_TYPE: 'application/tron';
+
+/** True when the request's Accept header asks for TRON. */
+export function acceptsTron(request: Request): boolean;
+
+export interface Serializer {
+	serialize(result: unknown, event: { request: Request; url?: URL }): Response | null;
+	parseBody(request: Request, contentType: string): Promise<unknown> | undefined;
+}
+
+export interface TronSerializerOptions extends EncodeOptions {
+	/** Compiled schema from defineSchema() — skips shape detection (fastest mode). */
+	schema?: CompiledSchema;
+}
+
+/** Build a serializer for norns route() / setSerializer() / boot({ serializer }). */
+export function tronSerializer(opts?: TronSerializerOptions): Serializer;

package/src/server.js

@@ -0,0 +1,99 @@
+/**
+ * Server glue for Norns `route()`.
+ *
+ * Usage (app-wide):
+ *   // src/hooks.server.c (or wherever boot() runs)
+ *   import { setSerializer } from '@human-synthesis/norns/server';
+ *   import { tronSerializer } from '@human-synthesis/norns-tron/server';
+ *   setSerializer(tronSerializer());
+ *
+ * Per-route override / opt-out:
+ *   export const POST = route({ serializer: null, handler });          // plain JSON
+ *   export const GET  = route({ serializer: tronSerializer({ schema }), 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';
+
+export const TRON_CONTENT_TYPE = 'application/tron';
+
+/** True when the request's Accept header asks for TRON. */
+export function acceptsTron(request) {
+	const accept = request.headers.get('accept');
+	return accept !== null && accept.includes(TRON_CONTENT_TYPE);
+}
+
+const DEV = typeof process !== 'undefined' && process.env?.NODE_ENV !== 'production';
+const warned = new Set();
+
+// Cheap capped walk: Map/Set/BigInt silently degrade in any JSON-family
+// format (Map/Set -> {}, BigInt throws). json() has the same problem, but a
+// dev-time nudge here beats debugging a mangled payload. Dates are fine —
+// they encode as ISO strings, exactly like JSON.stringify.
+function devWarn(value, path) {
+	let budget = 200;
+	(function walk(v, p) {
+		if (budget-- <= 0 || v === null || typeof v !== 'object') {
+			if (typeof v === 'bigint' && !warned.has(p)) {
+				warned.add(p);
+				console.warn(`[norns-tron] ${p}: BigInt cannot be serialized (same as JSON) — convert to string/number`);
+			}
+			return;
+		}
+		if ((v instanceof Map || v instanceof Set) && !warned.has(p)) {
+			warned.add(p);
+			console.warn(`[norns-tron] ${p}: ${v.constructor.name} serializes as {} (same as JSON) — convert to array/object first`);
+			return;
+		}
+		if (Array.isArray(v)) {
+			for (let i = 0; i < v.length && budget > 0; i++) walk(v[i], p);
+			return;
+		}
+		for (const k of Object.keys(v)) { if (budget <= 0) break; walk(v[k], p + '.' + k); }
+	})(value, path);
+}
+
+/**
+ * Build a serializer for norns `route()` / `setSerializer()`.
+ *
+ * @param {object} [opts]
+ * @param {{encode:Function, decode:Function}} [opts.schema] compiled schema from
+ *        defineSchema() — skips shape detection entirely (fastest mode)
+ * @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;
+	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);
+			return new Response(body, {
+				headers: { 'content-type': TRON_CONTENT_TYPE }
+			});
+		},
+
+		/** @returns {Promise<any>|undefined} undefined = content type not handled */
+		parseBody(request, contentType) {
+			if (contentType !== TRON_CONTENT_TYPE) return undefined;
+			return request.text().then(
+				(text) => {
+					try {
+						return decode(text);
+					} catch {
+						return null; // schema validation then rejects, same as malformed JSON
+					}
+				},
+				() => null
+			);
+		}
+	};
+}

package/src/valibot.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledSchema, SchemaSpec } from './index.js';
+
+export interface DeriveOptions {
+	/** Version tag emitted as a `#id` line and used by createRegistry(). */
+	id?: string;
+	/** Where the row array lives: `'$'` (root) or e.g. `'$.data'`. */
+	path?: string;
+}
+
+/** Derive a plain TRON schema spec from a valibot v.object(...) schema. */
+export function tronSpecFromValibot(objectSchema: unknown, opts?: DeriveOptions): SchemaSpec;
+
+/** Derive and compile in one step. Call at module scope, never per request. */
+export function tronSchemaFromValibot(objectSchema: unknown, opts?: DeriveOptions): CompiledSchema;

package/src/valibot.js

@@ -0,0 +1,84 @@
+/**
+ * Derive a TRON schema spec from a valibot object schema, so the wire contract
+ * lives in one place — the feature's `shared/schema.c`.
+ *
+ *   // shared/schema.c
+ *   export noteSchema := v.object({ id: v.number(), title: v.string(),
+ *                                   status: v.picklist(['draft','published']) })
+ *   export noteWire := tronSchemaFromValibot(noteSchema, { id: 'notes.v1', path: '$.data' })
+ *
+ *   // server:  route({ serializer: tronSerializer({ schema: noteWire }), handler })
+ *   // client:  noteWire.decode(await res.text())
+ *
+ * Derivation rules:
+ *   - fields    = object entry names, in declaration order
+ *   - picklist  -> enum (string options only; numeric picklists are skipped —
+ *                 numbers are ambiguous with dictionary indices on the wire)
+ *   - enum      -> enum from its string values
+ *   - boolean   -> enum [false, true] (a boolean column as 0/1 on the wire)
+ *   - optional / nullable / nullish wrappers are unwrapped first
+ */
+import { defineSchema } from './index.js';
+
+function unwrap(schema) {
+	let s = schema;
+	while (s && (s.type === 'optional' || s.type === 'nullable' || s.type === 'nullish' || s.type === 'non_optional' || s.type === 'non_nullable' || s.type === 'non_nullish')) {
+		s = s.wrapped;
+	}
+	return s;
+}
+
+function enumValues(schema) {
+	const s = unwrap(schema);
+	if (!s) return null;
+	if (s.type === 'picklist' && Array.isArray(s.options)) {
+		return s.options.every((o) => typeof o === 'string') ? s.options.slice() : null;
+	}
+	if (s.type === 'enum' && s.enum && typeof s.enum === 'object') {
+		const vals = Object.values(s.enum).filter((v) => typeof v === 'string');
+		return vals.length > 0 ? vals : null;
+	}
+	if (s.type === 'boolean') return [false, true];
+	if (s.type === 'literal' && (typeof s.literal === 'string' || typeof s.literal === 'boolean')) {
+		return [s.literal];
+	}
+	return null;
+}
+
+/**
+ * Derive the plain spec — useful when you want to tweak it before compiling.
+ *
+ * @param {any} objectSchema a valibot v.object(...) schema
+ * @param {{id?: string, path?: string}} [opts]
+ * @returns {{id?: string, fields: string[], enums?: Record<string, any[]>, path?: string}}
+ */
+export function tronSpecFromValibot(objectSchema, opts = {}) {
+	const s = unwrap(objectSchema);
+	if (!s || s.type !== 'object' || !s.entries) {
+		throw new Error('tronSpecFromValibot: expected a valibot object schema (got ' + (s?.type ?? typeof objectSchema) + ')');
+	}
+	const fields = Object.keys(s.entries);
+	/** @type {Record<string, any[]>} */
+	const enums = {};
+	let any = false;
+	for (const f of fields) {
+		const vals = enumValues(s.entries[f]);
+		if (vals) { enums[f] = vals; any = true; }
+	}
+	const spec = { fields };
+	if (any) spec.enums = enums;
+	if (opts.id) spec.id = opts.id;
+	if (opts.path) spec.path = opts.path;
+	return spec;
+}
+
+/**
+ * Derive and compile in one step (defineSchema is a startup-time cost — call
+ * this at module scope, never per request).
+ *
+ * @param {any} objectSchema a valibot v.object(...) schema
+ * @param {{id?: string, path?: string}} [opts]
+ */
+export function tronSchemaFromValibot(objectSchema, opts = {}) {
+	return defineSchema(tronSpecFromValibot(objectSchema, opts));
+}