@routier/core 0.4.0 → 0.6.0

package/dist/transfer/index.js

@@ -0,0 +1,872 @@
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Ai: () => (/* reexport */ isTransferCodecSupported),
+  WZ: () => (/* reexport */ isTransferJsonError),
+  sg: () => (/* reexport */ transferEncodingFor),
+  E5: () => (/* reexport */ assertTransferVersion),
+  YA: () => (/* reexport */ nullByteLength),
+  iT: () => (/* reexport */ /* inlined export .CHUNK_ROWS */ (4096)),
+  wN: () => (/* reexport */ clearDecoderCache),
+  FG: () => (/* reexport */ /* inlined export .TRANSFER_VERSION */ (1)),
+  rq: () => (/* reexport */ assertColumnLayout),
+  yl: () => (/* reexport */ rawStorageTransferTypes),
+  fY: () => (/* reexport */ buildTransferPlan),
+  WQ: () => (/* reexport */ decodeChunk),
+  Im: () => (/* reexport */ ChunkEncoder),
+  ze: () => (/* reexport */ parsedValueTransferTypes)
+});
+
+;// CONCATENATED MODULE: ./src/transfer/types.ts
+/**
+ * The wire format for query results crossing an in-process worker boundary.
+ *
+ * `postMessage` with no transfer list structured-clones everything, and a clone of a large row
+ * array is paid twice — once serialising in the worker, once deserialising on the main thread,
+ * where it blocks. Columnar typed arrays are transferred instead: the buffer changes owner and
+ * nothing is copied.
+ *
+ * Nothing here knows about SQL, schemas, or workers. A column's values go in and
+ * `{ payload, transferables }` comes out; the caller owns the transport. A transport with no
+ * transfer list may ignore the array — the payload then clones correctly on its own.
+ */ /**
+ * The COMPLETE layout: chunk size, bitmap semantics, JSON joining, and the framing above.
+ *
+ * Both sides reject a version they do not know rather than guessing. The worker ships as its own
+ * bundle, so the two halves can be built from different sources.
+ */ const TRANSFER_VERSION = 1;
+/**
+ * Rows per chunk.
+ *
+ * Chunking is what lets the main thread decode chunk *k* while the worker fills *k+1*, so the
+ * first rows arrive in about 2ms at any result size instead of after the whole clone. Measured
+ * best at 4,096: 8,192 is within noise, 25,000 is measurably worse.
+ */ const CHUNK_ROWS = 4096;
+/** Bytes of null bitmap for `rowCount` rows: one bit per row, LSB-first. */ const nullByteLength = (rowCount)=>rowCount + 7 >> 3;
+/**
+ * Rejects a version this build cannot read.
+ *
+ * Never attempt to decode an unknown version. Every field's meaning is version-scoped, so a
+ * layout that merely looks close would be read wrongly and silently.
+ */ const assertTransferVersion = (version)=>{
+    if (version !== TRANSFER_VERSION) {
+        throw new Error(`transfer codec version ${version} is not supported`);
+    }
+};
+/**
+ * Rejects a plan that does not describe the result the engine is about to produce.
+ *
+ * OPTIONAL, for an engine that can report the fields of a result before yielding rows. Encoding
+ * against a wrong layout would put each field's values under another field's name and report
+ * nothing, so a caller that CAN check should. An engine whose records are heterogeneous has
+ * nothing to check against and skips it — the plan decides the result shape there.
+ *
+ * Checked once per result, never per row.
+ */ const assertColumnLayout = (plan, names)=>{
+    const planned = plan.columns.map((column)=>column.name);
+    const matches = planned.length === names.length && planned.every((name, index)=>name === names[index]);
+    if (matches === false) {
+        throw new Error(`The transfer plan does not match the result columns. ` + `Plan: [${planned.join(', ')}]. Result: [${names.join(', ')}].`);
+    }
+};
+
+;// CONCATENATED MODULE: ./src/transfer/fillers.ts
+
+const NULL_BYTES = nullByteLength(/* inlined export .CHUNK_ROWS */ (4096));
+/**
+ * Epoch milliseconds for any shape an engine returns a date in, or `null` for anything else.
+ *
+ * An invalid `Date` and an unparseable string both answer `null` rather than writing `NaN`: a
+ * date that cannot be represented is a value this encoding has no answer for, and the column
+ * falls back so the raw value survives.
+ */ const toEpoch = (value)=>{
+    if (value instanceof Date) {
+        const epoch = value.getTime();
+        return Number.isNaN(epoch) ? null : epoch;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+};
+class TypedFiller {
+    data;
+    nulls;
+    constructor(){
+        this.data = this.allocate();
+        this.nulls = new Uint8Array(NULL_BYTES);
+    }
+    set(index, value) {
+        if (value == null) {
+            this.nulls[index >> 3] |= 1 << (index & 7);
+            this.data[index] = 0;
+            return true;
+        }
+        return this.write(index, value);
+    }
+    drain(count) {
+        const values = new Array(count);
+        for(let i = 0; i < count; i++){
+            const isNull = (this.nulls[i >> 3] & 1 << (i & 7)) !== 0;
+            values[i] = isNull ? null : this.raw(i);
+        }
+        return values;
+    }
+    emit(rowCount, transferables) {
+        // `subarray` would not do: transfer moves the whole underlying buffer, so a short final
+        // chunk has to be copied to its exact size. A full chunk is already exact.
+        const data = rowCount === /* inlined export .CHUNK_ROWS */ (4096) ? this.data : this.data.slice(0, rowCount);
+        const nulls = rowCount === /* inlined export .CHUNK_ROWS */ (4096) ? this.nulls : this.nulls.slice(0, nullByteLength(rowCount));
+        transferables.push(data.buffer, nulls.buffer);
+        return {
+            encoding: this.encoding,
+            data,
+            nulls
+        };
+    }
+    reset() {
+        this.data = this.allocate();
+        this.nulls = new Uint8Array(NULL_BYTES);
+    }
+}
+/**
+ * Numbers, including `NaN` and the infinities — those are legitimate JS numbers and pass through.
+ *
+ * No `BigInt64Array`. Routier only ever writes JS numbers, so `Float64Array` round-trips
+ * everything it stored; a `bigint` or a wide integer type can only come from something else, and
+ * that column falls back rather than losing precision silently.
+ */ class Float64Filler extends TypedFiller {
+    encoding = 'float64';
+    allocate() {
+        return new Float64Array(/* inlined export .CHUNK_ROWS */ (4096));
+    }
+    write(index, value) {
+        if (typeof value !== 'number') {
+            return false;
+        }
+        this.data[index] = value;
+        return true;
+    }
+    raw(index) {
+        return this.data[index];
+    }
+}
+/**
+ * Epoch milliseconds, whatever shape the engine returned the date in.
+ *
+ * All three shapes are accepted because engines genuinely differ: one that stores a date as text
+ * returns a string, one that parses before returning gives a `Date`, and one that stores a
+ * timestamp gives a number. Requiring text would silently drop the whole encoding for every
+ * engine of the other two kinds — they would fall back to `clone` on every row.
+ *
+ * The final entity shape needs a `Date` either way, so converting here means the wire carries
+ * eight bytes and the main thread builds the `Date` from them.
+ */ class DateFiller extends TypedFiller {
+    encoding = 'date-f64';
+    allocate() {
+        return new Float64Array(/* inlined export .CHUNK_ROWS */ (4096));
+    }
+    write(index, value) {
+        const epoch = toEpoch(value);
+        if (epoch == null) {
+            return false;
+        }
+        this.data[index] = epoch;
+        return true;
+    }
+    /**
+     * A `Date`, not the epoch number.
+     *
+     * A fallback column is decoded raw, and the rows already written can no longer produce their
+     * ISO text. A `Date` is what the decoder would have emitted for them, and it is also what
+     * the existing date deserializer passes through untouched — an epoch number would reach the
+     * entity as a number.
+     */ raw(index) {
+        return new Date(this.data[index]);
+    }
+}
+/**
+ * 0/1 bytes.
+ *
+ * Both shapes are accepted: an engine with no boolean type returns 0 or 1, one with a boolean
+ * type returns a boolean. Requiring either would drop the encoding entirely for engines of the
+ * other kind. Both decode to `true`/`false`, so the result is identical.
+ */ class BooleanFiller extends TypedFiller {
+    encoding = 'boolean-byte';
+    allocate() {
+        return new Uint8Array(/* inlined export .CHUNK_ROWS */ (4096));
+    }
+    write(index, value) {
+        if (value === 0 || value === 1) {
+            this.data[index] = value;
+            return true;
+        }
+        if (typeof value !== 'boolean') {
+            return false;
+        }
+        this.data[index] = value ? 1 : 0;
+        return true;
+    }
+    raw(index) {
+        return this.data[index];
+    }
+}
+/**
+ * JSON text, joined into one document per chunk so the main thread parses once per column
+ * instead of once per row.
+ *
+ * The join is valid because each element is a complete JSON document and `null` is valid JSON.
+ * The text is NOT validated here; that would be the second parse this exists to avoid. Text that
+ * is not JSON poisons the chunk's document and the decoder reports it (see `decodeChunk`).
+ */ class JsonFiller {
+    toText;
+    fromText;
+    encoding = 'json';
+    texts = [];
+    /**
+     * Which rows were null, so a fallback to `clone` can carry `null` rather than the text
+     * `'null'` the document holds. Sparse — only null rows are written.
+     */ nulls = [];
+    /**
+     * @param toText The JSON text for one non-null value, or `null` to send the column to
+     * `clone`. This is the whole difference between an engine that returns text and one that
+     * returns a live object.
+     * @param fromText Recovers the value the engine originally gave, for a fallback to `clone`.
+     * The stored text is all that is kept, so a filler whose input was NOT text has to reverse
+     * its own conversion — otherwise the rows written before the fallback would change type,
+     * coming back as text while every row after it comes back as an object.
+     */ constructor(toText, fromText){
+        this.toText = toText;
+        this.fromText = fromText;
+    }
+    set(index, value) {
+        if (value == null) {
+            this.texts[index] = 'null';
+            this.nulls[index] = true;
+            return true;
+        }
+        const text = this.toText(value);
+        if (text == null) {
+            return false;
+        }
+        this.texts[index] = text;
+        return true;
+    }
+    drain(count) {
+        const values = new Array(count);
+        for(let i = 0; i < count; i++){
+            values[i] = this.nulls[i] === true ? null : this.fromText(this.texts[i]);
+        }
+        return values;
+    }
+    emit(rowCount) {
+        // Joined with a single ',' and nothing else, which is the whole of the format.
+        const doc = `[${this.texts.slice(0, rowCount).join(',')}]`;
+        return {
+            encoding: this.encoding,
+            doc
+        };
+    }
+    reset() {
+        this.texts = [];
+        this.nulls = [];
+    }
+}
+/**
+ * Raw values in a plain array, structured-cloned as they are.
+ *
+ * Strings live here and are never encoded. `TextEncoder` loses to clone by a wide margin —
+ * 14.0ms against 8.3ms for 4,000 rows of 2KB text — because cloning a V8 string is a native
+ * memcpy.
+ */ class CloneFiller {
+    encoding = 'clone';
+    data;
+    constructor(seed = []){
+        this.data = seed;
+    }
+    set(index, value) {
+        this.data[index] = value;
+        return true;
+    }
+    drain(count) {
+        return this.data.slice(0, count);
+    }
+    emit(rowCount) {
+        return {
+            encoding: this.encoding,
+            data: this.data.slice(0, rowCount)
+        };
+    }
+    reset() {
+        this.data = [];
+    }
+}
+/** A value that is already JSON text is passed straight through; anything else is not text. */ const asJsonText = (value)=>typeof value === 'string' ? value : null;
+/**
+ * A live value becomes text here.
+ *
+ * `JSON.stringify` throws on a circular structure and on a `bigint`, and returns `undefined` for
+ * a value that is not representable at all — a function, or a lone `undefined`. All three send the
+ * column to `clone`, which is the same answer every other filler gives a value it cannot encode.
+ */ const asStringifiedJson = (value)=>{
+    try {
+        return JSON.stringify(value) ?? null;
+    } catch  {
+        return null;
+    }
+};
+/**
+ * Back to a value, for a `json-stringify` column that fell back.
+ *
+ * The text came from `JSON.stringify` on this same value, so it parses. A `catch` returning the
+ * text is there only so a fallback — already the unhappy path — cannot throw.
+ */ const parseJsonText = (text)=>{
+    try {
+        return JSON.parse(text);
+    } catch  {
+        return text;
+    }
+};
+const FILLERS = {
+    'float64': ()=>new Float64Filler(),
+    'date-f64': ()=>new DateFiller(),
+    'boolean-byte': ()=>new BooleanFiller(),
+    // The engine gave text, so the text IS the raw value a fallback should carry.
+    'json': ()=>new JsonFiller(asJsonText, (text)=>text),
+    // The engine gave a live object, so a fallback has to parse the text back into one.
+    'json-stringify': ()=>new JsonFiller(asStringifiedJson, parseJsonText),
+    'clone': ()=>new CloneFiller()
+};
+const createFiller = (encoding)=>{
+    const create = FILLERS[encoding];
+    if (create == null) {
+        throw new Error(`transfer encoding '${encoding}' is not supported`);
+    }
+    return create();
+};
+
+;// CONCATENATED MODULE: ./src/transfer/ChunkEncoder.ts
+
+
+/** Probe for names the prototype chain answers for — `__proto__`, `toString`, `constructor`. */ const EMPTY_OBJECT = {};
+/**
+ * Fills one chunk at a time from row values, and emits it with the buffers its transport can hand
+ * over.
+ *
+ * One encoder per result, not per chunk: a column that falls back to `clone` stays there for
+ * every later chunk, and a forward-only cursor cannot rewind to re-encode what it already yielded.
+ *
+ * Usage is a loop — `appendRow` or `appendRecord` until `isFull`, `take`, repeat, then `take` once
+ * more for the short final chunk. A zero-row result takes exactly one chunk with `rowCount: 0`.
+ */ class ChunkEncoder {
+    columns;
+    fillers;
+    inheritedNames;
+    rows = 0;
+    constructor(plan){
+        assertTransferVersion(plan.version);
+        if (plan.columns.length === 0) {
+            throw new Error('A transfer plan needs at least one column; a result with no columns has no rows to encode.');
+        }
+        const names = new Set();
+        for (const column of plan.columns){
+            if (names.has(column.name)) {
+                // One entry per column name in the emitted chunk, so two columns sharing a name
+                // would silently keep only the second. The caller aliases them instead.
+                throw new Error(`A transfer plan names the column '${column.name}' more than once.`);
+            }
+            names.add(column.name);
+        }
+        this.columns = plan.columns;
+        this.fillers = plan.columns.map((column)=>createFiller(column.encoding));
+        this.inheritedNames = plan.columns.some((column)=>column.name in EMPTY_OBJECT);
+    }
+    /** Rows in the chunk being filled. */ get rowCount() {
+        return this.rows;
+    }
+    get isFull() {
+        return this.rows === /* inlined export .CHUNK_ROWS */ (4096);
+    }
+    /** The column names, in the order a row's values must arrive in. */ get columnNames() {
+        return this.columns.map((column)=>column.name);
+    }
+    /**
+     * Adds one row, its values in plan column order.
+     *
+     * A value that does not belong in its column's encoding sends that column to `clone` for the
+     * rest of the result, carrying the rows already written with it. Nothing is coerced into a
+     * typed array.
+     */ appendRow(values) {
+        if (this.isFull) {
+            throw new Error(`The chunk is full at ${/* inlined export .CHUNK_ROWS */ (4096)} rows; take it before appending another.`);
+        }
+        if (values.length !== this.fillers.length) {
+            throw new Error(`A row carried ${values.length} values for ${this.fillers.length} planned columns.`);
+        }
+        const index = this.rows;
+        for(let i = 0; i < this.fillers.length; i++){
+            if (this.fillers[i].set(index, values[i]) === false) {
+                this.fallBack(i, index, values[i]);
+            }
+        }
+        this.rows = index + 1;
+    }
+    /**
+     * Adds one row from a NAME-KEYED record, reading each planned column out of it.
+     *
+     * For an engine that yields records rather than positional tuples — a document store, a
+     * key-value store, a driver that returns row objects. Projecting to an array is the caller's
+     * alternative, and getting that order wrong is silent corruption rather than an error, so the
+     * mapping belongs here once instead of in every plugin.
+     *
+     * A column the record does not carry is `null`, not an error. Records are legitimately
+     * heterogeneous outside a fixed-schema table, and the plan is what decides the result shape.
+     */ appendRecord(record) {
+        const values = new Array(this.columns.length);
+        for(let i = 0; i < this.columns.length; i++){
+            values[i] = this.readField(record, this.columns[i].name);
+        }
+        this.appendRow(values);
+    }
+    /**
+     * A plain read, unless a planned name is one the prototype chain answers for.
+     *
+     * `record['__proto__']` on an object literal returns `Object.prototype` rather than
+     * `undefined`, and `toString` returns a function — either would be encoded as a value. The
+     * own-property test that avoids it costs a call per field, so it is only taken when a name in
+     * this plan actually needs it.
+     */ readField(record, name) {
+        if (this.inheritedNames) {
+            return Object.prototype.hasOwnProperty.call(record, name) ? record[name] : null;
+        }
+        const value = record[name];
+        // `null`, not `undefined`. An absent field and one holding `undefined` mean the same thing
+        // here, and a `clone` column would otherwise carry `undefined` all the way to the entity —
+        // a decoded row says `null` for an absent value in every other encoding.
+        return value === undefined ? null : value;
+    }
+    /**
+     * Emits the filled chunk and readies the encoder for the next one.
+     *
+     * Transfer DETACHES the emitted buffers, so the fillers allocate fresh arrays here rather
+     * than reusing them. Reading a chunk's typed arrays after this is a use-after-transfer.
+     */ take() {
+        const transferables = [];
+        // `Object.create(null)`, because a column named `__proto__` assigned onto a plain object
+        // reaches `Object.prototype`'s setter and never becomes an own property — the column then
+        // survives same-realm through the getter and vanishes the moment the chunk is cloned.
+        const columns = Object.create(null);
+        for(let i = 0; i < this.columns.length; i++){
+            columns[this.columns[i].name] = this.fillers[i].emit(this.rows, transferables);
+        }
+        const payload = {
+            version: /* inlined export .TRANSFER_VERSION */ (1),
+            rowCount: this.rows,
+            columns
+        };
+        this.rows = 0;
+        for (const filler of this.fillers){
+            filler.reset();
+        }
+        return {
+            payload,
+            transferables
+        };
+    }
+    fallBack(column, index, value) {
+        const clone = new CloneFiller(this.fillers[column].drain(index));
+        clone.set(index, value);
+        this.fillers[column] = clone;
+    }
+}
+
+;// CONCATENATED MODULE: ./src/transfer/decoder.ts
+
+const isTransferJsonError = (error)=>typeof error?.transferJsonColumn === 'string';
+const jsonError = (column, cause)=>Object.assign(new Error(`The transferred JSON document for column '${column}' did not parse, so this column holds ` + `text that is not JSON. Retry the request without a transfer plan. Cause: ` + `${cause?.message ?? String(cause)}`), {
+        transferJsonColumn: column
+    });
+const effectiveColumns = (plan, chunk)=>plan.columns.map((column)=>{
+        // An own-property test, not a truthiness one: a name like `__proto__` or `toString`
+        // resolves to something inherited on a plain object, which would pass a null check and
+        // then be decoded as a column.
+        if (Object.prototype.hasOwnProperty.call(chunk.columns, column.name) === false) {
+            throw new Error(`The transferred chunk has no column '${column.name}', which the plan lists.`);
+        }
+        const encoded = chunk.columns[column.name];
+        return {
+            name: column.name,
+            encoding: encoded.encoding
+        };
+    });
+/**
+ * The serialized layout IS the key.
+ *
+ * Content-keyed, never by collection name: a migration changes the columns under one name, one
+ * worker serves every database on the page, and joins and projections produce many shapes per
+ * collection. Names are quoted so a name containing the separator cannot collide with a
+ * different layout — a collision would hand a result the wrong decoder, silently.
+ */ const cacheKey = (columns)=>'v1|' + columns.map((column)=>`${JSON.stringify(column.name)}:${column.encoding}`).join('|');
+/** Retains a compiled function per entry, so it is bounded. */ const CACHE_CAPACITY = 64;
+const cache = new Map();
+const cached = (key)=>{
+    const decoder = cache.get(key);
+    if (decoder == null) {
+        return undefined;
+    }
+    // Re-inserted so the eviction below drops the least recently USED entry, not the oldest.
+    cache.delete(key);
+    cache.set(key, decoder);
+    return decoder;
+};
+const remember = (key, decoder)=>{
+    cache.set(key, decoder);
+    if (cache.size > CACHE_CAPACITY) {
+        const oldest = cache.keys().next();
+        if (oldest.done === false) {
+            cache.delete(oldest.value);
+        }
+    }
+};
+/** Emptied between tests. Not part of the decoding contract. */ const clearDecoderCache = ()=>cache.clear();
+const rowValue = (column, index)=>{
+    const nulled = `(u${index}[b] & m) !== 0`;
+    switch(column.encoding){
+        case 'float64':
+            return `${nulled} ? null : d${index}[i]`;
+        case 'date-f64':
+            return `${nulled} ? null : new Date(d${index}[i])`;
+        case 'boolean-byte':
+            return `${nulled} ? null : d${index}[i] !== 0`;
+        case 'json':
+            return `j${index}[i]`;
+        case 'clone':
+            return `d${index}[i]`;
+    }
+};
+/**
+ * The key to write in the emitted object literal.
+ *
+ * A quoted `"__proto__"` in an object literal sets the row's prototype instead of defining a
+ * property (Annex B.3.1), so that one name needs a computed key. Every other name keeps the
+ * constant form: computed keys throughout measured 9% slower over a 4,096-row chunk, and decode
+ * speed is what this whole module is for.
+ */ const literalKey = (name)=>name === '__proto__' ? `[${JSON.stringify(name)}]` : JSON.stringify(name);
+const isTyped = (encoding)=>encoding === 'float64' || encoding === 'date-f64' || encoding === 'boolean-byte';
+const decoderSource = (columns)=>{
+    const lines = [
+        '"use strict";',
+        'var n = chunk.rowCount;',
+        'var rows = new Array(n);'
+    ];
+    columns.forEach((column, index)=>{
+        if (column.encoding === 'json') {
+            lines.push(`var j${index} = json[${index}];`);
+            return;
+        }
+        lines.push(`var c${index} = chunk.columns[${JSON.stringify(column.name)}];`);
+        lines.push(`var d${index} = c${index}.data;`);
+        if (isTyped(column.encoding)) {
+            lines.push(`var u${index} = c${index}.nulls;`);
+        }
+    });
+    lines.push('for (var i = 0; i < n; i++) {');
+    lines.push('var b = i >> 3, m = 1 << (i & 7);');
+    // One object literal per row, properties in plan order, so all rows share a hidden class.
+    lines.push('rows[i] = {');
+    columns.forEach((column, index)=>{
+        lines.push(`${literalKey(column.name)}: ${rowValue(column, index)},`);
+    });
+    lines.push('};');
+    lines.push('}');
+    lines.push('return rows;');
+    return lines.join('\n');
+};
+/**
+ * Whether this environment allows generated functions at all.
+ *
+ * `new Function` needs `unsafe-eval`, which a Content-Security-Policy can withhold. A caller
+ * asks once at startup and stops sending plans if the answer is no, which falls back to the
+ * transport's ordinary clone — a known-good path. There is deliberately no reflective decoder to
+ * fall back to: one was measured and never beat the clone it would replace.
+ */ let generationSupported = null;
+const isTransferCodecSupported = ()=>{
+    if (generationSupported == null) {
+        try {
+            new Function('return 1')();
+            generationSupported = true;
+        } catch  {
+            generationSupported = false;
+        }
+    }
+    return generationSupported;
+};
+const buildDecoder = (columns)=>new Function('chunk', 'json', decoderSource(columns));
+const decoderFor = (columns)=>{
+    const key = cacheKey(columns);
+    const hit = cached(key);
+    if (hit != null) {
+        return hit;
+    }
+    const decoder = buildDecoder(columns);
+    remember(key, decoder);
+    return decoder;
+};
+/**
+ * Parsed outside the generated function, so a failure can name its column.
+ *
+ * One parse per JSON column per chunk replaces one per row — worth about 16% of the codec's
+ * total win, and it stacks with chunking.
+ */ const parseJsonColumns = (columns, chunk)=>{
+    const parsed = new Array(columns.length);
+    columns.forEach((column, index)=>{
+        if (column.encoding !== 'json') {
+            return;
+        }
+        const encoded = chunk.columns[column.name];
+        const doc = encoded.encoding === 'json' ? encoded.doc : '[]';
+        try {
+            parsed[index] = JSON.parse(doc);
+        } catch (error) {
+            throw jsonError(column.name, error);
+        }
+    });
+    return parsed;
+};
+/**
+ * Decodes one chunk into final-shape row objects — real booleans, `Date` objects, parsed JSON.
+ *
+ * Not the raw storage shape. The entity needs the final shape either way, and decoding to raw and
+ * re-shaping afterwards measured slower (156ms against 140ms at 100,000 rows). An absent or null
+ * value becomes JavaScript `null`, never `undefined` and never an absent property.
+ *
+ * A column that fell back to `clone` in the worker comes back RAW, and the caller still owes it
+ * whatever shaping that column would otherwise have had.
+ */ const decodeChunk = (plan, chunk)=>{
+    assertTransferVersion(plan.version);
+    assertTransferVersion(chunk.version);
+    const columns = effectiveColumns(plan, chunk);
+    return decoderFor(columns)(chunk, parseJsonColumns(columns, chunk));
+};
+
+;// CONCATENATED MODULE: ./src/schema/types.ts
+var types_SchemaTypes = /*#__PURE__*/ function(SchemaTypes) {
+    SchemaTypes["Array"] = "Array";
+    SchemaTypes["Boolean"] = "Boolean";
+    SchemaTypes["Date"] = "Date";
+    SchemaTypes["Number"] = "Number";
+    SchemaTypes["Object"] = "Object";
+    SchemaTypes["String"] = "String";
+    SchemaTypes["Definition"] = "Definition";
+    SchemaTypes["Function"] = "Function";
+    SchemaTypes["Computed"] = "Computed";
+    /**
+     * Content in, reference out. The only type whose write shape differs from its stored
+     * shape, and a leaf on purpose — see `SchemaFile`.
+     */ SchemaTypes["File"] = "File";
+    /**
+     * A fixed-length list of numbers, carrying its dimension count — see `SchemaVector`.
+     *
+     * Value-shaped exactly like `s.array(s.number())`, which is why every array codegen
+     * handler accepts it. It is a distinct type only so a backend can recognise it and store
+     * it natively; nothing else needs to tell the two apart.
+     */ SchemaTypes["Vector"] = "Vector";
+    return SchemaTypes;
+}({});
+var types_HashType = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(HashType) {
+    HashType["Ids"] = "Ids";
+    HashType["Object"] = "Object";
+    return HashType;
+}({})));
+
+;// CONCATENATED MODULE: ./src/transfer/plan.ts
+
+
+/**
+ * For an engine that returns a column as the raw text or number it stored.
+ *
+ * SQLite is the case this was measured against — a date is TEXT holding ISO-8601 and a boolean is
+ * INTEGER holding 0 or 1 — but the mapping is about the STORED shape, not about SQL. Any engine
+ * that keeps those encodings uses it; one that parses values before returning them (PGlite) needs
+ * its own.
+ *
+ * `String` is deliberately absent, so strings cross in a plain array. Cloning a V8 string is a
+ * native memcpy and encoding one measured slower: 14.0ms against 8.3ms for 4,000 rows of 2KB text.
+ */ const rawStorageTransferTypes = {
+    [types_SchemaTypes.Number]: 'float64',
+    [types_SchemaTypes.Boolean]: 'boolean-byte',
+    [types_SchemaTypes.Date]: 'date-f64',
+    [types_SchemaTypes.Object]: 'json',
+    [types_SchemaTypes.Array]: 'json',
+    [types_SchemaTypes.Vector]: 'json'
+};
+/**
+ * For an engine that returns values already parsed — a document store, a key-value store holding
+ * decoded records, or a driver with type parsers registered.
+ *
+ * Differs from {@link rawStorageTransferTypes} in ONE place: a nested structure arrives as a live
+ * object, so it is stringified on the way out rather than passed through as text. Dates and
+ * booleans need no separate entry, because those fillers accept either shape.
+ *
+ * Whether `json-stringify` beats `clone` for a given payload is unmeasured — see the encoding's
+ * own note. An engine unsure of that should map its nested types to `clone` and keep today's
+ * behaviour.
+ */ const parsedValueTransferTypes = {
+    [types_SchemaTypes.Number]: 'float64',
+    [types_SchemaTypes.Boolean]: 'boolean-byte',
+    [types_SchemaTypes.Date]: 'date-f64',
+    [types_SchemaTypes.Object]: 'json-stringify',
+    [types_SchemaTypes.Array]: 'json-stringify',
+    [types_SchemaTypes.Vector]: 'json-stringify'
+};
+/**
+ * True when this layer must not touch the column, whatever its declared type says.
+ *
+ * A property that serializes, deserializes or transforms itself owns its storage shape, and this
+ * has no way to know what that shape is. Handing an already-parsed value to a property carrying
+ * `.deserialize(x => JSON.parse(String(x)))` throws, from a schema that was working.
+ */ const ownsItsShape = (property)=>property.valueSerializer != null || property.valueDeserializer != null || property.transform != null || property.functionBody != null;
+/**
+ * The encoding for one column.
+ *
+ * A schema type alone does not prove what the engine will return — a migration or an external
+ * writer can put anything in a column — so this is a starting point the encoder still validates
+ * per value.
+ */ const transferEncodingFor = (column, strategy)=>{
+    const property = column.property;
+    // Checked BEFORE the resolver, and not overridable by it. A property carrying its own
+    // serializer owns its storage shape; pre-shaping it throws from a schema that was working,
+    // and that is true on every engine.
+    if (property == null || ownsItsShape(property)) {
+        return 'clone';
+    }
+    const { resolve, types } = normalize(strategy);
+    return resolve?.(column) ?? types?.[property.type] ?? 'clone';
+};
+const normalize = (strategy)=>{
+    if (typeof strategy === 'function') {
+        return {
+            resolve: strategy
+        };
+    }
+    if ('resolve' in strategy || 'types' in strategy) {
+        return strategy;
+    }
+    return {
+        types: strategy
+    };
+};
+/**
+ * Builds the plan for an ordered result column list, or `undefined` when there is nothing to plan.
+ *
+ * `undefined` is not a failure — it means this result takes the ordinary clone path. Two shapes
+ * get it:
+ *
+ * - **No columns.** There is no row to decode.
+ * - **A repeated column name.** One chunk carries one entry per name, and a row object holds one
+ *   value per key, so a result naming a column twice cannot round-trip through a plan. That is a
+ *   legal result that works without the codec, so it keeps working rather than becoming an error.
+ */ const buildTransferPlan = (columns, strategy)=>{
+    if (columns.length === 0) {
+        return undefined;
+    }
+    const names = new Set(columns.map((column)=>column.name));
+    if (names.size !== columns.length) {
+        return undefined;
+    }
+    return {
+        version: /* inlined export .TRANSFER_VERSION */ (1),
+        columns: columns.map((column)=>({
+                name: column.name,
+                encoding: transferEncodingFor(column, strategy)
+            }))
+    };
+};
+
+;// CONCATENATED MODULE: ./src/transfer/index.ts
+/**
+ * The worker-boundary transfer codec.
+ *
+ * Not SQL-specific. Any plugin whose engine runs in a worker crosses this boundary for the same
+ * reason — `FileSystemFileHandle.createSyncAccessHandle` is undefined on the main thread, so OPFS
+ * persistence is only reachable from a worker — and pays the same structured clone for its records.
+ * A document store, a key-value store, or anything else compiled to WASM over OPFS is the same
+ * problem: many records, each a set of named values, crossing one `postMessage`.
+ *
+ * What an engine has to supply is small and deliberately so:
+ *
+ * - **An ordered list of the fields a result carries**, and the schema property behind each one
+ *   where there is one. Positional (`appendRow`) or name-keyed (`appendRecord`), whichever the
+ *   engine yields.
+ * - **A `TransferEncodingStrategy`** — which encoding each field takes. A table by schema type
+ *   covers the common case; a resolver covers an engine whose answer is not a function of the type.
+ *
+ * Every encoding names a VALUE shape rather than an engine, and the fillers accept every shape a
+ * value plausibly arrives in: a date as a `Date`, an epoch number, or text; a boolean as a boolean
+ * or as 0/1; a nested structure as text (`json`) or as a live object (`json-stringify`). An engine
+ * chooses; nothing here assumes.
+ *
+ * Three layers, and the first two are here:
+ *
+ * - **codec** (`types`, `ChunkEncoder`, `decoder`) — column values in, `{ payload, transferables }`
+ *   out. Knows nothing about schemas or workers.
+ * - **plan building** (`plan`) — result columns become a `TransferPlan`. Needs `SchemaTypes` and a
+ *   property's serializers, which are data-model facts, so it belongs here too. What varies by
+ *   engine is only which values that engine hands back, and that is a `TransferTypeMapping` the
+ *   caller passes in.
+ * - **wiring** — the worker protocol and the transport. Belongs to each plugin.
+ *
+ * What is NOT here is anything that knows a STORAGE LAYOUT. `entityResultColumns` lives in
+ * `@routier/sql-plugin-core` because "one JSON column per nested subtree, named for its root" is a
+ * fact about flat tables, not about the data model.
+ *
+ * Deliberately NOT in `core/src/plugins/wire/`: that module's contract is plain JSON for crossing
+ * a trust boundary over HTTP, and a transferable only moves in-process.
+ *
+ * The encoder is import-light on purpose — a worker file ships as its own bundle, so everything it
+ * pulls from core is bundled into it. `plan` adds one runtime import, the `SchemaTypes` enum, whose
+ * own module is type-only imports throughout.
+ */ 
+
+
+
+
+var __webpack_exports__CHUNK_ROWS = __webpack_exports__.iT;
+var __webpack_exports__ChunkEncoder = __webpack_exports__.Im;
+var __webpack_exports__TRANSFER_VERSION = __webpack_exports__.FG;
+var __webpack_exports__assertColumnLayout = __webpack_exports__.rq;
+var __webpack_exports__assertTransferVersion = __webpack_exports__.E5;
+var __webpack_exports__buildTransferPlan = __webpack_exports__.fY;
+var __webpack_exports__clearDecoderCache = __webpack_exports__.wN;
+var __webpack_exports__decodeChunk = __webpack_exports__.WQ;
+var __webpack_exports__isTransferCodecSupported = __webpack_exports__.Ai;
+var __webpack_exports__isTransferJsonError = __webpack_exports__.WZ;
+var __webpack_exports__nullByteLength = __webpack_exports__.YA;
+var __webpack_exports__parsedValueTransferTypes = __webpack_exports__.ze;
+var __webpack_exports__rawStorageTransferTypes = __webpack_exports__.yl;
+var __webpack_exports__transferEncodingFor = __webpack_exports__.sg;
+export { __webpack_exports__CHUNK_ROWS as CHUNK_ROWS, __webpack_exports__ChunkEncoder as ChunkEncoder, __webpack_exports__TRANSFER_VERSION as TRANSFER_VERSION, __webpack_exports__assertColumnLayout as assertColumnLayout, __webpack_exports__assertTransferVersion as assertTransferVersion, __webpack_exports__buildTransferPlan as buildTransferPlan, __webpack_exports__clearDecoderCache as clearDecoderCache, __webpack_exports__decodeChunk as decodeChunk, __webpack_exports__isTransferCodecSupported as isTransferCodecSupported, __webpack_exports__isTransferJsonError as isTransferJsonError, __webpack_exports__nullByteLength as nullByteLength, __webpack_exports__parsedValueTransferTypes as parsedValueTransferTypes, __webpack_exports__rawStorageTransferTypes as rawStorageTransferTypes, __webpack_exports__transferEncodingFor as transferEncodingFor };
+
+//# sourceMappingURL=index.js.map