@leofcoin/workers 1.5.43 → 1.6.0

package/exports/browser/{worker-BDTWOCzS.js → proposal.proto-8zgMfutf.js}

@@ -1,4 +1,9 @@
-var proto$3 = {
+import { e as encodeFrames, d as decodeFrames, b as BinaryReader, c as BinaryWriter, v as varUintLength, a as encodeValue, f as encodeValueWithPrefix, g as decodeValue } from './binary-worker-BxQdEW3s.js';
+
+/** Freeze declarations, not decoded messages. Keep existing consumer field types mutable. */
+const defineSchema = (proto) => Object.freeze(proto);
+
+var proto$2 = defineSchema({
     index: BigInt(0),
     previousHash: String(),
     timestamp: Number(),
@@ -9,7 +14,7 @@ var proto$3 = {
     producer: String(),
     producerProof: String(),
     protocolVersion: String()
-};
+});
 
 // base-x encoding / decoding
 // Copyright (c) 2018 base-x contributors
@@ -440,219 +445,6 @@ var isHex = string => /^[A-F0-9]+$/i.test(
   string
 );
 
-/** @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;
-    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 asBytes = (source) => {
     if (source instanceof Uint8Array)
         return source;
@@ -8212,7 +8004,7 @@ const utils = {
     codecs: registry
 };
 
-class Codec extends BasicInterface {
+let Codec$1 = class Codec extends BasicInterface {
     codecBuffer;
     codec;
     hashAlg;
@@ -8313,7 +8105,7 @@ class Codec extends BasicInterface {
         this.encoded = new BinaryWriter(varUintLength(codec)).writeVarUint(codec).finish();
         return this.encoded;
     }
-}
+};
 
 /*!
  * hash-wasm (https://www.npmjs.com/package/hash-wasm)
@@ -8985,7 +8777,7 @@ class CodecHash extends BasicInterface {
             this.name = name;
         if (!buffer)
             throw new Error('buffer is required for encoding');
-        this.discoCodec = new Codec(this.name);
+        this.discoCodec = new Codec$1(this.name);
         let hashAlg = this.discoCodec.hashAlg;
         const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
         if (hashAlg.includes('dbl')) {
@@ -9014,7 +8806,7 @@ class CodecHash extends BasicInterface {
         buffer = buffer ?? this.encoded;
         // Validate completely before changing this instance, including cached encodings.
         const header = hashHeader(buffer);
-        const codec = new Codec(header.name);
+        const codec = new Codec$1(header.name);
         const digest = new Uint8Array(buffer.subarray(header.offset));
         this.#clearEncodingCache();
         this.encoded = buffer;
@@ -9054,13 +8846,13 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     hasCodec() {
         if (!this.encoded)
             return false;
-        const codec = new Codec(this.encoded);
+        const codec = new Codec$1(this.encoded);
         if (codec.name)
             return true;
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = new Codec(encoded);
+        const codec = new Codec$1(encoded);
         if (codec.codecBuffer) {
             encoded = encoded.slice(codec.codecBuffer.length);
             this.name = codec.name;
@@ -9078,7 +8870,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     encode(decoded) {
         let encoded;
         decoded = decoded || this.decoded;
-        const codec = new Codec(this.name);
+        const codec = new Codec$1(this.name);
         if (decoded instanceof Uint8Array)
             encoded = decoded;
         else
@@ -9117,7 +8909,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     get contentBytes() {
         if (!this.encoded)
             return new Uint8Array(0);
-        const codec = new Codec(this.encoded);
+        const codec = new Codec$1(this.encoded);
         if (codec.codecBuffer) {
             return this.encoded.slice(codec.codecBuffer.length);
         }
@@ -9198,37 +8990,182 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
  * Interface for defining codec formats
  */
 const FormatInterface = FormatInterface$1;
+/**
+ * Codec utility class
+ */
+const Codec = Codec$1;
+
+const schemas = new WeakMap();
+const kindOf = (value) => value === undefined ? 'any'
+    : value instanceof Uint8Array ? 'bytes' : Array.isArray(value) ? 'array' : typeof value;
+function schemaFor(proto) {
+    const cached = schemas.get(proto);
+    if (cached)
+        return cached;
+    const keys = Object.keys(proto);
+    const schema = {
+        fields: keys.map(key => ({
+            key, name: key.endsWith('?') ? key.slice(0, -1) : key, kind: kindOf(proto[key])
+        })),
+        prefixes: new Map()
+    };
+    // Only immutable declarations can safely reuse keys, types and codec framing.
+    // Caller-defined mutable schemas remain supported and are recompiled per operation.
+    if (Object.isFrozen(proto) && keys.every(key => 'value' in Object.getOwnPropertyDescriptor(proto, key)))
+        schemas.set(proto, schema);
+    return schema;
+}
+function codecPrefix(schema, name) {
+    let prefix = schema.prefixes.get(name);
+    if (!prefix) {
+        const codec = new Codec(name);
+        if (!codec.codecBuffer)
+            throw new Error('invalid codec');
+        prefix = new Uint8Array(codec.codecBuffer);
+        schema.prefixes.set(name, prefix);
+    }
+    return prefix;
+}
+/** Codec prefix + versioned binary tuple, in declared schema order. No proto-array JSON. */
+class BinaryFormat extends FormatInterface {
+    field(key, value, kind) {
+        if (value === undefined)
+            return value;
+        kind ??= kindOf(this.proto[key]);
+        if (kind === 'any')
+            return value;
+        if (kind === 'bigint') {
+            if (typeof value === 'number' && !Number.isSafeInteger(value))
+                throw new TypeError('Unsafe integer message field');
+            if (!['number', 'string', 'bigint'].includes(typeof value))
+                throw new TypeError('Invalid BigInt message field');
+            return BigInt(value);
+        }
+        if (kind === 'bytes') {
+            if (!(value instanceof Uint8Array))
+                throw new TypeError('Message byte field must be Uint8Array');
+        }
+        else if (kind === 'array') {
+            if (!Array.isArray(value))
+                throw new TypeError('Message array field must be an array');
+        }
+        else if (typeof value !== kind || value === null)
+            throw new TypeError('Message field type mismatch');
+        return value;
+    }
+    create(value) {
+        const { fields } = schemaFor(this.proto);
+        // Content hashes are derived, never trusted from a caller-supplied cache field.
+        this.decoded = Object.fromEntries(fields.map(field => {
+            const input = value?.[field.name];
+            return [field.name, field.kind === 'bigint' ? this.field(field.key, input, field.kind) : input];
+        }));
+    }
+    tuple(value, fields) {
+        const tuple = new Array(fields.length);
+        for (let index = 0; index < fields.length; index++) {
+            const field = fields[index];
+            tuple[index] = this.field(field.key, value[field.name], field.kind);
+        }
+        return tuple;
+    }
+    protoEncode(value) {
+        return encodeValue(this.tuple(value, schemaFor(this.proto).fields));
+    }
+    encode(value) {
+        value = value || this.decoded;
+        const schema = schemaFor(this.proto);
+        const prefix = codecPrefix(schema, this.name);
+        if (value instanceof Uint8Array) {
+            // Preserve the base interface's already-encoded-content path.
+            const output = new Uint8Array(prefix.length + value.length);
+            output.set(prefix);
+            output.set(value, prefix.length);
+            this.encoded = output;
+        }
+        else {
+            this.encoded = encodeValueWithPrefix(this.tuple(value, schema.fields), prefix);
+        }
+        return this.encoded;
+    }
+    protoDecode(bytes) {
+        const values = decodeValue(bytes);
+        const { fields } = schemaFor(this.proto);
+        if (!Array.isArray(values) || values.length !== fields.length)
+            throw new TypeError('Binary message schema mismatch');
+        return Object.fromEntries(fields.map((field, index) => {
+            const value = this.field(field.key, values[index], field.kind);
+            if (typeof value !== typeof values[index])
+                throw new TypeError('Non-canonical message field type');
+            return [field.name, value];
+        }));
+    }
+    decode(bytes) {
+        bytes ??= this.encoded;
+        if (!(bytes instanceof Uint8Array))
+            throw new TypeError('Message payload must be Uint8Array');
+        const codec = new Codec(bytes);
+        if (codec.name !== this.name)
+            throw new TypeError('Wrong binary message codec');
+        // Parse the codec once and borrow its content view; decoded byte fields still own copies.
+        this.decoded = this.protoDecode(bytes.subarray(codec.codecBuffer.length));
+        return this.decoded;
+    }
+    fromUint8Array(bytes) { this.encoded = bytes; return this.decode(bytes); }
+    fromArrayBuffer(buffer) { return this.fromUint8Array(new Uint8Array(buffer)); }
+}
 
-var proto$2 = {
+var proto$1 = defineSchema({
     address: String(),
     reward: BigInt(0)
-};
+});
 
-({
-    epoch: BigInt(0)});
+defineSchema({
+    epoch: BigInt(0),
+    configDigest: String(),
+    from: String(),
+    signature: String()
+});
 
-({
+defineSchema({
     epoch: BigInt(0),
     threshold: BigInt(0),
     participant: BigInt(0),
-    commitments: Array()});
+    from: String(),
+    commitments: Array(),
+    signature: String()
+});
 
-({
+defineSchema({
     epoch: BigInt(0),
     round: BigInt(0),
-    participant: BigInt(0)});
+    participant: BigInt(0),
+    from: String(),
+    signatureShare: String(),
+    signature: String()
+});
+
+defineSchema({
+    up: Number(),
+    down: Number()
+});
+
+defineSchema({});
 
-var proto$1 = {
+var proto = defineSchema({
     creator: String(),
     contract: new Uint8Array(),
     constructorParameters: Array()
-};
+});
 
-({
+defineSchema({
+    hash: String(),
     index: BigInt(0)
 });
 
-var proto = {
+defineSchema({});
+
+defineSchema({
     timestamp: Number(),
     from: String(),
     to: String(),
@@ -9238,138 +9175,44 @@ var proto = {
     'nonce?': Number(),
     'dependsOn?': Array(),
     'priority?': Boolean()
-};
+});
 
-({
-    params: Array()});
+defineSchema({
+    timestamp: Number(),
+    from: String(),
+    to: String(),
+    method: String(),
+    params: Array(),
+    'nonce?': Number()
+});
 
-({
+defineSchema({
+    lastblock: Object(),
+    values: Object()
+});
+
+defineSchema({
+    blockHash: String(),
     index: BigInt(0),
-    round: BigInt(0)});
+    round: BigInt(0),
+    from: String(),
+    signature: String()
+});
 
-({
+defineSchema({
+    blockHash: String(),
     index: BigInt(0),
-    round: BigInt(0)});
+    round: BigInt(0),
+    from: String(),
+    signature: String()
+});
 
-({
+defineSchema({
+    blockHash: String(),
     index: BigInt(0),
-    round: BigInt(0)});
-
-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);
-        });
-    }
-}
+    round: BigInt(0),
+    from: String(),
+    signature: String()
+});
 
-export { EasyWorker as E, FormatInterface as F, proto$3 as a, proto$1 as b, proto as c, decodeFrames as d, encodeFrames as e, jsonParseBigInt$1 as f, jsonStringifyBigInt$1 as j, proto$2 as p };
+export { BinaryFormat as B, proto$2 as a, proto as b, jsonStringifyBigInt$1 as j, proto$1 as p };