@aztec/bb.js 3.0.0-nightly.20251030 → 3.0.0-nightly.20251030-2

package/dest/node/barretenberg_wasm/barretenberg_wasm_base/index.js

@@ -0,0 +1,125 @@
+import { createDebugLogger } from '../../log/index.js';
+import { randomBytes } from '../../random/index.js';
+/**
+ * Base implementation of BarretenbergWasm.
+ * Contains code that is common to the "main thread" implementation and the "child thread" implementation.
+ */
+export class BarretenbergWasmBase {
+    constructor() {
+        this.memStore = {};
+        this.logger = createDebugLogger('bb_wasm_base');
+    }
+    getImportObj(memory) {
+        /* eslint-disable camelcase */
+        const importObj = {
+            // We need to implement a part of the wasi api:
+            // https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
+            // We literally only need to support random_get, everything else is noop implementated in barretenberg.wasm.
+            wasi_snapshot_preview1: {
+                random_get: (out, length) => {
+                    out = out >>> 0;
+                    const randomData = randomBytes(length);
+                    const mem = this.getMemory();
+                    mem.set(randomData, out);
+                },
+                clock_time_get: (a1, a2, out) => {
+                    out = out >>> 0;
+                    const ts = BigInt(new Date().getTime()) * 1000000n;
+                    const view = new DataView(this.getMemory().buffer);
+                    view.setBigUint64(out, ts, true);
+                },
+                proc_exit: () => {
+                    this.logger('PANIC: proc_exit was called.');
+                    throw new Error();
+                },
+            },
+            // These are functions implementations for imports we've defined are needed.
+            // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
+            env: {
+                /**
+                 * The 'info' call we use for logging in C++, calls this under the hood.
+                 * The native code will just print to std:err (to avoid std::cout which is used for IPC).
+                 * Here we just emit the log line for the client to decide what to do with.
+                 */
+                logstr: (addr) => {
+                    const str = this.stringFromAddress(addr);
+                    const m = this.getMemory();
+                    const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
+                    this.logger(str2);
+                },
+                throw_or_abort_impl: (addr) => {
+                    const str = this.stringFromAddress(addr);
+                    throw new Error(str);
+                },
+                get_data: (keyAddr, outBufAddr) => {
+                    const key = this.stringFromAddress(keyAddr);
+                    outBufAddr = outBufAddr >>> 0;
+                    const data = this.memStore[key];
+                    if (!data) {
+                        this.logger(`get_data miss ${key}`);
+                        return;
+                    }
+                    // this.logger(`get_data hit ${key} size: ${data.length} dest: ${outBufAddr}`);
+                    // this.logger(Buffer.from(data.slice(0, 64)).toString('hex'));
+                    this.writeMemory(outBufAddr, data);
+                },
+                set_data: (keyAddr, dataAddr, dataLength) => {
+                    const key = this.stringFromAddress(keyAddr);
+                    dataAddr = dataAddr >>> 0;
+                    this.memStore[key] = this.getMemorySlice(dataAddr, dataAddr + dataLength);
+                    // this.logger(`set_data: ${key} length: ${dataLength}`);
+                },
+                memory,
+            },
+        };
+        /* eslint-enable camelcase */
+        return importObj;
+    }
+    exports() {
+        return this.instance.exports;
+    }
+    /**
+     * When returning values from the WASM, use >>> operator to convert signed representation to unsigned representation.
+     */
+    call(name, ...args) {
+        if (!this.exports()[name]) {
+            throw new Error(`WASM function ${name} not found.`);
+        }
+        try {
+            return this.exports()[name](...args) >>> 0;
+        }
+        catch (err) {
+            const message = `WASM function ${name} aborted, error: ${err}`;
+            this.logger(message);
+            this.logger(err.stack);
+            throw err;
+        }
+    }
+    memSize() {
+        return this.getMemory().length;
+    }
+    /**
+     * Returns a copy of the data, not a view.
+     */
+    getMemorySlice(start, end) {
+        return this.getMemory().subarray(start, end).slice();
+    }
+    writeMemory(offset, arr) {
+        const mem = this.getMemory();
+        mem.set(arr, offset);
+    }
+    getMemory() {
+        return new Uint8Array(this.memory.buffer);
+    }
+    // PRIVATE METHODS
+    stringFromAddress(addr) {
+        addr = addr >>> 0;
+        const m = this.getMemory();
+        let i = addr;
+        for (; m[i] !== 0; ++i)
+            ;
+        const textDecoder = new TextDecoder('ascii');
+        return textDecoder.decode(m.slice(addr, i));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/browser/index.d.ts

@@ -0,0 +1,2 @@
+export declare function createMainWorker(): Promise<Worker>;
+//# sourceMappingURL=index.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/barretenberg_wasm/barretenberg_wasm_main/factory/browser/index.ts"],"names":[],"mappings":"AAGA,wBAAsB,gBAAgB,oBAOrC"}

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/browser/index.js

@@ -0,0 +1,11 @@
+import { logOptions } from '../../../../log/index.js';
+import { readinessListener } from '../../../helpers/browser/index.js';
+export async function createMainWorker() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const worker = new Worker(new URL('./main.worker.js', import.meta.url), { type: 'module' });
+    worker.postMessage({ log: logOptions });
+    await new Promise(resolve => readinessListener(worker, resolve));
+    return worker;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYmFycmV0ZW5iZXJnX3dhc20vYmFycmV0ZW5iZXJnX3dhc21fbWFpbi9mYWN0b3J5L2Jyb3dzZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBRXRFLE1BQU0sQ0FBQyxLQUFLLFVBQVUsZ0JBQWdCO0lBQ3BDLDZEQUE2RDtJQUM3RCxhQUFhO0lBQ2IsTUFBTSxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxHQUFHLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzVGLE1BQU0sQ0FBQyxXQUFXLENBQUMsRUFBRSxHQUFHLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUN4QyxNQUFNLElBQUksT0FBTyxDQUFPLE9BQU8sQ0FBQyxFQUFFLENBQUMsaUJBQWlCLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDdkUsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQyJ9

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/browser/main.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.worker.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/browser/main.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.worker.d.ts","sourceRoot":"","sources":["../../../../../../src/barretenberg_wasm/barretenberg_wasm_main/factory/browser/main.worker.ts"],"names":[],"mappings":""}

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/browser/main.worker.js

@@ -0,0 +1,12 @@
+import { expose } from 'comlink';
+import { BarretenbergWasmMain } from '../../index.js';
+import { Ready } from '../../../helpers/browser/index.js';
+import { initLogger } from '../../../../log/browser/index.js';
+addEventListener('message', e => {
+    if (e.data.log) {
+        initLogger(e.data.log);
+    }
+});
+expose(new BarretenbergWasmMain());
+postMessage(Ready);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi53b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYmFycmV0ZW5iZXJnX3dhc20vYmFycmV0ZW5iZXJnX3dhc21fbWFpbi9mYWN0b3J5L2Jyb3dzZXIvbWFpbi53b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNqQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0RCxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDMUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRTlELGdCQUFnQixDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsRUFBRTtJQUM5QixJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDZixVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN6QixDQUFDO0FBQ0gsQ0FBQyxDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsSUFBSSxvQkFBb0IsRUFBRSxDQUFDLENBQUM7QUFDbkMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDIn0=

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.d.ts

@@ -0,0 +1,3 @@
+import { Worker } from 'worker_threads';
+export declare function createMainWorker(): Promise<Worker>;
+//# sourceMappingURL=index.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAexC,wBAAgB,gBAAgB,oBAK/B"}

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/index.js

@@ -0,0 +1,21 @@
+import { Worker } from 'worker_threads';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { logOptions } from '../../../../log/index.js';
+function getCurrentDir() {
+    if (typeof __dirname !== 'undefined') {
+        return __dirname;
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return dirname(fileURLToPath(import.meta.url));
+    }
+}
+export function createMainWorker() {
+    const __dirname = getCurrentDir();
+    const worker = new Worker(__dirname + `/main.worker.js`);
+    worker.postMessage({ log: logOptions });
+    return Promise.resolve(worker);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYmFycmV0ZW5iZXJnX3dhc20vYmFycmV0ZW5iZXJnX3dhc21fbWFpbi9mYWN0b3J5L25vZGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDL0IsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUNwQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFdEQsU0FBUyxhQUFhO0lBQ3BCLElBQUksT0FBTyxTQUFTLEtBQUssV0FBVyxFQUFFLENBQUM7UUFDckMsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztTQUFNLENBQUM7UUFDTiw2REFBNkQ7UUFDN0QsYUFBYTtRQUNiLE9BQU8sT0FBTyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDakQsQ0FBQztBQUNILENBQUM7QUFFRCxNQUFNLFVBQVUsZ0JBQWdCO0lBQzlCLE1BQU0sU0FBUyxHQUFHLGFBQWEsRUFBRSxDQUFDO0lBQ2xDLE1BQU0sTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLFNBQVMsR0FBRyxpQkFBaUIsQ0FBQyxDQUFDO0lBQ3pELE1BQU0sQ0FBQyxXQUFXLENBQUMsRUFBRSxHQUFHLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUN4QyxPQUFPLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDakMsQ0FBQyJ9

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/main.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.worker.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/main.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.worker.d.ts","sourceRoot":"","sources":["../../../../../../src/barretenberg_wasm/barretenberg_wasm_main/factory/node/main.worker.ts"],"names":[],"mappings":""}

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/factory/node/main.worker.js

@@ -0,0 +1,16 @@
+import { parentPort } from 'worker_threads';
+import { expose } from 'comlink';
+import { BarretenbergWasmMain } from '../../index.js';
+import { nodeEndpoint } from '../../../helpers/node/node_endpoint.js';
+import { initLogger } from '../../../../log/node/index.js';
+if (!parentPort) {
+    throw new Error('No parentPort');
+}
+const endpoint = nodeEndpoint(parentPort);
+endpoint.addEventListener('message', (e) => {
+    if (e.data.log) {
+        initLogger(e.data.log);
+    }
+});
+expose(new BarretenbergWasmMain(), nodeEndpoint(parentPort));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFpbi53b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYmFycmV0ZW5iZXJnX3dhc20vYmFycmV0ZW5iZXJnX3dhc21fbWFpbi9mYWN0b3J5L25vZGUvbWFpbi53b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzVDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDakMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUUzRCxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDaEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxlQUFlLENBQUMsQ0FBQztBQUNuQyxDQUFDO0FBRUQsTUFBTSxRQUFRLEdBQUcsWUFBWSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0FBRTFDLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFNLEVBQUUsRUFBRTtJQUM5QyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDZixVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN6QixDQUFDO0FBQ0gsQ0FBQyxDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsSUFBSSxvQkFBb0IsRUFBRSxFQUFFLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDIn0=

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.d.ts

@@ -0,0 +1,21 @@
+import { type BarretenbergWasmMain } from './index.js';
+/**
+ * Keeps track of heap allocations so they can be easily freed.
+ * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
+ * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
+ * Heap allocations will be created for input/output args that don't fit into the scratch space.
+ * Input scratch grows UP from 0, output scratch grows DOWN from 1024, meeting in the middle.
+ * This maximizes space utilization while preventing overlap.
+ */
+export declare class HeapAllocator {
+    private wasm;
+    private allocs;
+    private inScratchPtr;
+    private outScratchPtr;
+    constructor(wasm: BarretenbergWasmMain);
+    getInputs(buffers: (Uint8Array | number)[]): number[];
+    getOutputPtrs(outLens: (number | undefined)[]): number[];
+    addOutputPtr(ptr: number): void;
+    freeAll(): void;
+}
+//# sourceMappingURL=heap_allocator.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap_allocator.d.ts","sourceRoot":"","sources":["../../../../src/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;GAOG;AACH,qBAAa,aAAa;IAKZ,OAAO,CAAC,IAAI;IAJxB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,aAAa,CAAQ;gBAET,IAAI,EAAE,oBAAoB;IAE9C,SAAS,CAAC,OAAO,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE;IAuB1C,aAAa,CAAC,OAAO,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE;IAmB7C,YAAY,CAAC,GAAG,EAAE,MAAM;IAOxB,OAAO;CAKR"}

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/heap_allocator.js

@@ -0,0 +1,70 @@
+/**
+ * Keeps track of heap allocations so they can be easily freed.
+ * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
+ * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
+ * Heap allocations will be created for input/output args that don't fit into the scratch space.
+ * Input scratch grows UP from 0, output scratch grows DOWN from 1024, meeting in the middle.
+ * This maximizes space utilization while preventing overlap.
+ */
+export class HeapAllocator {
+    constructor(wasm) {
+        this.wasm = wasm;
+        this.allocs = [];
+        this.inScratchPtr = 0; // Next input starts here, grows UP
+        this.outScratchPtr = 1024; // Next output ends here, grows DOWN
+    }
+    getInputs(buffers) {
+        return buffers.map(bufOrNum => {
+            if (typeof bufOrNum === 'object') {
+                const size = bufOrNum.length;
+                // Check if there's room in scratch space (inputs grow up, outputs grow down)
+                if (this.inScratchPtr + size <= this.outScratchPtr) {
+                    const ptr = this.inScratchPtr;
+                    this.inScratchPtr += size; // Grow UP
+                    this.wasm.writeMemory(ptr, bufOrNum);
+                    return ptr;
+                }
+                else {
+                    // Fall back to heap allocation
+                    const ptr = this.wasm.call('bbmalloc', size);
+                    this.wasm.writeMemory(ptr, bufOrNum);
+                    this.allocs.push(ptr);
+                    return ptr;
+                }
+            }
+            else {
+                return bufOrNum;
+            }
+        });
+    }
+    getOutputPtrs(outLens) {
+        return outLens.map(len => {
+            // If the obj is variable length, we need a 4 byte ptr to write the serialized data address to.
+            // WARNING: 4 only works with WASM as it has 32 bit memory.
+            const size = len || 4;
+            // Check if there's room in scratch space (inputs grow up, outputs grow down)
+            if (this.inScratchPtr + size <= this.outScratchPtr) {
+                this.outScratchPtr -= size; // Grow DOWN
+                return this.outScratchPtr;
+            }
+            else {
+                // Fall back to heap allocation
+                const ptr = this.wasm.call('bbmalloc', size);
+                this.allocs.push(ptr);
+                return ptr;
+            }
+        });
+    }
+    addOutputPtr(ptr) {
+        // Only add to dealloc list if it's a heap allocation (not in scratch space 0-1023)
+        if (ptr >= 1024) {
+            this.allocs.push(ptr);
+        }
+    }
+    freeAll() {
+        for (const ptr of this.allocs) {
+            this.wasm.call('bbfree', ptr);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/index.d.ts

@@ -0,0 +1,53 @@
+import { Remote } from 'comlink';
+import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
+/**
+ * This is the "main thread" implementation of BarretenbergWasm.
+ * It spawns a bunch of "child thread" implementations.
+ * In a browser context, this still runs on a worker, as it will block waiting on child threads.
+ */
+export declare class BarretenbergWasmMain extends BarretenbergWasmBase {
+    static MAX_THREADS: number;
+    private workers;
+    private remoteWasms;
+    private nextWorker;
+    private nextThreadId;
+    private msgpackInputScratch;
+    private msgpackOutputScratch;
+    private readonly MSGPACK_SCRATCH_SIZE;
+    getNumThreads(): number;
+    /**
+     * Init as main thread. Spawn child threads.
+     */
+    init(module: WebAssembly.Module, threads?: number, logger?: (msg: string) => void, initial?: number, maximum?: number): Promise<void>;
+    private getDefaultMaximumMemoryPages;
+    /**
+     * Called on main thread. Signals child threads to gracefully exit.
+     */
+    destroy(): Promise<void>;
+    protected getImportObj(memory: WebAssembly.Memory): {
+        wasi: {
+            'thread-spawn': (arg: number) => number;
+        };
+        env: {
+            env_hardware_concurrency: () => number;
+            logstr: (addr: number) => void;
+            throw_or_abort_impl: (addr: number) => never;
+            get_data: (keyAddr: number, outBufAddr: number) => void;
+            set_data: (keyAddr: number, dataAddr: number, dataLength: number) => void;
+            memory: WebAssembly.Memory;
+        };
+        wasi_snapshot_preview1: {
+            random_get: (out: any, length: number) => void;
+            clock_time_get: (a1: number, a2: number, out: number) => void;
+            proc_exit: () => never;
+        };
+    };
+    callWasmExport(funcName: string, inArgs: (Uint8Array | number)[], outLens: (number | undefined)[]): Uint8Array<ArrayBuffer>[];
+    private getOutputArgs;
+    cbindCall(cbind: string, inputBuffer: Uint8Array): any;
+}
+/**
+ * The comlink type that asyncifies the BarretenbergWasmMain api.
+ */
+export type BarretenbergWasmMainWorker = Remote<BarretenbergWasmMain>;
+//# sourceMappingURL=index.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/barretenberg_wasm/barretenberg_wasm_main/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAIjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAI1E;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,oBAAoB;IAC5D,MAAM,CAAC,WAAW,SAAM;IACxB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,YAAY,CAAK;IAGzB,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,oBAAoB,CAAa;IACzC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAmB;IAEjD,aAAa;IAIpB;;OAEG;IACU,IAAI,CACf,MAAM,EAAE,WAAW,CAAC,MAAM,EAC1B,OAAO,SAA0D,EACjE,MAAM,GAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAmC,EAC5D,OAAO,SAAK,EACZ,OAAO,SAAsC;IAwC/C,OAAO,CAAC,4BAA4B;IASpC;;OAEG;IACU,OAAO;IAIpB,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM;;kCAOrB,MAAM;;;;;;;;;;;;;;;;IAsBlC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,UAAU,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE;IAUjG,OAAO,CAAC,aAAa;IAmBrB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,GAAG;CA4DvD;AAED;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC"}

package/dest/node/barretenberg_wasm/barretenberg_wasm_main/index.js

@@ -0,0 +1,170 @@
+import { getNumCpu, getRemoteBarretenbergWasm, getSharedMemoryAvailable } from '../helpers/index.js';
+import { createThreadWorker } from '../barretenberg_wasm_thread/factory/node/index.js';
+import { BarretenbergWasmBase } from '../barretenberg_wasm_base/index.js';
+import { HeapAllocator } from './heap_allocator.js';
+import { createDebugLogger } from '../../log/index.js';
+/**
+ * This is the "main thread" implementation of BarretenbergWasm.
+ * It spawns a bunch of "child thread" implementations.
+ * In a browser context, this still runs on a worker, as it will block waiting on child threads.
+ */
+export class BarretenbergWasmMain extends BarretenbergWasmBase {
+    constructor() {
+        super(...arguments);
+        this.workers = [];
+        this.remoteWasms = [];
+        this.nextWorker = 0;
+        this.nextThreadId = 1;
+        // Pre-allocated scratch buffers for msgpack I/O to avoid malloc/free overhead
+        this.msgpackInputScratch = 0; // 8MB input buffer
+        this.msgpackOutputScratch = 0; // 8MB output buffer
+        this.MSGPACK_SCRATCH_SIZE = 1024 * 1024 * 8; // 8MB
+    }
+    getNumThreads() {
+        return this.workers.length + 1;
+    }
+    /**
+     * Init as main thread. Spawn child threads.
+     */
+    async init(module, threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS), logger = createDebugLogger('bb_wasm'), initial = 33, maximum = this.getDefaultMaximumMemoryPages()) {
+        this.logger = logger;
+        const initialMb = (initial * 2 ** 16) / (1024 * 1024);
+        const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
+        const shared = getSharedMemoryAvailable();
+        this.logger(`Initializing bb wasm: initial memory ${initial} pages ${initialMb}MiB; ` +
+            `max memory: ${maximum} pages, ${maxMb}MiB; ` +
+            `threads: ${threads}; shared memory: ${shared}`);
+        this.memory = new WebAssembly.Memory({ initial, maximum, shared });
+        const instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
+        this.instance = instance;
+        // Init all global/static data.
+        this.call('_initialize');
+        // Allocate dedicated msgpack scratch buffers (never freed, reused for all msgpack calls)
+        this.msgpackInputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+        this.msgpackOutputScratch = this.call('bbmalloc', this.MSGPACK_SCRATCH_SIZE);
+        this.logger(`Allocated msgpack scratch buffers: ` +
+            `input @ ${this.msgpackInputScratch}, output @ ${this.msgpackOutputScratch} (${this.MSGPACK_SCRATCH_SIZE} bytes each)`);
+        // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
+        if (threads > 1) {
+            this.logger(`Creating ${threads} worker threads`);
+            this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
+            this.remoteWasms = await Promise.all(this.workers.map((getRemoteBarretenbergWasm)));
+            await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
+        }
+    }
+    getDefaultMaximumMemoryPages() {
+        // iOS browser is very aggressive with memory. Check if running in browser and on iOS
+        // We at any rate expect the mobile iOS browser to kill us >=1GB, so we don't set a maximum higher than that.
+        if (typeof window !== 'undefined' && /iPad|iPhone/.test(navigator.userAgent)) {
+            return 2 ** 14;
+        }
+        return 2 ** 16;
+    }
+    /**
+     * Called on main thread. Signals child threads to gracefully exit.
+     */
+    async destroy() {
+        await Promise.all(this.workers.map(w => w.terminate()));
+    }
+    getImportObj(memory) {
+        const baseImports = super.getImportObj(memory);
+        /* eslint-disable camelcase */
+        return {
+            ...baseImports,
+            wasi: {
+                'thread-spawn': (arg) => {
+                    arg = arg >>> 0;
+                    const id = this.nextThreadId++;
+                    const worker = this.nextWorker++ % this.remoteWasms.length;
+                    // this.logger(`spawning thread ${id} on worker ${worker} with arg ${arg >>> 0}`);
+                    this.remoteWasms[worker].call('wasi_thread_start', id, arg).catch(this.logger);
+                    // this.remoteWasms[worker].postMessage({ msg: 'thread', data: { id, arg } });
+                    return id;
+                },
+            },
+            env: {
+                ...baseImports.env,
+                env_hardware_concurrency: () => {
+                    // If there are no workers (we're already running as a worker, or the main thread requested no workers)
+                    // then we return 1, which should cause any algos using threading to just not create a thread.
+                    return this.remoteWasms.length + 1;
+                },
+            },
+        };
+        /* eslint-enable camelcase */
+    }
+    callWasmExport(funcName, inArgs, outLens) {
+        const alloc = new HeapAllocator(this);
+        const inPtrs = alloc.getInputs(inArgs);
+        const outPtrs = alloc.getOutputPtrs(outLens);
+        this.call(funcName, ...inPtrs, ...outPtrs);
+        const outArgs = this.getOutputArgs(outLens, outPtrs, alloc);
+        alloc.freeAll();
+        return outArgs;
+    }
+    getOutputArgs(outLens, outPtrs, alloc) {
+        return outLens.map((len, i) => {
+            if (len) {
+                return this.getMemorySlice(outPtrs[i], outPtrs[i] + len);
+            }
+            const slice = this.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
+            const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
+            // Add our heap buffer to the dealloc list.
+            alloc.addOutputPtr(ptr);
+            // The length will be found in the first 4 bytes of the buffer, big endian. See to_heap_buffer.
+            const lslice = this.getMemorySlice(ptr, ptr + 4);
+            const length = new DataView(lslice.buffer, lslice.byteOffset, lslice.byteLength).getUint32(0, false);
+            return this.getMemorySlice(ptr + 4, ptr + 4 + length);
+        });
+    }
+    cbindCall(cbind, inputBuffer) {
+        const needsCustomInputBuffer = inputBuffer.length > this.MSGPACK_SCRATCH_SIZE;
+        let inputPtr;
+        if (needsCustomInputBuffer) {
+            // Allocate temporary buffer for oversized input
+            inputPtr = this.call('bbmalloc', inputBuffer.length);
+        }
+        else {
+            // Use pre-allocated scratch buffer
+            inputPtr = this.msgpackInputScratch;
+        }
+        // Write input to buffer
+        this.writeMemory(inputPtr, inputBuffer);
+        // Setup output scratch buffer with IN-OUT parameter pattern:
+        // Reserve 8 bytes for metadata (pointer + size), rest is scratch data space
+        const METADATA_SIZE = 8;
+        const outputPtrLocation = this.msgpackOutputScratch;
+        const outputSizeLocation = this.msgpackOutputScratch + 4;
+        const scratchDataPtr = this.msgpackOutputScratch + METADATA_SIZE;
+        const scratchDataSize = this.MSGPACK_SCRATCH_SIZE - METADATA_SIZE;
+        // Get memory and create DataView for writing IN values
+        let mem = this.getMemory();
+        let view = new DataView(mem.buffer);
+        // Write IN values: provide scratch buffer pointer and size to C++
+        view.setUint32(outputPtrLocation, scratchDataPtr, true);
+        view.setUint32(outputSizeLocation, scratchDataSize, true);
+        // Call WASM
+        this.call(cbind, inputPtr, inputBuffer.length, outputPtrLocation, outputSizeLocation);
+        // Free custom input buffer if allocated
+        if (needsCustomInputBuffer) {
+            this.call('bbfree', inputPtr);
+        }
+        // Re-fetch memory after WASM call, as the buffer may have been detached if memory grew
+        mem = this.getMemory();
+        view = new DataView(mem.buffer);
+        // Read OUT values: C++ returns actual buffer pointer and size
+        const outputDataPtr = view.getUint32(outputPtrLocation, true);
+        const outputSize = view.getUint32(outputSizeLocation, true);
+        // Check if C++ used scratch (pointer unchanged) or allocated (pointer changed)
+        const usedScratch = outputDataPtr === scratchDataPtr;
+        // Copy output data from WASM memory
+        const encodedResult = this.getMemorySlice(outputDataPtr, outputDataPtr + outputSize);
+        // Only free if C++ allocated beyond scratch
+        if (!usedScratch) {
+            this.call('bbfree', outputDataPtr);
+        }
+        return encodedResult;
+    }
+}
+BarretenbergWasmMain.MAX_THREADS = 32;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/barretenberg_wasm/barretenberg_wasm_main/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACrG,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,OAAO,oBAAqB,SAAQ,oBAAoB;IAA9D;;QAEU,YAAO,GAAa,EAAE,CAAC;QACvB,gBAAW,GAAmC,EAAE,CAAC;QACjD,eAAU,GAAG,CAAC,CAAC;QACf,iBAAY,GAAG,CAAC,CAAC;QAEzB,8EAA8E;QACtE,wBAAmB,GAAW,CAAC,CAAC,CAAC,mBAAmB;QACpD,yBAAoB,GAAW,CAAC,CAAC,CAAC,oBAAoB;QAC7C,yBAAoB,GAAG,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,MAAM;IA4LjE,CAAC;IA1LQ,aAAa;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI,CACf,MAA0B,EAC1B,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,oBAAoB,CAAC,WAAW,CAAC,EACjE,SAAgC,iBAAiB,CAAC,SAAS,CAAC,EAC5D,OAAO,GAAG,EAAE,EACZ,OAAO,GAAG,IAAI,CAAC,4BAA4B,EAAE;QAE7C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QAErB,MAAM,SAAS,GAAG,CAAC,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,CAAC,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;QAClD,MAAM,MAAM,GAAG,wBAAwB,EAAE,CAAC;QAE1C,IAAI,CAAC,MAAM,CACT,wCAAwC,OAAO,UAAU,SAAS,OAAO;YACvE,eAAe,OAAO,WAAW,KAAK,OAAO;YAC7C,YAAY,OAAO,oBAAoB,MAAM,EAAE,CAClD,CAAC;QAEF,IAAI,CAAC,MAAM,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QAEnE,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;QAEvF,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAEzB,+BAA+B;QAC/B,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAEzB,yFAAyF;QACzF,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC5E,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC7E,IAAI,CAAC,MAAM,CACT,qCAAqC;YACnC,WAAW,IAAI,CAAC,mBAAmB,cAAc,IAAI,CAAC,oBAAoB,KAAK,IAAI,CAAC,oBAAoB,cAAc,CACzH,CAAC;QAEF,0FAA0F;QAC1F,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,CAAC,YAAY,OAAO,iBAAiB,CAAC,CAAC;YAClD,IAAI,CAAC,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC;YAC9F,IAAI,CAAC,WAAW,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA,yBAAuD,CAAA,CAAC,CAAC,CAAC;YAChH,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IAEO,4BAA4B;QAClC,qFAAqF;QACrF,6GAA6G;QAC7G,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;YAC7E,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,CAAC;QACD,OAAO,CAAC,IAAI,EAAE,CAAC;IACjB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,OAAO;QAClB,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IAC1D,CAAC;IAES,YAAY,CAAC,MAA0B;QAC/C,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAE/C,8BAA8B;QAC9B,OAAO;YACL,GAAG,WAAW;YACd,IAAI,EAAE;gBACJ,cAAc,EAAE,CAAC,GAAW,EAAE,EAAE;oBAC9B,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC;oBAChB,MAAM,EAAE,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;oBAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;oBAC3D,kFAAkF;oBAClF,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAC/E,8EAA8E;oBAC9E,OAAO,EAAE,CAAC;gBACZ,CAAC;aACF;YACD,GAAG,EAAE;gBACH,GAAG,WAAW,CAAC,GAAG;gBAClB,wBAAwB,EAAE,GAAG,EAAE;oBAC7B,uGAAuG;oBACvG,8FAA8F;oBAC9F,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;gBACrC,CAAC;aACF;SACF,CAAC;QACF,6BAA6B;IAC/B,CAAC;IAED,cAAc,CAAC,QAAgB,EAAE,MAA+B,EAAE,OAA+B;QAC/F,MAAM,KAAK,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,OAAO,GAAG,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5D,KAAK,CAAC,OAAO,EAAE,CAAC;QAChB,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,aAAa,CAAC,OAA+B,EAAE,OAAiB,EAAE,KAAoB;QAC5F,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;YAC5B,IAAI,GAAG,EAAE,CAAC;gBACR,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;YAC3D,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC9D,MAAM,GAAG,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YAE9F,2CAA2C;YAC3C,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YAExB,+FAA+F;YAC/F,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC;YACjD,MAAM,MAAM,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAErG,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,SAAS,CAAC,KAAa,EAAE,WAAuB;QAC9C,MAAM,sBAAsB,GAAG,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC;QAC9E,IAAI,QAAgB,CAAC;QAErB,IAAI,sBAAsB,EAAE,CAAC;YAC3B,gDAAgD;YAChD,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;QACvD,CAAC;aAAM,CAAC;YACN,mCAAmC;YACnC,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACtC,CAAC;QAED,wBAAwB;QACxB,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAExC,6DAA6D;QAC7D,4EAA4E;QAC5E,MAAM,aAAa,GAAG,CAAC,CAAC;QACxB,MAAM,iBAAiB,GAAG,IAAI,CAAC,oBAAoB,CAAC;QACpD,MAAM,kBAAkB,GAAG,IAAI,CAAC,oBAAoB,GAAG,CAAC,CAAC;QACzD,MAAM,cAAc,GAAG,IAAI,CAAC,oBAAoB,GAAG,aAAa,CAAC;QACjE,MAAM,eAAe,GAAG,IAAI,CAAC,oBAAoB,GAAG,aAAa,CAAC;QAElE,uDAAuD;QACvD,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC3B,IAAI,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAEpC,kEAAkE;QAClE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;QACxD,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,eAAe,EAAE,IAAI,CAAC,CAAC;QAE1D,YAAY;QACZ,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,kBAAkB,CAAC,CAAC;QAEtF,wCAAwC;QACxC,IAAI,sBAAsB,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAChC,CAAC;QAED,uFAAuF;QACvF,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACvB,IAAI,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAEhC,8DAA8D;QAC9D,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;QAC9D,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC;QAE5D,+EAA+E;QAC/E,MAAM,WAAW,GAAG,aAAa,KAAK,cAAc,CAAC;QAErD,oCAAoC;QACpC,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,aAAa,GAAG,UAAU,CAAC,CAAC;QAErF,4CAA4C;QAC5C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;;AApMM,gCAAW,GAAG,EAAE,AAAL,CAAM"}

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.d.ts

@@ -0,0 +1,2 @@
+export declare function createThreadWorker(): Promise<Worker>;
+//# sourceMappingURL=index.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.ts"],"names":[],"mappings":"AAGA,wBAAsB,kBAAkB,oBAOvC"}

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/index.js

@@ -0,0 +1,11 @@
+import { logOptions } from '../../../../log/index.js';
+import { readinessListener } from '../../../helpers/browser/index.js';
+export async function createThreadWorker() {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const worker = new Worker(new URL('./thread.worker.js', import.meta.url), { type: 'module' });
+    worker.postMessage({ log: logOptions });
+    await new Promise(resolve => readinessListener(worker, resolve));
+    return worker;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYmFycmV0ZW5iZXJnX3dhc20vYmFycmV0ZW5iZXJnX3dhc21fdGhyZWFkL2ZhY3RvcnkvYnJvd3Nlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFdEUsTUFBTSxDQUFDLEtBQUssVUFBVSxrQkFBa0I7SUFDdEMsNkRBQTZEO0lBQzdELGFBQWE7SUFDYixNQUFNLE1BQU0sR0FBRyxJQUFJLE1BQU0sQ0FBQyxJQUFJLEdBQUcsQ0FBQyxvQkFBb0IsRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDOUYsTUFBTSxDQUFDLFdBQVcsQ0FBQyxFQUFFLEdBQUcsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO0lBQ3hDLE1BQU0sSUFBSSxPQUFPLENBQU8sT0FBTyxDQUFDLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUN2RSxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDIn0=

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=thread.worker.d.ts.map

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thread.worker.d.ts","sourceRoot":"","sources":["../../../../../../src/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.ts"],"names":[],"mappings":""}

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/browser/thread.worker.js

@@ -0,0 +1,12 @@
+import { expose } from 'comlink';
+import { BarretenbergWasmThread } from '../../index.js';
+import { Ready } from '../../../helpers/browser/index.js';
+import { initLogger } from '../../../../log/browser/index.js';
+addEventListener('message', e => {
+    if (e.data.log) {
+        initLogger(e.data.log);
+    }
+});
+expose(new BarretenbergWasmThread());
+postMessage(Ready);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhyZWFkLndvcmtlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9iYXJyZXRlbmJlcmdfd2FzbS9iYXJyZXRlbmJlcmdfd2FzbV90aHJlYWQvZmFjdG9yeS9icm93c2VyL3RocmVhZC53b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUNqQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDMUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRTlELGdCQUFnQixDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUMsRUFBRTtJQUM5QixJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDZixVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN6QixDQUFDO0FBQ0gsQ0FBQyxDQUFDLENBQUM7QUFFSCxNQUFNLENBQUMsSUFBSSxzQkFBc0IsRUFBRSxDQUFDLENBQUM7QUFDckMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDIn0=

package/dest/node/barretenberg_wasm/barretenberg_wasm_thread/factory/node/index.d.ts

@@ -0,0 +1,3 @@
+import { Worker } from 'worker_threads';
+export declare function createThreadWorker(): Promise<Worker>;
+//# sourceMappingURL=index.d.ts.map