toiljs 0.0.116 → 0.0.118

package/src/io/FastMap.ts

@@ -1,151 +0,0 @@
-/** A key usable with {@link FastMap}: any `PropertyKey` plus `bigint`. */
-export type PropertyExtendedKey = PropertyKey | bigint;
-
-/**
- * Like Record, but supports bigint keys (which JS auto-converts to strings).
- * Reflects actual JavaScript behavior where obj[123n] becomes obj["123"].
- */
-export type FastRecord<V> = {
-    [key: string]: V;
-};
-
-/** The string/number form a key takes once used to index the backing object. */
-export type IndexKey = string | number;
-
-/**
- * An insertion-ordered map backed by a key array plus a plain object, supporting
- * `bigint` keys (coerced to their string form, like native property access). Exposed
- * to the client as a global (no import). Implements `Disposable`, so a `using` binding
- * clears it on scope exit.
- */
-export class FastMap<K extends PropertyExtendedKey, V> implements Disposable {
-    protected _keys: K[] = [];
-    protected _values: FastRecord<V> = {};
-
-    /** @param iterable - initial entries, or another FastMap to copy. */
-    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | FastMap<K, V>) {
-        if (iterable instanceof FastMap) {
-            this.setAll(iterable);
-        } else {
-            if (iterable) {
-                for (const [key, value] of iterable) {
-                    this.set(key, value);
-                }
-            }
-        }
-    }
-
-    /** Number of entries. */
-    public get size(): number {
-        return this._keys.length;
-    }
-
-    /** Replaces all entries with a copy of `map`'s entries. */
-    public setAll(map: FastMap<K, V>): void {
-        this._keys = [...map._keys];
-        this._values = { ...map._values };
-    }
-
-    /** Merges `map`'s entries into this one (existing keys are overwritten). */
-    public addAll(map: FastMap<K, V>): void {
-        for (const [key, value] of map.entries()) {
-            this.set(key, value);
-        }
-    }
-
-    /** Iterates the keys in insertion order. */
-    public *keys(): IterableIterator<K> {
-        yield* this._keys;
-    }
-
-    /** Iterates the values in key-insertion order. */
-    public *values(): IterableIterator<V> {
-        for (const key of this._keys) {
-            yield this._values[key as IndexKey] as V;
-        }
-    }
-
-    /** Iterates `[key, value]` pairs in insertion order. */
-    public *entries(): IterableIterator<[K, V]> {
-        for (const key of this._keys) {
-            yield [key, this._values[key as IndexKey] as V];
-        }
-    }
-
-    /** Sets `key` to `value` (appending the key if new), and returns `this` for chaining. */
-    public set(key: K, value: V): this {
-        if (!this.has(key)) {
-            this._keys.push(key);
-        }
-
-        this._values[key as IndexKey] = value;
-
-        return this;
-    }
-
-    /** Returns the insertion index of `key`, or -1 if absent. */
-    public indexOf(key: K): number {
-        if (!this.has(key)) {
-            return -1;
-        }
-
-        for (let i = 0; i < this._keys.length; i++) {
-            if (this._keys[i] === key) {
-                return i;
-            }
-        }
-
-        throw new Error('Key not found, this should not happen.');
-    }
-
-    /** Returns the value for `key`, or `undefined` if absent. */
-    public get(key: K): V | undefined {
-        return this._values[key as IndexKey];
-    }
-
-    /** Whether `key` is present. */
-    public has(key: K): boolean {
-        return Object.prototype.hasOwnProperty.call(this._values, key as IndexKey);
-    }
-
-    /** Removes `key`; returns true if it was present. */
-    public delete(key: K): boolean {
-        if (!this.has(key)) {
-            return false;
-        }
-
-        const index = this.indexOf(key);
-        this._keys.splice(index, 1);
-
-        delete this._values[key as IndexKey];
-        return true;
-    }
-
-    /** Removes all entries. */
-    public clear(): void {
-        this._keys = [];
-        this._values = {};
-    }
-
-    /** `Disposable` hook: clears the map (so `using m = new FastMap()` frees it on scope exit). */
-    public [Symbol.dispose](): void {
-        this.clear();
-    }
-
-    /** Calls `callback(value, key, map)` for each entry in insertion order. */
-    public forEach(
-        callback: (value: V, key: K, map: FastMap<K, V>) => void,
-        thisArg?: unknown,
-    ): void {
-        for (const key of this._keys) {
-            callback.call(thisArg, this._values[key as IndexKey] as V, key, this);
-        }
-    }
-
-    /** Default iterator: `[key, value]` pairs in insertion order. */
-    *[Symbol.iterator](): IterableIterator<[K, V]> {
-        for (const key of this._keys) {
-            yield [key, this._values[key as IndexKey] as V];
-        }
-    }
-}

