capnstruct 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1076 @@
+import { generateGo, generateRust, toGoStruct, toRustReprC, } from './codegen.js';
+export { generateGo, generateRust, toGoStruct, toRustReprC, };
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+const oob = () => {
+    throw new RangeError('Out of bounds');
+};
+const al = (x, a) => (x + a - 1) & ~(a - 1);
+const u8s = (d, o = 0, l = d.byteLength - o) => new Uint8Array(d.buffer, d.byteOffset + o, l);
+const N = Number;
+const chkLen = (n) => {
+    if (!N.isInteger(n) || n < 0)
+        oob();
+};
+let sBuf = new ArrayBuffer(65536), sDv = new DataView(sBuf), sU8 = new Uint8Array(sBuf), tail = 0;
+function hid(value) {
+    return { value, writable: true, enumerable: false, configurable: true };
+}
+const BASE_DESCS = Object.fromEntries('_d _b _o _m _a _ws _tl _dead _dirty'.split(' ').map((k) => [k, hid()]));
+const dvP = DataView.prototype;
+function prim(type) {
+    const c = type[0], bits = +type.slice(1) || 8, size = bits >> 3, float = c === 'f', big = size === 8 && !float, m = (float ? 'Float' : (big ? 'Big' : '') + (c === 'i' ? 'Int' : 'Uint')) + bits, g = dvP['get' + m], s = dvP['set' + m];
+    return {
+        kind: 'primitive',
+        type,
+        rustType: (type === 'f16' ? 'u16' : type),
+        size,
+        align: size,
+        signed: c === 'i' || float,
+        float,
+        bigint: big,
+        _C: globalThis[m + 'Array'] ?? Uint16Array,
+        _g: (d, o) => g.call(d, o, true),
+        _s: (d, o, v) => s.call(d, o, big ? BigInt(v) : N(v), true),
+    };
+}
+/** Unsigned 8-bit integer (`0..255`, 1 byte, 1-byte aligned). */
+export const u8 = /* @__PURE__ */ prim('u8');
+/** Signed 8-bit integer (`-128..127`, 1 byte, 1-byte aligned). */
+export const i8 = /* @__PURE__ */ prim('i8');
+/** Little-endian unsigned 16-bit integer (`0..65535`, 2 bytes, 2-byte aligned). */
+export const u16 = /* @__PURE__ */ prim('u16');
+/** Little-endian signed 16-bit integer (`-32768..32767`, 2 bytes, 2-byte aligned). */
+export const i16 = /* @__PURE__ */ prim('i16');
+/** Little-endian unsigned 32-bit integer (4 bytes, 4-byte aligned). */
+export const u32 = /* @__PURE__ */ prim('u32');
+/** Little-endian signed 32-bit integer (4 bytes, 4-byte aligned). */
+export const i32 = /* @__PURE__ */ prim('i32');
+/** Little-endian unsigned 64-bit integer (`bigint`, 8 bytes, 8-byte aligned). */
+export const u64 = /* @__PURE__ */ prim('u64');
+/** Little-endian signed 64-bit integer (`bigint`, 8 bytes, 8-byte aligned). */
+export const i64 = /* @__PURE__ */ prim('i64');
+/** IEEE 754 16-bit half-precision float (2 bytes, 2-byte aligned). */
+export const f16 = /* @__PURE__ */ prim('f16');
+/** IEEE 754 32-bit float (4 bytes, 4-byte aligned). */
+export const f32 = /* @__PURE__ */ prim('f32');
+/** IEEE 754 64-bit float (8 bytes, 8-byte aligned). */
+export const f64 = /* @__PURE__ */ prim('f64');
+/** 1-byte boolean (`0` or `1`, 1-byte aligned). */
+export const bool = {
+    ... /* @__PURE__ */prim('bool'),
+    _g: (d, o) => d.getUint8(o) !== 0,
+    _s: (d, o, v) => d.setUint8(o, v ? 1 : 0),
+};
+/** Inline fixed-length null-padded UTF-8 string `[u8; N]` (`align: 1, size: length`) with zero tail indirection. */
+export function fixedStr(length) {
+    return {
+        ...fixedBytes(length),
+        type: 'fixedStr',
+        _g(d, o) {
+            let end = 0;
+            while (end < length && d.getUint8(o + end))
+                end++;
+            return textDecoder.decode(u8s(d, o, end));
+        },
+        _s(d, o, v) {
+            const u = u8s(d, o, length);
+            u.fill(0);
+            textEncoder.encodeInto(String(v), u);
+        },
+    };
+}
+/** Inline fixed-length byte array `[u8; N]` (`align: 1, size: length`) read as a zero-copy `Uint8Array`. */
+export function fixedBytes(length) {
+    chkLen(length);
+    return {
+        kind: 'primitive',
+        type: 'fixedBytes',
+        length,
+        size: length,
+        align: 1,
+        rustType: `[u8; ${length}]`,
+        _C: undefined,
+        _g: (d, o) => u8s(d, o, length),
+        _s(d, o, v) {
+            const u = u8s(d, o, length);
+            u.fill(0);
+            if (v)
+                u.set(ArrayBuffer.isView(v) ? u8s(v, 0, Math.min(v.byteLength, length)) : Array.from(v).slice(0, length));
+        },
+    };
+}
+/** Maps an inline sentinel value (e.g. `-32768` for `i16` or `NaN` for `f32`) to `null` in JS with 0 extra wire bytes. */
+export function sentinel(primDesc, nullValue) {
+    return {
+        ...primDesc,
+        nullable: true,
+        _null: nullValue,
+        _C: undefined,
+        _g: (d, o) => { const v = primDesc._g(d, o); return Object.is(v, nullValue) ? null : v; },
+        _s: (d, o, v) => primDesc._s(d, o, (v ?? nullValue)),
+    };
+}
+/** Alias for `sentinel(primDesc, nullValue)`. */
+export const nullable = sentinel;
+export function scaled(primDesc, factor, nullOpt) {
+    const nv = typeof nullOpt === 'number' ? nullOpt : nullOpt?.null;
+    return {
+        ...sentinel(primDesc, nv),
+        type: 'f64',
+        float: true,
+        nullable: (nv !== undefined),
+        _g: (d, o) => {
+            const r = primDesc._g(d, o);
+            return Object.is(r, nv) ? null : r / factor;
+        },
+        _s: (d, o, v) => primDesc._s(d, o, v == null ? (nv ?? 0) : Math.round(+v * factor)),
+    };
+}
+/** Variable-length UTF-8 string stored in the tail arena via an 8-byte `[u32 off, u32 len]` descriptor. */
+export const str = {
+    kind: 'str',
+    size: 8,
+    align: 4,
+    rustType: 'CapnStr',
+};
+export function fixedArray(element, length) {
+    chkLen(length);
+    return {
+        kind: 'array',
+        element,
+        length,
+        size: element.size * length,
+        align: element.align,
+        rustType: `[${element.rustType}; ${length}]`,
+    };
+}
+/** Alias for `fixedArray(element, length)`. */
+export const array = fixedArray;
+/** Variable-length slice `CapnSlice<T>` stored in the tail arena via an 8-byte `[u32 off, u32 len]` descriptor. */
+const _reg = {};
+function ptrDesc(kind, target) {
+    const getEl = () => _reg[target] ?? (typeof target === 'function' ? target() : target);
+    return {
+        kind,
+        get element() { return getEl(); },
+        size: 8,
+        align: 4,
+        get rustType() {
+            return `Capn${kind === 'ref' ? 'Ref' : 'Slice'}<${getEl().rustType}>`;
+        },
+    };
+}
+export function slice(element, kind = 'slice') { return ptrDesc(kind, element); }
+/** Alias for `slice(element)`. */
+export const list = slice;
+export function ref(target) { return ptrDesc('ref', target); }
+function ensureScratch(minBytes) {
+    if (minBytes > sBuf.byteLength) {
+        const nb = new ArrayBuffer(Math.max(minBytes, sBuf.byteLength * 2));
+        sDv = new DataView((sBuf = nb));
+        const nu = new Uint8Array(nb);
+        nu.set(sU8);
+        sU8 = nu;
+    }
+}
+function growMem(m, end) {
+    if (end > m.buffer.byteLength)
+        m.grow(Math.ceil((end - m.buffer.byteLength) / 65536));
+}
+function resolveSource(s, byteOffset = 0) {
+    const v = ArrayBuffer.isView(s), m = !v && s?.buffer ? s : null, b = v ? s.buffer : m ? m.buffer : s, len = v ? s.byteLength : b.byteLength;
+    if (byteOffset < 0 || byteOffset > len)
+        oob();
+    return {
+        d: m && '_d' in m ? m.sync()._d : new DataView(b, v ? s.byteOffset : 0, len),
+        b: v ? s.byteOffset : 0,
+        o: byteOffset,
+        max: len - byteOffset,
+        m,
+    };
+}
+function defVal(desc, plain) {
+    const d = new DataView(new ArrayBuffer(desc.size));
+    return readVal({ def: desc, _d: d, _b: 0, _o: 0, _ws: desc.size, _m: null, _k: () => d }, desc, 0, plain);
+}
+function allocTail(v, bytes, align) {
+    const root = v._a ?? v, m = root._m;
+    if (m && '_u8' in m) {
+        const p = m._alloc(bytes, align, true);
+        if (root._tl !== undefined && m.offset > root._tl)
+            root._tl = m.offset;
+        v._d = root._d = m._d;
+        return p;
+    }
+    const d = root._k(), cur = Math.max(root._tl ?? root._o + al(root.byteLength, 8), m?.offset ?? 0), p = al(cur, align), end = p + bytes;
+    if (end > d.byteLength) {
+        if (m) {
+            growMem(m, end);
+            root._d = new DataView(m.buffer);
+        }
+        else {
+            const nb = new ArrayBuffer(Math.max(al(end, 8), d.byteLength * 2, 64));
+            new Uint8Array(nb).set(u8s(d, 0, cur));
+            root._d = new DataView(nb);
+        }
+        v._d = root._d;
+    }
+    else if (bytes) {
+        u8s(d, p, bytes).fill(0);
+    }
+    root._tl = end;
+    if (m)
+        m.offset = end;
+    return p;
+}
+function mutVar(v, off, base, count, elSize, align) {
+    const bytes = count * elSize;
+    if (!v) {
+        const st = count ? al(tail, align) : tail;
+        ensureScratch((tail = st + bytes) + 64);
+        sU8.fill(0, st, tail);
+        setDesc(off, count ? st - base : 0, count);
+        return st;
+    }
+    const root = v._a ?? v, d = v._k(), oldP = d.getUint32(off, true), oldB = d.getUint32(off + 4, true) * elSize, st0 = base + oldP, inTail = oldP > 0 && st0 >= root._o + root.byteLength, atTip = inTail && oldB > 0 && st0 + oldB === (root._tl ?? root._o + root.byteLength);
+    let st = st0;
+    if (inTail && bytes <= oldB) {
+        if (atTip)
+            root._tl = st0 + bytes;
+        if (oldB > bytes)
+            root._dead = (root._dead ?? 0) + (oldB - bytes);
+    }
+    else {
+        if (atTip && !root._m)
+            root._tl = st0;
+        else if (inTail && oldB)
+            root._dead = (root._dead ?? 0) + oldB;
+        st = allocTail(root, bytes, align);
+        if (root.def && off === root._b + root.def._fv && st - base !== al(root.byteLength, 8))
+            root._dirty = true;
+    }
+    if (bytes)
+        u8s(root._d, st, bytes).fill(0);
+    setDesc(off, count ? st - base : 0, count, root._d);
+    return st;
+}
+function upgradeView(v) {
+    if (v._ws < v.def.size)
+        (v._a ?? v).compact();
+}
+let _budget = 0;
+let _rSeen = null;
+let _wSeen = null;
+let _wActive = null;
+let _wFix = null;
+function readVal(v, desc, off, plain) {
+    const d = v._k(), k = desc.kind;
+    if (k === 'primitive') {
+        const r = desc._g(d, off);
+        return plain && r instanceof Uint8Array ? Array.from(r) : r;
+    }
+    const minP = v._o === v._b ? v._o + v._ws : v._b;
+    if (k === 'str') {
+        const p = v._b + d.getUint32(off, true), l = d.getUint32(off + 4, true);
+        if (!l)
+            return '';
+        if (p < minP || p + l > d.byteLength || (plain && (_budget -= l) < 0))
+            oob();
+        return textDecoder.decode(u8s(d, p, l));
+    }
+    if (k === 'array' || k === 'slice' || k === 'ref') {
+        const el = desc.element, sz = el.size, n = k === 'array' ? desc.length : d.getUint32(off + 4, true);
+        let p = off;
+        if (k !== 'array') {
+            if (!n && k === 'ref')
+                return null;
+            p = n ? v._b + d.getUint32(off, true) : v._b;
+            const bl = (k === 'ref' ? 1 : n) * sz, inTbl = el === v.def && p >= v._b && p < minP && (p - v._b) % (v._ws || v.def.size) === 0;
+            if (n && ((!inTbl && p < minP) || p + bl > d.byteLength || (!inTbl && p < off + 8 && p + bl > off)))
+                oob();
+        }
+        if (k === 'ref')
+            return readVal(v, el, p, plain);
+        const tot = d.byteOffset + p;
+        if (!plain && el.kind === 'primitive' && el._C && el.type !== 'bool' && tot % sz === 0)
+            return new el._C(d.buffer, tot, n);
+        if (!plain && el.kind === 'struct') {
+            const sav = new StructArrayView(el, d, p, n, v._b);
+            sav._m = v._m;
+            sav._a = v._a ?? v;
+            return sav;
+        }
+        if (plain && (_budget -= n * sz) < 0)
+            oob();
+        return Array.from({ length: n }, (_, i) => readVal(v, el, p + i * sz, plain));
+    }
+    if (!plain) {
+        if (desc === v.def && v === v._a?._c) {
+            v._o = off;
+            return v;
+        }
+        const nv = new desc._V(d, v._b, off, v._m);
+        nv._ws = desc === v.def ? v._ws : desc.size;
+        nv._a = v._a ?? v;
+        return nv;
+    }
+    const prev = _rSeen?.get(off);
+    if (prev)
+        return prev;
+    const ws = desc === v.def ? (v._ws ?? desc.size) : desc.size;
+    if ((_budget -= ws) < 0)
+        oob();
+    const out = {};
+    _rSeen?.set(off, out);
+    for (const f of desc.fieldList) {
+        out[f.name] =
+            f.offset + f.size > ws
+                ? defVal(f.desc, true)
+                : readVal(v, f.desc, off + f.offset, true);
+    }
+    return out;
+}
+function readPlain(v, o = v._o, multi = false) {
+    _budget = Math.max(v._k().byteLength * 8, 65536);
+    _rSeen = new Map();
+    try {
+        return multi
+            ? Array.from({ length: v.length }, (_, i) => readVal(v, v.def, o + i * v.stride, true))
+            : readVal(v, v.def, o, true);
+    }
+    finally {
+        _rSeen = null;
+    }
+}
+function setDesc(off, ptr, len, d = sDv) {
+    d.setUint32(off, ptr, true);
+    d.setUint32(off + 4, len, true);
+}
+function writeVal(v, desc, val, base, off) {
+    if (val === undefined || (val === null && desc.kind !== 'ref' && desc._null === undefined))
+        return;
+    const top = _wSeen === null && desc.kind !== 'primitive' && desc.kind !== 'str';
+    if (top) {
+        _wSeen = new Map();
+        _wActive = new Set();
+        _wFix = [];
+    }
+    try {
+        let d = v ? v._k() : sDv;
+        const k = desc.kind;
+        if (k === 'primitive') {
+            desc._s(d, off, val);
+        }
+        else if (k === 'str') {
+            const b = textEncoder.encode(String(val)), st = mutVar(v, off, base, b.byteLength, 1, 1);
+            u8s(v ? v._k() : sDv, st, b.byteLength).set(b);
+        }
+        else if (k === 'ref') {
+            const el = desc.element;
+            if (val === null)
+                mutVar(v, off, base, 0, el.size, el.align);
+            else {
+                const sv = val instanceof MemView && val._k().buffer === d.buffer && val._d.byteOffset === d.byteOffset
+                    ? val._o
+                    : _wSeen?.get(val);
+                if (sv !== undefined)
+                    setDesc(off, sv - base, 1, d);
+                else
+                    writeVal(v, el, val, base, mutVar(v, off, base, 1, el.size, el.align));
+            }
+        }
+        else if (k === 'array' || k === 'slice') {
+            const el = desc.element, isSav = val instanceof StructArrayView, isRaw = el.kind === 'struct' && el._fv < 0 && ArrayBuffer.isView(val), src = isSav || isRaw || 'length' in val ? val : Array.from(val), rawLen = isRaw ? (val.byteLength / el.size) | 0 : src.length, n = k === 'array' ? desc.length : rawLen, cp = Math.min(n, rawLen) * el.size, st = k === 'slice' ? mutVar(v, off, base, n, el.size, el.align) : off;
+            d = v ? v._k() : sDv;
+            if (v && k !== 'slice' && n)
+                u8s(d, st, n * el.size).fill(0);
+            const sb = isRaw || (el.kind === 'primitive' && el._C && val instanceof el._C)
+                ? u8s(val, 0, cp)
+                : isSav && el._fv < 0 && val.stride === el.size && val._ws === el.size
+                    ? u8s(val._k(), val._o, cp)
+                    : null;
+            if (sb) {
+                if (cp)
+                    u8s(d, st, cp).set(sb);
+            }
+            else {
+                const m = Math.min(n, src.length);
+                if (el.kind === 'struct' && _wSeen && !isSav)
+                    for (let i = 0; i < m; i++) {
+                        const it = src[i];
+                        if (it && typeof it === 'object' && !Array.isArray(it) && !_wSeen.has(it))
+                            _wSeen.set(it, st + i * el.size);
+                    }
+                const savCur = isSav ? val._mv(0) : null;
+                for (let i = 0; i < m; i++)
+                    writeVal(v, el, savCur ? val._mv(i, savCur) : src[i], base, st + i * el.size);
+            }
+            if (el._null !== undefined)
+                for (let i = Math.min(n, rawLen); i < n; i++)
+                    el._s(d, st + i * el.size, null);
+        }
+        else if (k === 'struct') {
+            const rec = val;
+            const isTuple = Array.isArray(rec);
+            const trackObj = Boolean(rec && typeof rec === 'object' && !isTuple && !(rec instanceof StructViewBase));
+            if (trackObj) {
+                if (_wActive?.has(rec)) {
+                    _wFix.push([off, _wSeen.get(rec), desc.size]);
+                    return;
+                }
+                if (_wSeen && !_wSeen.has(rec))
+                    _wSeen.set(rec, off);
+                _wActive?.add(rec);
+            }
+            if (v && v._ws < desc.size)
+                upgradeView(v);
+            for (let i = 0; i < desc.fieldList.length; i++) {
+                const f = desc.fieldList[i], fv = isTuple ? rec[i] : rec[f.name];
+                if (fv !== undefined) {
+                    writeVal(v, f.desc, fv, base, off + f.offset);
+                }
+                else if ((!v || off !== v._o) && f.desc._null !== undefined) {
+                    f.desc._s(v ? v._k() : sDv, off + f.offset, null);
+                }
+                else if (!v && off === base && off + f.offset === desc._fv) {
+                    setDesc(off + f.offset, tail - base, 0);
+                }
+            }
+            if (trackObj)
+                _wActive?.delete(rec);
+        }
+    }
+    finally {
+        if (top) {
+            const dEnd = v ? v._k() : sDv;
+            for (const [dst, src, sz] of _wFix)
+                u8s(dEnd, dst, sz).set(u8s(dEnd, src, sz));
+            _wSeen = _wActive = _wFix = null;
+        }
+    }
+}
+function initNulls(def, d, o, n = 1, st = def.size) {
+    for (const f of def.fieldList)
+        if (f.desc._null !== undefined)
+            for (let i = 0; i < n; i++)
+                f.desc._s(d, o + i * st + f.offset, null);
+}
+class MemView {
+    /** @internal */
+    _set(d, b, o, m) {
+        this._d = d;
+        this._b = b;
+        this._o = o;
+        this._m = m;
+        return this;
+    }
+    /** @internal */
+    _k() {
+        const a = this._a;
+        if (a)
+            return (this._d = a._k());
+        const m = this._m;
+        if (m) {
+            const b = (m.memory ?? m).buffer ?? m._buf;
+            if (b !== this._d.buffer)
+                this._d = m.sync ? m.sync()._d : new DataView(b);
+        }
+        return this._d;
+    }
+    /** Underlying `ArrayBuffer` (automatically re-bound if backed by a growing `WebAssembly.Memory` or `WasmArena`). */
+    get buffer() {
+        return this._k().buffer;
+    }
+    /** Byte offset of this view inside `buffer`. */
+    get byteOffset() {
+        return this._k().byteOffset + this._o;
+    }
+    /** Total active + dead bytes occupied by this view's fixed table and tail arena. */
+    get usedByteLength() {
+        const r = this._a ?? this;
+        return r._tl !== undefined ? Math.max(r.byteLength, r._tl - r._o) : r.byteLength;
+    }
+    /** Dead bytes in the tail arena reclaimable via `.compact()`. */
+    get deadByteLength() {
+        const r = this._a ?? this;
+        return r._dead ?? 0;
+    }
+    /** Ratio (`0..1`) of dead tail bytes to total used bytes. */
+    get compactionRatio() {
+        const used = this.usedByteLength;
+        return used > 0 ? Math.min(1, this.deadByteLength / used) : 0;
+    }
+    /** Returns a structured inspection summary (`{ schema, stride, rowCount, usedByteLength, deadByteLength, compactionRatio, data }`). */
+    toDebugObject() {
+        const a = this;
+        return {
+            schema: this.def.rustType,
+            stride: a.stride ?? this.def.size,
+            rowCount: a.length ?? 1,
+            usedByteLength: this.usedByteLength,
+            deadByteLength: this.deadByteLength,
+            compactionRatio: this.compactionRatio,
+            data: a.toJSON(),
+        };
+    }
+    /** Re-packs only live fields and tail data into a tight `Uint8Array` and rebinds this view in-place. */
+    compact() {
+        const a = this, isArr = 'length' in a, p = pack(this.def, (isArr ? a.toJSON() : [a.toJSON()])), o0 = this._o, sz = this.def.size;
+        this.byteLength = (isArr ? a.length : 1) * sz;
+        this._tl = p.byteLength;
+        this._ws = sz;
+        this._dead = 0;
+        this._dirty = false;
+        this._set(new DataView(p.buffer, p.byteOffset, p.byteLength), 0, 0, null);
+        if (isArr) {
+            a.stride = sz;
+            a._cap = a.length;
+            for (const pv of [a._c, ...(a._p ?? [])])
+                if (pv) {
+                    pv._set(this._d, 0, pv._o - o0, a);
+                    pv._ws = sz;
+                }
+        }
+        return p;
+    }
+    /** Wire-ready `Uint8Array` view over the underlying bytes (automatically compacts dead tail bytes if dirty). */
+    get bytes() {
+        if (this._dirty || this._dead || (this.def._fv >= 0 && this._b !== this._o))
+            return this.compact();
+        const d = this._k(), rawEnd = Math.max(this.byteLength, (this._tl ?? this._o + this.byteLength) - this._o), end = !this._m && this._tl !== undefined ? Math.min(d.byteLength - this._o, al(rawEnd, 8)) : rawEnd;
+        if (this.byteLength && this.def._fv >= 0) {
+            const ts = al(this.byteLength, 8), f = this._b + this.def._fv, p0 = d.getUint32(f, true);
+            if (this._tl !== undefined && p0 > ts)
+                return this.compact();
+            if (p0 < ts && end >= ts) {
+                const h = p0 || d.getUint32(f + 4, true) ? 4 : 0;
+                d.setUint32(f + h, ts | (h >> 2), true);
+            }
+        }
+        return u8s(d, this._o, end);
+    }
+}
+export class StructViewBase extends MemView {
+    /** @internal */
+    constructor(descs, dv, base, off, mem = null) {
+        super();
+        Object.defineProperties(this, descs);
+        if (dv)
+            this._set(dv, base, off, mem);
+    }
+    /** Re-positions this flyweight cursor to row `index` (supports negative indices from the end). */
+    seek(index) {
+        const a = this._a;
+        if (a !== undefined)
+            return a.at(index, this);
+        const st = this._ws || this.def.size, o = this._b + index * st;
+        if (o < 0 || o + st > this._k().byteLength)
+            oob();
+        this._o = o;
+        return this;
+    }
+    set(fieldOrValues, value) {
+        if (typeof fieldOrValues === 'string')
+            this[fieldOrValues] = value;
+        else
+            writeVal(this, this.def, fieldOrValues, this._b, this._o);
+        return this;
+    }
+    toObject() {
+        return readPlain(this);
+    }
+}
+const kInspect = /* @__PURE__ */ Symbol.for('nodejs.util.inspect.custom');
+StructViewBase.prototype.at = StructViewBase.prototype.seek;
+StructViewBase.prototype.setAll = StructViewBase.prototype.set;
+StructViewBase.prototype.toJSON = StructViewBase.prototype[kInspect] = StructViewBase.prototype.toObject;
+function normOpts(b = 0, c, bo, s) {
+    return typeof b === 'number'
+        ? { o: b, c, b: bo, s }
+        : { o: b.byteOffset ?? 0, c: b.count, b: b.baseOffset, s: b.stride };
+}
+export function structView(def, source, byteOffset = 0, baseOffset, wireStride) {
+    const n = normOpts(byteOffset, undefined, baseOffset, wireStride);
+    const r = resolveSource(source, n.o), ws = n.s ?? (r.max < def.size ? r.max : def.size);
+    if (r.o < 0 || r.max < ws)
+        oob();
+    const v = new def._V(r.d, n.b ?? r.o, r.o, r.m);
+    v._ws = ws;
+    v._tl = r.o + Math.max(ws, r.max);
+    return v;
+}
+export class StructArrayView extends MemView {
+    constructor(def, source, byteOffset = 0, count, baseOffset, wireStride) {
+        super();
+        const n = normOpts(byteOffset, count, baseOffset, wireStride);
+        const sz = n.s ?? def.size, r = resolveSource(source, n.o), hasVar = def._fv >= 0 && def._fv < sz, f = n.c === undefined && r.max >= sz && hasVar
+            ? (def._fvr && r.d.getUint32(r.o + def._fv + 4, true) & ~7) || r.d.getUint32(r.o + def._fv, true)
+            : 0, len = n.c ?? (f >= sz && f <= r.max ? f / sz : r.max / sz) | 0, tot = len * sz;
+        if (len < 0 || r.o < 0 || r.max < tot)
+            oob();
+        Object.assign(this, {
+            def,
+            stride: sz,
+            length: len,
+            byteLength: tot,
+            _ws: sz,
+            _tl: r.o + (!hasVar && n.c !== undefined ? tot : Math.max(tot, r.max)),
+            _cap: len,
+            _dead: 0,
+            _dirty: false,
+        });
+        this._set(r.d, n.b ?? r.o, r.o, r.m);
+    }
+    /** @internal */
+    _mv(index, v) {
+        const d = this._k(), o = this._o + index * this.stride, nv = v ? v._set(d, this._b, o, this._m) : new this.def._V(d, this._b, o, this._m);
+        nv._ws = this._ws;
+        nv._a = this._a ?? this;
+        return nv;
+    }
+    /** Returns a reusable flyweight cursor positioned at `index`. */
+    cursor(index = 0) {
+        return (this._c = this._mv(index, this._c));
+    }
+    /** Returns a `StructView<F>` at `index` (supports negative indices from the end, e.g. `rows.at(-1)`). */
+    at(index, out) {
+        if (index < 0)
+            index += this.length;
+        if (index < 0 || index >= this.length)
+            oob();
+        if (out)
+            return this._mv(index, out);
+        const p = this._p ?? (this._p = []);
+        const s = (this._pi = ((this._pi ?? 0) + 1) & 255);
+        return (p[s] = this._mv(index, p[s]));
+    }
+    /** Writes `value` into the struct at `index` (supports negative indices from the end). */
+    set(index, value) {
+        this.at(index).set(value);
+        return this;
+    }
+    /** Appends one or more rows to the binary array, automatically growing capacity if needed. */
+    push(...items) {
+        const def = this.def, st = this.stride, need = this.length + items.length, hasVar = def._fv >= 0;
+        if (need > this._cap) {
+            const curEnd = this._tl ?? this._o + this.byteLength, tableEnd = this._o + this._cap * st;
+            if ((!hasVar || !this.length) && tableEnd === curEnd) {
+                allocTail(this, (need - this._cap) * st, def.align);
+                this._cap = need;
+            }
+            else {
+                const newCap = Math.max(need, (this._cap || 2) * 2), newO = allocTail(this, al(newCap * st, 8), def.align), d = this._k(), dO = newO - this._o;
+                if (this.byteLength > 0) {
+                    u8s(d, newO, this.byteLength).set(u8s(d, this._o, this.byteLength));
+                    this._dead = (this._dead ?? 0) + this.byteLength;
+                }
+                this._o = newO;
+                this._cap = newCap;
+                for (const pv of [this._c, ...(this._p ?? [])])
+                    if (pv)
+                        pv._o += dO;
+            }
+        }
+        initNulls(def, this._k(), this._o + this.length * st, items.length, st);
+        for (const item of items) {
+            const idx = this.length++;
+            this.byteLength = this.length * st;
+            writeVal(this, def, item, this._b, this._o + idx * st);
+            if (hasVar)
+                this._dirty = true;
+        }
+        return this.length;
+    }
+    pop() {
+        if (!this.length)
+            return undefined;
+        const lastIdx = --this.length, val = readPlain(this, this._o + lastIdx * this.stride);
+        this.byteLength = this.length * this.stride;
+        if (this.def._fv >= 0) {
+            this._dirty = true;
+            this._dead = (this._dead ?? 0) + this.stride;
+        }
+        else if (this._tl === this._o + (lastIdx + 1) * this.stride) {
+            this._tl -= this.stride;
+            this._cap = this.length;
+        }
+        return val;
+    }
+    /** Returns a zero-copy `StructArrayView` over `[begin, end)` without copying bytes. */
+    subarray(begin = 0, end = this.length) {
+        const len = this.length, cl = (i) => Math.max(0, Math.min(len, i < 0 ? len + i : i)), s = cl(begin), e = cl(end), sub = new StructArrayView(this.def, this._k(), this._o + s * this.stride, Math.max(0, e - s), this._b, this._ws);
+        sub._m = this._m;
+        sub._a = this._a ?? this;
+        sub._dirty = (this.def._fv >= 0 && (s > 0 || e < len)) || Boolean(this._dirty || this._dead);
+        return sub;
+    }
+    lowerBound(field, value) {
+        return bsearch(this, field, value, false);
+    }
+    /** Binary search: first row index `i` in `[0..length]` where `row[i][field] > value` ($O(\log N)$, 0 allocations). */
+    upperBound(field, value) {
+        return bsearch(this, field, value, true);
+    }
+    /** Returns a zero-copy `StructArrayView` slice over the sorted range `min <= row[field] <= max` in $O(\log N)$. */
+    rangeBy(field, min, max) {
+        return this.subarray(this.lowerBound(field, min), this.upperBound(field, max));
+    }
+    /** Filters rows with a reusable flyweight cursor (0 per-row JS objects) and copies matching binary rows into a `Uint8Array`. */
+    filterBytes(predicate) {
+        const len = this.length, c = this.cursor(0), def = this.def, st = this.stride, rows = [];
+        ensureScratch(len * st);
+        let outOff = 0;
+        for (let i = 0; i < len; i++)
+            if (predicate(c.seek(i), i))
+                def._fv < 0 && st === def.size && this._ws === st
+                    ? (sU8.set(u8s(this._k(), this._o + i * st, st), outOff), (outOff += st))
+                    : rows.push(c.toObject());
+        return rows.length ? pack(def, rows) : sU8.slice(0, outOff);
+    }
+    /** Extracts a `TypedArray` column for primitive `field` (zero-copy when `stride === field.size`). */
+    column(field) {
+        const lay = colDesc(this, field), desc = lay.desc, n = this.length, st = this.stride, fo = lay.offset, d = this._k(), start = d.byteOffset + this._o + fo, out = new desc._C(n);
+        if (fo + desc.size <= this._ws) {
+            if (desc.type !== 'bool' && (st === desc.size || n <= 1) && !(start % desc.align))
+                return new desc._C(d.buffer, start, n);
+            for (let i = 0, off = this._o + fo; i < n; i++, off += st)
+                out[i] = desc._g(d, off);
+        }
+        return out;
+    }
+    /** Bulk-writes a primitive column from `values` into `field` across all rows. */
+    setColumn(field, values) {
+        const lay = colDesc(this, field);
+        if (lay.offset + lay.size > this._ws)
+            this.compact();
+        const desc = lay.desc, d = this._k(), st = this.stride, n = Math.min(this.length, values.length);
+        for (let i = 0, off = this._o + lay.offset; i < n; i++, off += st) {
+            desc._s(d, off, values[i]);
+        }
+        return this;
+    }
+    /** Materializes all rows into an array of plain JavaScript objects. */
+    toObjects() {
+        return readPlain(this, this._o, true);
+    }
+    *[Symbol.iterator]() {
+        for (let i = 0, c = this.cursor(0), b = this._o, st = this.stride, n = this.length; i < n; i++) {
+            c._o = b + i * st;
+            yield c;
+        }
+    }
+}
+StructArrayView.prototype.toJSON = StructArrayView.prototype[kInspect] = StructArrayView.prototype.toObjects;
+function colDesc(a, k) {
+    const lay = a.def.fields[k];
+    if (!lay?.desc._C)
+        oob();
+    return lay;
+}
+function bsearch(a, k, v, eq) {
+    const lay = colDesc(a, k), g = lay.desc._g, d = a._k(), b = a._o + lay.offset, st = a.stride;
+    let lo = 0, hi = a.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1, x = g(d, b + mid * st);
+        if (eq ? x <= v : x < v)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+export class WasmArena {
+    constructor(backing = 65536, baseOffset = 0) {
+        this.memory = backing?.buffer ? backing : null;
+        this.baseOffset = this.offset = baseOffset;
+        this._rebind(this.memory
+            ? this.memory.buffer
+            : backing instanceof ArrayBuffer
+                ? backing
+                : new ArrayBuffer(Math.max(backing, baseOffset)));
+    }
+    /** @internal */
+    _rebind(buf) {
+        this._buf = buf;
+        this._u8 = u8s((this._d = new DataView(buf)));
+        return this;
+    }
+    sync() {
+        if (this.memory !== null && this.memory.buffer !== this._buf) {
+            this._rebind(this.memory.buffer);
+        }
+        return this;
+    }
+    get buffer() {
+        return this.sync()._buf;
+    }
+    get byteLength() {
+        return this.sync()._buf.byteLength;
+    }
+    get bytesUsed() {
+        return this.offset - this.baseOffset;
+    }
+    get u8() {
+        return this.sync()._u8;
+    }
+    get dataView() {
+        return this.sync()._d;
+    }
+    alignTo(align) {
+        return (this.offset = al(this.offset, align));
+    }
+    ensureCapacity(requiredByteLength) {
+        this.sync();
+        if (requiredByteLength <= this._buf.byteLength)
+            return this;
+        if (this.memory !== null) {
+            growMem(this.memory, requiredByteLength);
+            return this._rebind(this.memory.buffer);
+        }
+        const nb = new ArrayBuffer(Math.max(requiredByteLength, this._buf.byteLength * 2, 64));
+        new Uint8Array(nb).set(this._u8);
+        return this._rebind(nb);
+    }
+    /** @internal */
+    _alloc(bytes, align, zero = false) {
+        const p = this.alignTo(align), end = (this.offset = p + bytes);
+        this.ensureCapacity(end);
+        if (zero && bytes > 0)
+            this._u8.fill(0, p, end);
+        return p;
+    }
+    alloc(def, count = 1, zero = false) {
+        const p = this._alloc(count * def.size, def.align, zero);
+        initNulls(def, this._d, p, count);
+        const v = new StructArrayView(def, this, p, count, p);
+        v._tl = p + count * def.size;
+        return v;
+    }
+    allocOne(def, init) {
+        const p = this._alloc(def.size, def.align, true), v = new def._V(this._d, p, p, this);
+        initNulls(def, this._d, p);
+        return init !== undefined ? v.setAll(init) : v;
+    }
+    placeBytes(bytes, alignOrDef = 8) {
+        const u = u8s(bytes), p = this._alloc(u.byteLength, typeof alignOrDef === 'number' ? alignOrDef : alignOrDef.align);
+        this._u8.set(u, p);
+        return Object.defineProperties(new Uint8Array(this._buf, p, u.byteLength), {
+            ptr: hid(p),
+            as: hid((def, count = def.array(u).length) => {
+                const v = new StructArrayView(def, this, p, count, p);
+                v._tl = p + u.byteLength;
+                return v;
+            }),
+        });
+    }
+    view(def, byteOffset, baseOffset = byteOffset) {
+        return structView(def, this, byteOffset, baseOffset);
+    }
+    viewArray(def, byteOffset, count, baseOffset = byteOffset) {
+        return new StructArrayView(def, this, byteOffset, count, baseOffset);
+    }
+    reset(baseOffset = this.baseOffset) {
+        this.offset = baseOffset;
+        return this;
+    }
+}
+export const Arena = WasmArena;
+export class StructDef {
+    constructor(name, schemaOrBuilder) {
+        if (name)
+            _reg[name] = this;
+        const schema = typeof schemaOrBuilder === 'function' ? schemaOrBuilder((() => this)) : schemaOrBuilder;
+        if (!schema)
+            oob();
+        let off = 0, maxA = 1;
+        let firstV = -1, fvr = false;
+        const fObj = {};
+        const descs = { ...BASE_DESCS };
+        for (const [k, d] of Object.entries(schema)) {
+            const a = d.align;
+            maxA = Math.max(maxA, a);
+            const fo = (off = al(off, a));
+            fObj[k] = {
+                name: k,
+                desc: d,
+                offset: fo,
+                size: d.size,
+                align: a,
+            };
+            off += d.size;
+            const dk = d.kind;
+            if ((dk === 'str' || dk === 'slice' || dk === 'ref' || (dk === 'struct' && d._fv >= 0)) && firstV < 0) {
+                firstV = dk === 'struct' ? fo + d._fv : fo;
+                fvr = dk === 'ref';
+            }
+            const end = fo + d.size;
+            descs[k] = {
+                enumerable: true,
+                configurable: true,
+                get() {
+                    return end > this._ws
+                        ? defVal(d, false)
+                        : dk === 'primitive'
+                            ? d._g(this._k(), this._o + fo)
+                            : readVal(this, d, this._o + fo, false);
+                },
+                set(v) {
+                    if (end > this._ws)
+                        upgradeView(this);
+                    writeVal(this, d, v, this._b, this._o + fo);
+                },
+            };
+        }
+        const sz = al(off, maxA);
+        descs._ws = hid(sz);
+        class SpecializedStructView extends StructViewBase {
+            constructor(dv, b, o, m) {
+                super(descs, dv, b, o, m);
+            }
+        }
+        SpecializedStructView.prototype.def = this;
+        SpecializedStructView.prototype.byteLength = sz;
+        Object.assign(this, {
+            kind: 'struct',
+            name,
+            rustType: name || 'AnonStruct',
+            schema,
+            size: sz,
+            stride: sz,
+            align: maxA,
+            fields: fObj,
+            fieldList: Object.values(fObj),
+            _fv: firstV,
+            _fvr: fvr,
+            _V: SpecializedStructView,
+        });
+    }
+    offsetOf(field) {
+        return this.fields[field].offset;
+    }
+    /** Allocates a single `StructView<F>` backed by a fresh buffer and optionally initializes fields. */
+    create(init) {
+        const v = this.view(new ArrayBuffer(this.size));
+        initNulls(this, v._d, 0);
+        return init !== undefined ? v.setAll(init) : v;
+    }
+    /** Infers `Partial<StructInput<F>>` on a plain JS object literal (for building typed cyclic JS graphs without `any`). */
+    item(init) {
+        return init;
+    }
+    view(source, byteOffset, baseOffset, wireStride) {
+        return structView(this, source, byteOffset, baseOffset, wireStride);
+    }
+    /** Wraps a binary buffer in a zero-copy `StructArrayView<F>`. */
+    array(source, byteOffset, count, baseOffset, wireStride) {
+        return new StructArrayView(this, source, byteOffset, count, baseOffset, wireStride);
+    }
+    /** Allocates a growable `StructArrayView<F>` for `count` rows (pass `0` for an empty growable array). */
+    alloc(count, Ctor = ArrayBuffer) {
+        const a = this.array(new Ctor(count * this.size), 0, count);
+        initNulls(this, a._d, 0, count);
+        return a;
+    }
+    from(sourceOrRows) {
+        if (typeof sourceOrRows === 'number')
+            return this.alloc(sourceOrRows);
+        if (sourceOrRows instanceof StructArrayView)
+            return sourceOrRows;
+        if ('byteLength' in sourceOrRows || sourceOrRows?.buffer) {
+            return this.array(sourceOrRows);
+        }
+        return this.array(this.pack(Array.isArray(sourceOrRows)
+            ? sourceOrRows
+            : Array.from(sourceOrRows)));
+    }
+    shared(rowsOrCount) {
+        const B = typeof SharedArrayBuffer !== 'undefined'
+            ? SharedArrayBuffer
+            : ArrayBuffer;
+        if (typeof rowsOrCount === 'number')
+            return this.alloc(rowsOrCount, B);
+        const p = this.pack(rowsOrCount), sb = new B(p.byteLength);
+        new Uint8Array(sb).set(p);
+        return this.array(sb);
+    }
+    /** Allocates or packs a `StructArrayView<F>` directly inside `WebAssembly.Memory` (via `WasmArena` or exported `capn_alloc`/`alloc`) and returns `{ view, ptr, len, byteLength }`. */
+    inWasm(wasmMemoryOrExports, rowsOrCount) {
+        const exp = wasmMemoryOrExports?.exports ?? wasmMemoryOrExports, src = typeof rowsOrCount === 'number' ? null : this.from(rowsOrCount), u = src?.bytes, len = src ? src.length : rowsOrCount, byteLength = u ? u.byteLength : len * this.size, mem = exp._d ? exp : exp.memory ?? exp, fn = exp.capn_alloc ?? exp.alloc, ptr = exp._alloc
+            ? exp._alloc(byteLength, this.align)
+            : fn
+                ? byteLength && fn.call(exp, byteLength) >>> 0
+                : al(mem.offset ?? 64, this.align), end = (mem.offset = Math.max(mem.offset ?? 0, ptr + byteLength));
+        if (!exp._d)
+            growMem(mem, end);
+        const view = this.array(mem, ptr, len, ptr);
+        view._tl = end;
+        u ? u8s(view._d, ptr, byteLength).set(u) : (u8s(view._d, ptr, byteLength).fill(0), initNulls(this, view._d, ptr, len));
+        return { view, ptr, len, byteLength };
+    }
+    /** Packs an array of plain JavaScript objects or positional tuples into an 8-byte-aligned `Uint8Array`. */
+    pack(rows) {
+        return pack(this, rows);
+    }
+    concatBytes(chunks) {
+        return concatBytes(this, chunks);
+    }
+}
+/** Concatenates multiple `StructArrayView<F>` or `Uint8Array` chunks into a single packed `Uint8Array` via bulk `memcpy` when fixed-size. */
+export function concatBytes(def, chunks) {
+    if (def._fv >= 0)
+        return pack(def, chunks.flatMap((c) => def.from(c).toObjects()));
+    const slices = chunks.map((c) => c instanceof Uint8Array ? (c.byteLength % def.size && oob(), c) : c.stride === def.size ? c.bytes : c.compact());
+    const out = new Uint8Array(slices.reduce((s, b) => s + b.byteLength, 0));
+    let off = 0;
+    for (const s of slices)
+        (out.set(s, off), (off += s.byteLength));
+    return out;
+}
+/** Packs an array of plain JavaScript objects into an 8-byte-aligned `Uint8Array`. */
+export function pack(def, rows) {
+    const n = rows.length;
+    const st = def.size;
+    const tb = n * st;
+    const ts = def._fv >= 0 ? al(tb, 8) : tb;
+    ensureScratch(ts + n * 64 + 64);
+    sU8.fill(0, 0, ts);
+    tail = ts;
+    writeVal(null, { kind: 'array', element: def, length: n }, rows, 0, 0);
+    if (n && def._fv >= 0 && sDv.getUint32(def._fv, true) < ts) {
+        const h = sDv.getUint32(def._fv + 4, true) ? 4 : 0;
+        sDv.setUint32(def._fv + h, ts | (h >> 2), true);
+    }
+    const end = al(tail, 8);
+    sU8.fill(0, tail, end);
+    return sU8.slice(0, end);
+}
+export function defineStruct(nameOrFields, maybeFields) {
+    return typeof nameOrFields === 'string'
+        ? new StructDef(nameOrFields, maybeFields)
+        : new StructDef('', nameOrFields);
+}
+/** Alias for `defineStruct`. */
+export const struct = defineStruct;
+const _dtf = {
+    header(x) {
+        if (!(x instanceof MemView))
+            return null;
+        const n = x.def?.name || 'Struct';
+        if ('length' in x)
+            return ['span', {}, `${n}[${x.length}] (${x.usedByteLength} B)`];
+        const ks = Object.keys(x);
+        return ['span', {}, `${n} { ${ks.slice(0, 4).map((k) => `${k}: ${JSON.stringify(x[k])}`).join(', ')}${ks.length > 4 ? ', ...' : ''} }`];
+    },
+    hasBody: (x) => x instanceof MemView,
+    body: (x) => ['div', {}, ['object', { object: x.toJSON() }]],
+};
+/** Registers a lazy Chrome/Edge/Firefox DevTools custom formatter (`globalThis.devtoolsFormatters`) for `StructView` and `StructArrayView`. */
+export function installDevtoolsFormatter() {
+    const g = globalThis;
+    const list = (g.devtoolsFormatters ??= []);
+    if (!list.includes(_dtf))
+        list.push(_dtf);
+    return _dtf;
+}
+//# sourceMappingURL=index.js.map