@leofcoin/workers 1.5.44 → 1.6.0

package/exports/browser/binary-worker-BxQdEW3s.js

@@ -0,0 +1,672 @@
+class EasyWorker {
+    #messageEvent = 'message';
+    #errorEvent = 'error';
+    #isBrowser = false;
+    #isWorker = false;
+    #messageHandler = null;
+    #errorHandler = null;
+    worker;
+    get isWorker() {
+        return this.#isWorker;
+    }
+    constructor(url, options) {
+        return this.#init(url, options);
+    }
+    #init(url, options = {}) {
+        if (url) {
+            if (globalThis.Worker) {
+                this.#isBrowser = true;
+                this.worker = new Worker(url, { ...options });
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    import('child_process').then(({ fork }) => {
+                        const child = fork(url, ['easy-worker-child'], options);
+                        child.once('error', reject);
+                        this.worker = child;
+                        resolve(this);
+                    }).catch(reject);
+                });
+            }
+        }
+        else {
+            this.#isWorker = true;
+            if (globalThis.process?.argv[2] === 'easy-worker-child') {
+                this.worker = process;
+            }
+            else {
+                this.#isBrowser = true;
+                this.worker = globalThis;
+            }
+        }
+        return this;
+    }
+    onmessage(fn) {
+        if (this.#isBrowser) {
+            this.worker.onmessage = ({ data }) => fn(data);
+        }
+        else {
+            if (this.#messageHandler)
+                this.worker.off(this.#messageEvent, this.#messageHandler);
+            this.#messageHandler = fn;
+            this.worker.on(this.#messageEvent, fn);
+        }
+    }
+    postMessage(message) {
+        if (this.#isBrowser)
+            this.worker.postMessage(message);
+        else
+            this.worker.send(message);
+    }
+    terminate() {
+        if (this.#isBrowser)
+            this.worker.terminate();
+        else
+            this.worker.kill();
+    }
+    onerror(fn) {
+        if (this.#isBrowser) {
+            this.worker.onerror = fn;
+        }
+        else {
+            if (this.#errorHandler)
+                this.worker.off(this.#errorEvent, this.#errorHandler);
+            this.#errorHandler = fn;
+            this.worker.on(this.#errorEvent, fn);
+        }
+    }
+    /**
+     *
+     * @param {*} data
+     * @returns {Promise} resolves result onmessage & rejects on error
+     */
+    once(data) {
+        return new Promise((resolve, reject) => {
+            if (this.#isBrowser) {
+                const handleMessage = ({ data: result }) => {
+                    this.worker.onerror = null;
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.onmessage = null;
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.onmessage = handleMessage;
+                this.worker.onerror = handleError;
+            }
+            else {
+                const handleMessage = (result) => {
+                    this.worker.off(this.#errorEvent, handleError);
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.off(this.#messageEvent, handleMessage);
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.once(this.#messageEvent, handleMessage);
+                this.worker.once(this.#errorEvent, handleError);
+            }
+            this.postMessage(data);
+        });
+    }
+}
+
+/** @leofcoin/binary: dependency-free unsigned framing, with no global byte counters. */
+const MAX_BIGINT = (1n << 256n) - 1n;
+function size(value) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError('Expected an unsigned safe integer');
+}
+function bytes(value) {
+    if (!(value instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array');
+}
+function varUintLength(value) {
+    size(value);
+    let length = 1;
+    while (value >= 128) {
+        value = Math.floor(value / 128);
+        length++;
+    }
+    return length;
+}
+function varBigIntLength(value) {
+    if (typeof value !== 'bigint')
+        throw new TypeError('Expected BigInt');
+    if (value < 0n || value > MAX_BIGINT)
+        throw new RangeError('Expected an unsigned 256-bit integer');
+    let length = 1;
+    // Count whole eight-byte varint groups before the short tail.
+    while (value >= 0x100000000000000n) {
+        value >>= 56n;
+        length += 8;
+    }
+    while (value >= 128n) {
+        value >>= 7n;
+        length++;
+    }
+    return length;
+}
+/** Fixed-capacity writer. finish() is a view; copy it before reusing/resetting the writer. */
+class BinaryWriter {
+    #buffer;
+    #position = 0;
+    constructor(capacity = 64) {
+        if (typeof capacity === 'number') {
+            size(capacity);
+            this.#buffer = new Uint8Array(capacity);
+        }
+        else {
+            bytes(capacity);
+            this.#buffer = capacity;
+        }
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    #require(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Binary output buffer is too small');
+    }
+    writeVarUint(value) {
+        this.#require(varUintLength(value));
+        this.#writeVarUint(value);
+        return this;
+    }
+    #writeVarUint(value) {
+        while (value >= 128) {
+            this.#buffer[this.#position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        this.#buffer[this.#position++] = value;
+    }
+    writeVarBigInt(value) {
+        this.#require(varBigIntLength(value));
+        do {
+            const byte = Number(value & 127n);
+            value >>= 7n;
+            this.#buffer[this.#position++] = byte | (value ? 128 : 0);
+        } while (value);
+        return this;
+    }
+    writeBytes(value) {
+        bytes(value);
+        this.#require(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    writeFrame(value) {
+        bytes(value);
+        // Check the complete operation before writing its length prefix.
+        const prefixLength = varUintLength(value.length);
+        this.#require(prefixLength + value.length);
+        const prefixStart = this.#buffer.byteOffset + this.#position;
+        if (value.buffer === this.#buffer.buffer &&
+            value.byteOffset < prefixStart + prefixLength &&
+            value.byteOffset + value.length > prefixStart)
+            throw new RangeError('Frame source overlaps its length prefix');
+        this.#writeVarUint(value.length);
+        this.#buffer.set(value, this.#position);
+        this.#position += value.length;
+        return this;
+    }
+    reset() {
+        this.#position = 0;
+        return this;
+    }
+    finish(copy = false) {
+        const result = this.#buffer.subarray(0, this.#position);
+        // Buffer.slice() aliases memory; this constructor copies every Uint8Array subtype.
+        return copy ? new Uint8Array(result) : result;
+    }
+}
+/** Reads views of the original buffer. Failed operations leave the cursor unchanged. */
+class BinaryReader {
+    #buffer;
+    #position = 0;
+    constructor(buffer) {
+        bytes(buffer);
+        this.#buffer = buffer;
+    }
+    get position() {
+        return this.#position;
+    }
+    get remaining() {
+        return this.#buffer.length - this.#position;
+    }
+    readVarUint(canonical = true) {
+        let result = 0;
+        let multiplier = 1;
+        for (let index = 0; index < 8; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            const payload = byte & 127;
+            if (index === 7 && payload > Math.floor((Number.MAX_SAFE_INTEGER - result) / multiplier))
+                throw new RangeError('Varint exceeds safe integer range');
+            result += payload * multiplier;
+            if (byte < 128) {
+                if (canonical && index > 0 && payload === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+            multiplier *= 128;
+        }
+        throw new RangeError('Varint exceeds safe integer range');
+    }
+    readVarBigInt(canonical = true) {
+        let result = 0n;
+        for (let index = 0; index < 37; index++) {
+            const cursor = this.#position + index;
+            if (cursor >= this.#buffer.length)
+                throw new RangeError('Truncated varint');
+            const byte = this.#buffer[cursor];
+            result |= BigInt(byte & 127) << BigInt(index * 7);
+            if (result > MAX_BIGINT)
+                throw new RangeError('Varint exceeds 256 bits');
+            if (byte < 128) {
+                if (canonical && index > 0 && byte === 0)
+                    throw new RangeError('Non-canonical varint');
+                this.#position = cursor + 1;
+                return result;
+            }
+        }
+        throw new RangeError('Varint exceeds 256 bits');
+    }
+    readBytes(length) {
+        size(length);
+        if (length > this.remaining)
+            throw new RangeError('Truncated binary field');
+        const start = this.#position;
+        this.#position += length;
+        return this.#buffer.subarray(start, this.#position);
+    }
+    readFrame(canonical = true) {
+        const start = this.#position;
+        try {
+            return this.readBytes(this.readVarUint(canonical));
+        }
+        catch (error) {
+            this.#position = start;
+            throw error;
+        }
+    }
+}
+/** Existing smart-concat bytes, with exactly one output allocation and no prefix arrays. */
+function encodeFrames(frames, prefix) {
+    if (!Array.isArray(frames))
+        throw new TypeError('Expected an array of byte frames');
+    let length = 0;
+    for (const frame of frames) {
+        bytes(frame);
+        length += varUintLength(frame.length) + frame.length;
+        size(length);
+    }
+    const writer = new BinaryWriter(length);
+    for (const frame of frames)
+        writer.writeFrame(frame);
+    return writer.finish();
+}
+/** Iterative framing: bounded by the input length, not recursive stack depth. */
+function decodeFrames(buffer, prefixLength = 0, options = {}) {
+    const reader = new BinaryReader(buffer);
+    reader.readBytes(prefixLength);
+    const maxFrames = options.maxFrames ?? buffer.length;
+    size(maxFrames);
+    const frames = [];
+    while (reader.remaining) {
+        if (frames.length >= maxFrames)
+            throw new RangeError('Too many binary frames');
+        frames.push(reader.readFrame(options.canonical ?? true));
+    }
+    return frames;
+}
+
+const MAGIC = new Uint8Array([0x4c, 0x46, 0x43, 1]);
+const utf8 = new TextEncoder();
+const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const defaults = { maxBytes: 16 * 1024 * 1024, maxDepth: 64, maxNodes: 200000 };
+const BIGINT_LIMB = 1n << 49n;
+const BIGINT_MASK = BIGINT_LIMB - 1n;
+const limitsFor = (options) => {
+    const limits = { ...defaults, ...options };
+    for (const value of Object.values(limits))
+        if (!Number.isSafeInteger(value) || value < 1)
+            throw new RangeError('Invalid binary limits');
+    return limits;
+};
+/** Canonical UTF-8 length without allocating a temporary encoded string. */
+function stringLength(value, maximum) {
+    if (value.length > maximum)
+        throw new RangeError('Invalid binary string');
+    let length = value.length;
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code < 0x80)
+            continue;
+        if (code < 0x800) {
+            length++;
+            continue;
+        }
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const low = value.charCodeAt(++index);
+            if (!(low >= 0xdc00 && low <= 0xdfff))
+                throw new RangeError('Invalid binary string');
+            length += 2;
+        }
+        else {
+            if (code >= 0xdc00 && code <= 0xdfff)
+                throw new RangeError('Invalid binary string');
+            length += 2;
+        }
+    }
+    return length;
+}
+/** Versioned canonical typed values. Validation/planning allocates no byte buffers. */
+function encodeValue(value, options = {}) {
+    return encodeValueWithPrefix(value, EMPTY, options);
+}
+const EMPTY = new Uint8Array();
+/** Prepend an existing framing/codec header in the same allocation.
+ * maxBytes bounds the typed value (including MAGIC), as with encodeValue.
+ * The caller-owned prefix is separate framing and is copied, never retained.
+ */
+function encodeValueWithPrefix(value, prefix, options = {}) {
+    if (!(prefix instanceof Uint8Array))
+        throw new TypeError('Expected Uint8Array prefix');
+    const limits = limitsFor(options);
+    // Flat plan retains validated data-property values; writing never reads user properties again.
+    // Internal tag 11 is an untagged map key and is never emitted on the wire.
+    const plan = [];
+    const ancestors = new Set();
+    let size = MAGIC.length;
+    let nodes = 0;
+    const reserve = (length) => {
+        size += length;
+        if (size > limits.maxBytes)
+            throw new RangeError('Binary value exceeds byte limit');
+    };
+    const string = (value, tag) => {
+        const length = stringLength(value, limits.maxBytes);
+        reserve((tag === 7 ? 1 : 0) + varUintLength(length) + length);
+        plan.push(tag, value, length);
+    };
+    const visit = (value, depth) => {
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new RangeError('Binary value exceeds complexity limit');
+        if (value === undefined || value === null || typeof value === 'boolean') {
+            reserve(1);
+            plan.push(value === undefined ? 0 : value === null ? 1 : value === false ? 2 : 3);
+            return;
+        }
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value))
+                throw new TypeError('Binary numbers must be finite');
+            reserve(9);
+            plan.push(4, value);
+            return;
+        }
+        if (typeof value === 'bigint') {
+            const magnitude = value < 0n ? -value : value;
+            reserve(1 + varBigIntLength(magnitude));
+            plan.push(value < 0n ? 6 : 5, magnitude);
+            return;
+        }
+        if (typeof value === 'string')
+            return string(value, 7);
+        if (value instanceof Uint8Array) {
+            reserve(1 + varUintLength(value.length) + value.length);
+            plan.push(8, value, value.length);
+            return;
+        }
+        if (typeof value !== 'object')
+            throw new TypeError('Unsupported binary value');
+        if (ancestors.has(value))
+            throw new TypeError('Cyclic binary value');
+        ancestors.add(value);
+        try {
+            if (Array.isArray(value)) {
+                if (value.length > limits.maxNodes - nodes)
+                    throw new RangeError('Binary array exceeds node limit');
+                if (Object.keys(value).length !== value.length || Object.getOwnPropertySymbols(value).length)
+                    throw new TypeError('Binary arrays cannot have extra properties or holes');
+                reserve(1 + varUintLength(value.length));
+                plan.push(9, value.length);
+                for (let index = 0; index < value.length; index++) {
+                    const entry = Object.getOwnPropertyDescriptor(value, String(index));
+                    if (!entry || !('value' in entry))
+                        throw new TypeError('Sparse arrays and accessors are not binary values');
+                    visit(entry.value, depth + 1);
+                }
+            }
+            else {
+                const prototype = Object.getPrototypeOf(value);
+                if (prototype !== Object.prototype && prototype !== null)
+                    throw new TypeError('Binary maps must be plain objects');
+                const keys = Object.keys(value).sort();
+                if (Object.getOwnPropertySymbols(value).length)
+                    throw new TypeError('Symbol keys are not binary values');
+                if (keys.length > limits.maxNodes - nodes)
+                    throw new RangeError('Binary map exceeds node limit');
+                reserve(1 + varUintLength(keys.length));
+                plan.push(10, keys.length);
+                for (const key of keys) {
+                    const entry = Object.getOwnPropertyDescriptor(value, key);
+                    if (!('value' in entry))
+                        throw new TypeError('Accessors are not binary values');
+                    string(key, 11);
+                    visit(entry.value, depth + 1);
+                }
+            }
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    };
+    visit(value, 0);
+    const capacity = prefix.length + size;
+    if (!Number.isSafeInteger(capacity))
+        throw new RangeError('Binary output is too large');
+    const output = new Uint8Array(capacity);
+    output.set(prefix);
+    output.set(MAGIC, prefix.length);
+    let position = prefix.length + MAGIC.length;
+    let view;
+    const uint = (value) => {
+        while (value >= 128) {
+            output[position++] = value % 128 | 128;
+            value = Math.floor(value / 128);
+        }
+        output[position++] = value;
+    };
+    for (let cursor = 0; cursor < plan.length;) {
+        const tag = plan[cursor++];
+        if (tag !== 11)
+            output[position++] = tag;
+        if (tag < 4)
+            continue;
+        if (tag === 4) {
+            view ??= new DataView(output.buffer);
+            view.setFloat64(position, plan[cursor++], false);
+            position += 8;
+        }
+        else if (tag === 5 || tag === 6) {
+            let value = plan[cursor++];
+            // Seven varint bytes fit exactly in a safe-integer Number (49 bits).
+            // Extract one BigInt limb rather than shifting/masking BigInt for every byte.
+            while (value >= BIGINT_LIMB) {
+                let limb = Number(value & BIGINT_MASK);
+                for (let index = 0; index < 7; index++) {
+                    output[position++] = limb % 128 | 128;
+                    limb = Math.floor(limb / 128);
+                }
+                value >>= 49n;
+            }
+            uint(Number(value));
+        }
+        else if (tag === 7 || tag === 11) {
+            const value = plan[cursor++];
+            const length = plan[cursor++];
+            uint(length);
+            if (length === value.length) {
+                for (let index = 0; index < length; index++)
+                    output[position++] = value.charCodeAt(index);
+            }
+            else {
+                const result = utf8.encodeInto(value, output.subarray(position, position + length));
+                if (result.read !== value.length || result.written !== length)
+                    throw new Error('UTF-8 planning mismatch');
+                position += length;
+            }
+        }
+        else if (tag === 8) {
+            const value = plan[cursor++];
+            const length = plan[cursor++];
+            if (value.length !== length)
+                throw new RangeError('Byte input changed while encoding');
+            uint(length);
+            output.set(value, position);
+            position += length;
+        }
+        else {
+            uint(plan[cursor++]);
+        }
+    }
+    if (position !== capacity)
+        throw new Error('Binary planning mismatch');
+    return output;
+}
+/** Strict decoder: byte input, version, canonical ordering, bounds and complete consumption. */
+function decodeValue(input, options = {}) {
+    const limits = limitsFor(options);
+    if (!(input instanceof Uint8Array))
+        throw new TypeError('Wire payload must be Uint8Array');
+    if (input.length > limits.maxBytes)
+        throw new RangeError('Binary value exceeds byte limit');
+    const reader = new BinaryReader(input);
+    if (reader.readBytes(MAGIC.length).some((byte, index) => byte !== MAGIC[index]))
+        throw new TypeError('Unsupported binary wire version');
+    let nodes = 0;
+    const string = () => text.decode(reader.readFrame());
+    const read = (depth) => {
+        if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+            throw new RangeError('Binary value exceeds complexity limit');
+        const tag = reader.readBytes(1)[0];
+        if (tag === 0)
+            return undefined;
+        if (tag === 1)
+            return null;
+        if (tag === 2)
+            return false;
+        if (tag === 3)
+            return true;
+        if (tag === 4) {
+            const bytes = reader.readBytes(8);
+            const value = new DataView(bytes.buffer, bytes.byteOffset, 8).getFloat64(0, false);
+            if (!Number.isFinite(value))
+                throw new TypeError('Binary numbers must be finite');
+            return value;
+        }
+        if (tag === 5 || tag === 6) {
+            const value = reader.readVarBigInt();
+            if (tag === 6 && value === 0n)
+                throw new TypeError('Non-canonical negative zero');
+            return tag === 6 ? -value : value;
+        }
+        if (tag === 7)
+            return string();
+        if (tag === 8)
+            return new Uint8Array(reader.readFrame());
+        if (tag === 9 || tag === 10) {
+            const count = reader.readVarUint();
+            if (count > limits.maxNodes - nodes || count > reader.remaining)
+                throw new RangeError('Invalid binary collection size');
+            if (tag === 9)
+                return Array.from({ length: count }, () => read(depth + 1));
+            const result = {};
+            let previous;
+            for (let index = 0; index < count; index++) {
+                const key = string();
+                if (previous !== undefined && key <= previous)
+                    throw new TypeError('Non-canonical binary map keys');
+                previous = key;
+                Object.defineProperty(result, key, { value: read(depth + 1), enumerable: true, writable: true, configurable: true });
+            }
+            return result;
+        }
+        throw new TypeError('Unknown binary value tag');
+    };
+    const value = read(0);
+    if (reader.remaining)
+        throw new TypeError('Trailing binary data');
+    return value;
+}
+/** Domain separation prevents RPC bytes from being accepted as worker/chat/peer messages. */
+const encodeWire = (channel, value, limits) => encodeValue([channel, value], limits);
+function decodeWire(channel, bytes, limits) {
+    const envelope = decodeValue(bytes, limits);
+    if (!Array.isArray(envelope) || envelope.length !== 2 || envelope[0] !== channel)
+        throw new TypeError('Wrong binary message channel');
+    return envelope[1];
+}
+
+/** Decoded objects stay inside a process. Every actual IPC payload is canonical bytes. */
+class BinaryWorker {
+    #transport;
+    #errorHandler;
+    constructor(url, options = {}) {
+        const transport = new EasyWorker(url, { ...options, serialization: 'advanced' });
+        // EasyWorker's parent constructor is asynchronous, the child constructor is not.
+        if (transport && typeof transport.then === 'function')
+            return transport.then(value => { this.#transport = value; this.worker = value.worker; return this; });
+        this.#transport = transport;
+        this.worker = transport.worker;
+    }
+    postMessage(value) { this.#transport.postMessage(encodeWire('worker', value)); }
+    onmessage(handler) {
+        this.#transport.onmessage(bytes => {
+            let value;
+            try {
+                value = decodeWire('worker', bytes);
+            }
+            catch (error) {
+                if (this.#errorHandler)
+                    this.#errorHandler(error);
+                else
+                    throw error;
+                return;
+            }
+            handler(value);
+        });
+    }
+    onerror(handler) { this.#errorHandler = handler; this.#transport.onerror(handler); }
+    terminate() { return this.#transport.terminate(); }
+    async once(value) {
+        let timer;
+        try {
+            return await new Promise((resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('Binary worker request timed out')), 10000);
+                this.onerror(reject);
+                this.onmessage(resolve);
+                this.postMessage(value);
+            });
+        }
+        finally {
+            clearTimeout(timer);
+            this.terminate();
+        }
+    }
+}
+
+export { BinaryWorker as B, encodeValue as a, BinaryReader as b, BinaryWriter as c, decodeFrames as d, encodeFrames as e, encodeValueWithPrefix as f, decodeValue as g, varUintLength as v };

package/exports/browser/binary-worker.js

@@ -0,0 +1 @@
+export { B as default } from './binary-worker-BxQdEW3s.js';