package/src/io/FastSet.ts

@@ -1,113 +0,0 @@
-import { type FastRecord, type IndexKey, type PropertyExtendedKey } from './FastMap.js';
-
-/**
- * The Set counterpart to {@link FastMap}: an insertion-ordered set backed by an array (for
- * iteration/ordering) plus a record index (for O(1) membership), with bigint-key support.
- *
- * Authored to match FastMap's design, the upstream package ships no `FastSet`. Implements
- * `Disposable`, so a `using` binding clears it on scope exit.
- */
-export class FastSet<T extends PropertyExtendedKey> implements Disposable {
-    protected _values: T[] = [];
-    protected _index: FastRecord<true> = {};
-
-    /** @param iterable - initial values, or another FastSet to copy. */
-    constructor(iterable?: Iterable<T> | null | FastSet<T>) {
-        if (iterable instanceof FastSet) {
-            this.addAll(iterable);
-        } else if (iterable) {
-            for (const value of iterable) {
-                this.add(value);
-            }
-        }
-    }
-
-    /** Number of values. */
-    public get size(): number {
-        return this._values.length;
-    }
-
-    /** Adds `value` if not already present, and returns `this` for chaining. */
-    public add(value: T): this {
-        if (!this.has(value)) {
-            this._values.push(value);
-            this._index[value as IndexKey] = true;
-        }
-
-        return this;
-    }
-
-    /** Whether `value` is present (O(1)). */
-    public has(value: T): boolean {
-        return Object.prototype.hasOwnProperty.call(this._index, value as IndexKey);
-    }
-
-    /** Returns the insertion index of `value`, or -1 if absent. */
-    public indexOf(value: T): number {
-        for (let i = 0; i < this._values.length; i++) {
-            if (this._values[i] === value) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    /** Removes `value`; returns true if it was present. */
-    public delete(value: T): boolean {
-        if (!this.has(value)) {
-            return false;
-        }
-
-        const index = this.indexOf(value);
-        if (index !== -1) {
-            this._values.splice(index, 1);
-        }
-
-        delete this._index[value as IndexKey];
-        return true;
-    }
-
-    /** Adds every value from `set`. */
-    public addAll(set: FastSet<T>): void {
-        for (const value of set.values()) {
-            this.add(value);
-        }
-    }
-
-    /** Iterates the values in insertion order. */
-    public *values(): IterableIterator<T> {
-        yield* this._values;
-    }
-
-    /** Iterates the values in insertion order (alias of {@link values}, for Map-like parity). */
-    public *keys(): IterableIterator<T> {
-        yield* this._values;
-    }
-
-    /** Calls `callback(value, value, set)` for each value in insertion order. */
-    public forEach(
-        callback: (value: T, value2: T, set: FastSet<T>) => void,
-        thisArg?: unknown,
-    ): void {
-        for (const value of this._values) {
-            callback.call(thisArg, value, value, this);
-        }
-    }
-
-    /** Removes all values. */
-    public clear(): void {
-        this._values = [];
-        this._index = {};
-    }
-
-    /** `Disposable` hook: clears the set (so `using s = new FastSet()` frees it on scope exit). */
-    public [Symbol.dispose](): void {
-        this.clear();
-    }
-
-    /** Default iterator: the values in insertion order. */
-    *[Symbol.iterator](): IterableIterator<T> {
-        yield* this._values;
-    }
-}

package/src/io/codec.ts

@@ -1,362 +0,0 @@
-/**
- * TypeScript side of the `@data` binary codec, byte-for-byte compatible with the
- * ToilScript `DataWriter`/`DataReader` in `std/assembly/data.ts`.
- *
- * Little-endian by default (wasm `store`/`load` are little-endian, so the ToilScript
- * side is near native and this matches it). Every multi-byte method takes an optional
- * `be` flag to read/write big-endian instead, for interop with big-endian wire
- * formats; the generated `@data` code never sets it, so the `@data` wire stays
- * little-endian. Strings and byte blobs are a `u32` byte-length prefix followed by the
- * bytes. `u128`/`i128` are two 64-bit limbs (low limb first in little-endian, high
- * limb first in big-endian), `u256`/`i256` four. The reader never throws: a read past
- * the end clears {@link DataReader.ok} and yields a zero/empty value.
- */
-
-const MASK64 = 0xffffffffffffffffn;
-const utf8Encoder = new TextEncoder();
-const utf8Decoder = new TextDecoder();
-
-/**
- * A growable little-endian (or big-endian, per the `be` flag) byte writer. Methods
- * return `this` so writes chain. The backing buffer doubles as needed; call
- * {@link toBytes} for an exact-length copy of what was written.
- */
-export class DataWriter {
-    // `ArrayBuffer`-backed (not the `ArrayBufferLike` default) so `toBytes()` yields a
-    // `Uint8Array<ArrayBuffer>`, which `fetch`/`Blob`/`Response` accept as a `BodyInit`.
-    private buf: Uint8Array<ArrayBuffer>;
-    private view: DataView;
-    private off = 0;
-
-    /** @param capacity - initial buffer size in bytes (grows automatically). */
-    constructor(capacity = 64) {
-        this.buf = new Uint8Array(capacity > 0 ? capacity : 1);
-        this.view = new DataView(this.buf.buffer);
-    }
-
-    /** Writes an unsigned 8-bit byte (the low 8 bits of `v`). */
-    writeU8(v: number): this {
-        const at = this.reserve(1);
-        this.view.setUint8(at, v & 0xff);
-        return this;
-    }
-
-    /** Writes an unsigned 16-bit integer. @param be - big-endian if true (default little-endian). */
-    writeU16(v: number, be?: boolean): this {
-        const at = this.reserve(2);
-        this.view.setUint16(at, v & 0xffff, !be);
-        return this;
-    }
-
-    /** Writes an unsigned 32-bit integer. @param be - big-endian if true (default little-endian). */
-    writeU32(v: number, be?: boolean): this {
-        const at = this.reserve(4);
-        this.view.setUint32(at, v >>> 0, !be);
-        return this;
-    }
-
-    /** Writes an unsigned 64-bit integer (low 64 bits of `v`). @param be - big-endian if true. */
-    writeU64(v: bigint, be?: boolean): this {
-        const at = this.reserve(8);
-        this.view.setBigUint64(at, v & MASK64, !be);
-        return this;
-    }
-
-    /** Writes a signed 8-bit integer. */
-    writeI8(v: number): this {
-        const at = this.reserve(1);
-        this.view.setInt8(at, v);
-        return this;
-    }
-
-    /** Writes a signed 16-bit integer. @param be - big-endian if true (default little-endian). */
-    writeI16(v: number, be?: boolean): this {
-        const at = this.reserve(2);
-        this.view.setInt16(at, v, !be);
-        return this;
-    }
-
-    /** Writes a signed 32-bit integer. @param be - big-endian if true (default little-endian). */
-    writeI32(v: number, be?: boolean): this {
-        const at = this.reserve(4);
-        this.view.setInt32(at, v | 0, !be);
-        return this;
-    }
-
-    /** Writes a signed 64-bit integer. @param be - big-endian if true (default little-endian). */
-    writeI64(v: bigint, be?: boolean): this {
-        const at = this.reserve(8);
-        this.view.setBigInt64(at, BigInt.asIntN(64, v), !be);
-        return this;
-    }
-
-    /** Writes a 32-bit float. @param be - big-endian if true (default little-endian). */
-    writeF32(v: number, be?: boolean): this {
-        const at = this.reserve(4);
-        this.view.setFloat32(at, v, !be);
-        return this;
-    }
-
-    /** Writes a 64-bit float. @param be - big-endian if true (default little-endian). */
-    writeF64(v: number, be?: boolean): this {
-        const at = this.reserve(8);
-        this.view.setFloat64(at, v, !be);
-        return this;
-    }
-
-    /** Writes a boolean as one byte (1 or 0). */
-    writeBool(v: boolean): this {
-        return this.writeU8(v ? 1 : 0);
-    }
-
-    /** Writes a `u32` length prefix followed by the raw bytes. @param be - endianness of the prefix. */
-    writeBytes(bytes: Uint8Array, be?: boolean): this {
-        this.writeU32(bytes.length, be);
-        if (bytes.length) {
-            const at = this.reserve(bytes.length);
-            this.buf.set(bytes, at);
-        }
-        return this;
-    }
-
-    /** Writes a `u32` byte-length prefix followed by the UTF-8 bytes. @param be - endianness of the prefix. */
-    writeString(value: string, be?: boolean): this {
-        const utf8 = utf8Encoder.encode(value);
-        this.writeU32(utf8.length, be);
-        if (utf8.length) {
-            const at = this.reserve(utf8.length);
-            this.buf.set(utf8, at);
-        }
-        return this;
-    }
-
-    /** Writes an unsigned 128-bit integer as two 64-bit limbs. @param be - big-endian if true. */
-    writeU128(v: bigint, be?: boolean): this {
-        return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be);
-    }
-
-    /** Writes a signed 128-bit integer as two 64-bit limbs (two's complement). @param be - big-endian if true. */
-    writeI128(v: bigint, be?: boolean): this {
-        return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be);
-    }
-
-    /** Writes an unsigned 256-bit integer as four 64-bit limbs. @param be - big-endian if true. */
-    writeU256(v: bigint, be?: boolean): this {
-        return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be);
-    }
-
-    /** Writes a signed 256-bit integer as four 64-bit limbs (two's complement). @param be - big-endian if true. */
-    writeI256(v: bigint, be?: boolean): this {
-        return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be);
-    }
-
-    /** Number of bytes written so far. */
-    length(): number {
-        return this.off;
-    }
-
-    /** A fresh copy of exactly the bytes written. */
-    toBytes(): Uint8Array<ArrayBuffer> {
-        return this.buf.slice(0, this.off);
-    }
-
-    /**
-     * Ensures room for `extra` more bytes and returns the offset to write at. Grows
-     * (doubling) when needed, reassigning `buf`/`view`. Callers MUST read the returned
-     * offset into a local before touching `this.view`/`this.buf`, since a grow swaps
-     * them out from under a stale receiver.
-     */
-    private reserve(extra: number): number {
-        const need = this.off + extra;
-        if (need > this.buf.length) {
-            let n = this.buf.length;
-            while (n < need) n <<= 1;
-            const bigger = new Uint8Array(n);
-            bigger.set(this.buf.subarray(0, this.off));
-            this.buf = bigger;
-            this.view = new DataView(this.buf.buffer);
-        }
-        const at = this.off;
-        this.off += extra;
-        return at;
-    }
-
-    /** Writes the `count` 64-bit limbs of `u` (low limb first in LE, high limb first in BE). */
-    private writeLimbs(u: bigint, count: number, be: boolean): this {
-        if (be) {
-            for (let i = count - 1; i >= 0; i--)
-                this.writeU64((u >> BigInt(i * 64)) & MASK64, true);
-        } else {
-            for (let i = 0; i < count; i++) this.writeU64((u >> BigInt(i * 64)) & MASK64, false);
-        }
-        return this;
-    }
-}
-
-/**
- * Reads values written by {@link DataWriter}. Never throws: a read past the end
- * clears {@link ok} and returns a zero/empty value, so a truncated or hostile buffer
- * fails closed rather than crashing. Defaults to little-endian; pass `be` to match a
- * big-endian writer.
- */
-export class DataReader {
-    /** Cleared to false if any read ran past the end of the buffer. */
-    ok = true;
-    private buf: Uint8Array;
-    private view: DataView;
-    private off = 0;
-
-    /** @param bytes - the buffer to read from (its byteOffset/length are respected). */
-    constructor(bytes: Uint8Array) {
-        this.buf = bytes;
-        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    }
-
-    /** Reads an unsigned 8-bit byte (0 past end). */
-    readU8(): number {
-        if (!this.has(1)) return 0;
-        const v = this.view.getUint8(this.off);
-        this.off += 1;
-        return v;
-    }
-
-    /** Reads an unsigned 16-bit integer. @param be - big-endian if true (default little-endian). */
-    readU16(be?: boolean): number {
-        if (!this.has(2)) return 0;
-        const v = this.view.getUint16(this.off, !be);
-        this.off += 2;
-        return v;
-    }
-
-    /** Reads an unsigned 32-bit integer. @param be - big-endian if true (default little-endian). */
-    readU32(be?: boolean): number {
-        if (!this.has(4)) return 0;
-        const v = this.view.getUint32(this.off, !be);
-        this.off += 4;
-        return v >>> 0;
-    }
-
-    /** Reads an unsigned 64-bit integer. @param be - big-endian if true (default little-endian). */
-    readU64(be?: boolean): bigint {
-        if (!this.has(8)) return 0n;
-        const v = this.view.getBigUint64(this.off, !be);
-        this.off += 8;
-        return v;
-    }
-
-    /** Reads a signed 8-bit integer (0 past end). */
-    readI8(): number {
-        if (!this.has(1)) return 0;
-        const v = this.view.getInt8(this.off);
-        this.off += 1;
-        return v;
-    }
-
-    /** Reads a signed 16-bit integer. @param be - big-endian if true (default little-endian). */
-    readI16(be?: boolean): number {
-        if (!this.has(2)) return 0;
-        const v = this.view.getInt16(this.off, !be);
-        this.off += 2;
-        return v;
-    }
-
-    /** Reads a signed 32-bit integer. @param be - big-endian if true (default little-endian). */
-    readI32(be?: boolean): number {
-        if (!this.has(4)) return 0;
-        const v = this.view.getInt32(this.off, !be);
-        this.off += 4;
-        return v;
-    }
-
-    /** Reads a signed 64-bit integer. @param be - big-endian if true (default little-endian). */
-    readI64(be?: boolean): bigint {
-        if (!this.has(8)) return 0n;
-        const v = this.view.getBigInt64(this.off, !be);
-        this.off += 8;
-        return v;
-    }
-
-    /** Reads a 32-bit float. @param be - big-endian if true (default little-endian). */
-    readF32(be?: boolean): number {
-        if (!this.has(4)) return 0;
-        const v = this.view.getFloat32(this.off, !be);
-        this.off += 4;
-        return v;
-    }
-
-    /** Reads a 64-bit float. @param be - big-endian if true (default little-endian). */
-    readF64(be?: boolean): number {
-        if (!this.has(8)) return 0;
-        const v = this.view.getFloat64(this.off, !be);
-        this.off += 8;
-        return v;
-    }
-
-    /** Reads a boolean (any non-zero byte is true). */
-    readBool(): boolean {
-        return this.readU8() !== 0;
-    }
-
-    /** Reads a `u32`-length-prefixed byte blob (empty past end). @param be - endianness of the prefix. */
-    readBytes(be?: boolean): Uint8Array {
-        const len = this.readU32(be);
-        if (!this.has(len)) return new Uint8Array(0);
-        const out = this.buf.slice(this.off, this.off + len);
-        this.off += len;
-        return out;
-    }
-
-    /** Reads a `u32`-byte-length-prefixed UTF-8 string (empty past end). @param be - endianness of the prefix. */
-    readString(be?: boolean): string {
-        const len = this.readU32(be);
-        if (!this.has(len)) return '';
-        const s = utf8Decoder.decode(this.buf.subarray(this.off, this.off + len));
-        this.off += len;
-        return s;
-    }
-
-    /** Reads an unsigned 128-bit integer. @param be - big-endian if true (default little-endian). */
-    readU128(be?: boolean): bigint {
-        return this.readLimbs(2, !!be);
-    }
-
-    /** Reads a signed 128-bit integer (two's complement). @param be - big-endian if true. */
-    readI128(be?: boolean): bigint {
-        return BigInt.asIntN(128, this.readLimbs(2, !!be));
-    }
-
-    /** Reads an unsigned 256-bit integer. @param be - big-endian if true (default little-endian). */
-    readU256(be?: boolean): bigint {
-        return this.readLimbs(4, !!be);
-    }
-
-    /** Reads a signed 256-bit integer (two's complement). @param be - big-endian if true. */
-    readI256(be?: boolean): bigint {
-        return BigInt.asIntN(256, this.readLimbs(4, !!be));
-    }
-
-    /** Bytes left to read. */
-    remaining(): number {
-        return this.buf.length - this.off;
-    }
-
-    /** Returns true (and leaves `off` advanceable) if `n` more bytes are available; else clears `ok`. */
-    private has(n: number): boolean {
-        if (n < 0 || this.off + n > this.buf.length) {
-            this.ok = false;
-            return false;
-        }
-        return true;
-    }
-
-    /** Reads `count` 64-bit limbs and recombines them (low limb first in LE, high first in BE). */
-    private readLimbs(count: number, be: boolean): bigint {
-        let result = 0n;
-        if (be) {
-            for (let i = count - 1; i >= 0; i--) result |= this.readU64(true) << BigInt(i * 64);
-        } else {
-            for (let i = 0; i < count; i++) result |= this.readU64(false) << BigInt(i * 64);
-        }
-        return result;
-    }
-}

package/src/io/index.ts

@@ -1,10 +0,0 @@
-/**
- * toiljs IO, native binary serialization + fast collections, exposed to the client both as
- * `toiljs/io` imports and as ambient globals (see the generated `.toil/toil-env.d.ts`).
- */
-export { FastMap } from './FastMap.js';
-export { FastSet } from './FastSet.js';
-export { DataWriter, DataReader } from './codec.js';
-
-export type { PropertyExtendedKey, FastRecord, IndexKey } from './FastMap.js';
-export type { i8, i16, i32, i64, u8, u16, u32, u64, Selector, BufferLike } from './types.js';

package/src/io/lengths.ts

@@ -1,14 +0,0 @@
-/** Byte widths for the fixed-size integer types written/read by the binary IO classes. */
-export const U8_BYTE_LENGTH = 1;
-export const U16_BYTE_LENGTH = 2;
-export const U32_BYTE_LENGTH = 4;
-export const U64_BYTE_LENGTH = 8;
-
-export const I8_BYTE_LENGTH = 1;
-export const I16_BYTE_LENGTH = 2;
-export const I32_BYTE_LENGTH = 4;
-export const I64_BYTE_LENGTH = 8;
-
-export const U128_BYTE_LENGTH = 16;
-export const I128_BYTE_LENGTH = 16;
-export const U256_BYTE_LENGTH = 32;

package/src/io/types.ts

@@ -1,19 +0,0 @@
-/**
- * Branded numeric width aliases used by the binary IO classes. They are plain `number`/`bigint`
- * at runtime, the names document intent.
- */
-export type i8 = number;
-export type i16 = number;
-export type i32 = number;
-export type i64 = bigint;
-
-export type u8 = number;
-export type u16 = number;
-export type u32 = number;
-export type u64 = bigint;
-
-/** A method/route selector encoded as a `u32` on the wire. */
-export type Selector = number;
-
-/** Anything that can back a {@link DataReader}. */
-export type BufferLike = Uint8Array;

package/src/logger/index.ts

@@ -1,22 +0,0 @@
-/**
- * Minimal logger placeholder for toiljs. Swapped for the real implementation later.
- */
-
-export enum LogLevel {
-    Debug = 'debug',
-    Info = 'info',
-    Warn = 'warn',
-    Error = 'error',
-}
-
-export class Logger {
-    public constructor(private readonly scope: string = 'toil') {}
-
-    public log(level: LogLevel, message: string): void {
-        console.log(`[${this.scope}] ${level}: ${message}`);
-    }
-
-    public info(message: string): void {
-        this.log(LogLevel.Info, message);
-    }
-}