@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.21caa21

package/dest/node-cjs/bb_backends/browser/platform.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPackageRoot = findPackageRoot;
+exports.findBbBinary = findBbBinary;
+exports.findNapiBinary = findNapiBinary;
+function findPackageRoot() {
+    throw new Error('Not implemented in browser environment.');
+}
+function findBbBinary(customPath) {
+    throw new Error('Not implemented in browser environment.');
+}
+function findNapiBinary(customPath) {
+    throw new Error('Not implemented in browser environment.');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhdGZvcm0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYmJfYmFja2VuZHMvYnJvd3Nlci9wbGF0Zm9ybS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLDJCQUFpRDtJQUMvQyxNQUFNLElBQUksS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUM7QUFBQSxDQUM1RDtBQUVELHNCQUE2QixVQUFtQixFQUFpQjtJQUMvRCxNQUFNLElBQUksS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUM7QUFBQSxDQUM1RDtBQUVELHdCQUErQixVQUFtQixFQUFpQjtJQUNqRSxNQUFNLElBQUksS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUM7QUFBQSxDQUM1RCJ9

package/dest/node-cjs/bb_backends/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Backend types for Barretenberg
+ */
+export declare enum BackendType {
+    /** WASM direct execution (no worker) */
+    Wasm = "Wasm",
+    /** WASM with worker threads */
+    WasmWorker = "WasmWorker",
+    /** Native via Unix domain socket (async only) */
+    NativeUnixSocket = "NativeUnixSocket",
+    /** Native via shared memory */
+    NativeSharedMemory = "NativeSharedMemory"
+}
+export type BackendOptions = {
+    /** @description Number of threads to run the backend worker on */
+    threads?: number;
+    /** @description Initial and Maximum memory to be alloted to the backend worker */
+    memory?: {
+        initial?: number;
+        maximum?: number;
+    };
+    /** @description Path to download CRS files */
+    crsPath?: string;
+    /** @description Path to download WASM files */
+    wasmPath?: string;
+    /** @description Custom path to bb binary for native backend (overrides automatic detection) */
+    bbPath?: string;
+    /**
+     * @description Logging function
+     * Warning: Attaching a logger can prevent nodejs from exiting without explicitly destroying the backend.
+     */
+    logger?: (msg: string) => void;
+    /**
+     * @description Maximum concurrent clients for shared memory IPC server (default: 1)
+     * Only applies to NativeSharedMemory backend
+     */
+    maxClients?: number;
+    /**
+     * @description Specify exact backend to use
+     * - If unset: tries backends in default order with fallback
+     * - If set: must succeed with specified backend or throw error (no fallback)
+     *
+     * Barretenberg (async) supports: all types
+     * BarretenbergSync supports: Wasm, NativeSharedMem only
+     */
+    backend?: BackendType;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILG9CQUFZLFdBQVc7SUFDckIsd0NBQXdDO0lBQ3hDLElBQUksU0FBUztJQUNiLCtCQUErQjtJQUMvQixVQUFVLGVBQWU7SUFDekIsaURBQWlEO0lBQ2pELGdCQUFnQixxQkFBcUI7SUFDckMsK0JBQStCO0lBQy9CLGtCQUFrQix1QkFBdUI7Q0FDMUM7QUFFRCxNQUFNLE1BQU0sY0FBYyxHQUFHO0lBQzNCLGtFQUFrRTtJQUNsRSxPQUFPLENBQUMsRUFBRSxNQUFNLENBQUM7SUFFakIsa0ZBQWtGO0lBQ2xGLE1BQU0sQ0FBQyxFQUFFO1FBQUUsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO1FBQUMsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFBO0tBQUUsQ0FBQztJQUVoRCw4Q0FBOEM7SUFDOUMsT0FBTyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBRWpCLCtDQUErQztJQUMvQyxRQUFRLENBQUMsRUFBRSxNQUFNLENBQUM7SUFFbEIsK0ZBQStGO0lBQy9GLE1BQU0sQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUVoQjs7O09BR0c7SUFDSCxNQUFNLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEtBQUssSUFBSSxDQUFDO0lBRS9COzs7T0FHRztJQUNILFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUVwQjs7Ozs7OztPQU9HO0lBQ0gsT0FBTyxDQUFDLEVBQUUsV0FBVyxDQUFDO0NBQ3ZCLENBQUMifQ==

package/dest/node-cjs/bb_backends/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bb_backends/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,WAAW;IACrB,wCAAwC;IACxC,IAAI,SAAS;IACb,+BAA+B;IAC/B,UAAU,eAAe;IACzB,iDAAiD;IACjD,gBAAgB,qBAAqB;IACrC,+BAA+B;IAC/B,kBAAkB,uBAAuB;CAC1C;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,kFAAkF;IAClF,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAEhD,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAE/B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB,CAAC"}

package/dest/node-cjs/bb_backends/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackendType = void 0;
+/**
+ * Backend types for Barretenberg
+ */
+var BackendType;
+(function (BackendType) {
+    /** WASM direct execution (no worker) */
+    BackendType["Wasm"] = "Wasm";
+    /** WASM with worker threads */
+    BackendType["WasmWorker"] = "WasmWorker";
+    /** Native via Unix domain socket (async only) */
+    BackendType["NativeUnixSocket"] = "NativeUnixSocket";
+    /** Native via shared memory */
+    BackendType["NativeSharedMemory"] = "NativeSharedMemory";
+})(BackendType || (exports.BackendType = BackendType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmJfYmFja2VuZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDSCxJQUFZLFdBU1g7QUFURCxXQUFZLFdBQVc7SUFDckIsd0NBQXdDO0lBQ3hDLDRCQUFhLENBQUE7SUFDYiwrQkFBK0I7SUFDL0Isd0NBQXlCLENBQUE7SUFDekIsaURBQWlEO0lBQ2pELG9EQUFxQyxDQUFBO0lBQ3JDLCtCQUErQjtJQUMvQix3REFBeUMsQ0FBQTtBQUFDLENBQzVDLEVBVFksV0FBVyxhQUFYLFdBQVcsR0FBWCxXQUFXLFFBU3RCIn0=

package/dest/node-cjs/bb_backends/interface.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Generic interface for msgpack backend implementations.
+ * Both WASM and native binary backends implement this interface.
+ */
+export interface IMsgpackBackend {
+    /**
+     * Execute a msgpack command and return the msgpack response.
+     * @param inputBuffer The msgpack-encoded input buffer
+     * @returns The msgpack-encoded response buffer (sync or async)
+     */
+    call(inputBuffer: Uint8Array): Uint8Array | Promise<Uint8Array>;
+    /**
+     * Clean up resources.
+     */
+    destroy(): void | Promise<void>;
+}
+/**
+ * Synchronous variant of IMsgpackBackend.
+ * Used by BarretenbergSync and SyncApi.
+ */
+export interface IMsgpackBackendSync extends IMsgpackBackend {
+    call(inputBuffer: Uint8Array): Uint8Array;
+    destroy(): void;
+}
+/**
+ * Asynchronous variant of IMsgpackBackend.
+ * Used by Barretenberg and AsyncApi.
+ */
+export interface IMsgpackBackendAsync extends IMsgpackBackend {
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmJfYmFja2VuZHMvaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUNILE1BQU0sV0FBVyxlQUFlO0lBQzlCOzs7O09BSUc7SUFDSCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLEdBQUcsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRWhFOztPQUVHO0lBQ0gsT0FBTyxJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDakM7QUFFRDs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsbUJBQW9CLFNBQVEsZUFBZTtJQUMxRCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLENBQUM7SUFDMUMsT0FBTyxJQUFJLElBQUksQ0FBQztDQUNqQjtBQUVEOzs7R0FHRztBQUNILE1BQU0sV0FBVyxvQkFBcUIsU0FBUSxlQUFlO0lBQzNELElBQUksQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNuRCxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0NBQzFCIn0=

package/dest/node-cjs/bb_backends/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/bb_backends/interface.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEhE;;OAEG;IACH,OAAO,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,CAAC;IAC1C,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACnD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dest/node-cjs/bb_backends/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/node-cjs/bb_backends/node/index.d.ts

@@ -0,0 +1,11 @@
+import { Barretenberg, BarretenbergSync } from '../../barretenberg/index.js';
+import { BackendOptions, BackendType } from '../index.js';
+/**
+ * Create backend of specific type (no fallback)
+ */
+export declare function createAsyncBackend(type: BackendType, options: BackendOptions, logger: (msg: string) => void): Promise<Barretenberg>;
+/**
+ * Create backend of specific type (no fallback)
+ */
+export declare function createSyncBackend(type: BackendType, options: BackendOptions, logger: (msg: string) => void): Promise<BarretenbergSync>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBLE9BQU8sRUFBRSxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUM3RSxPQUFPLEVBQUUsY0FBYyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUxRDs7R0FFRztBQUNILHdCQUFzQixrQkFBa0IsQ0FDdEMsSUFBSSxFQUFFLFdBQVcsRUFDakIsT0FBTyxFQUFFLGNBQWMsRUFDdkIsTUFBTSxFQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sS0FBSyxJQUFJLEdBQzVCLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FnRHZCO0FBRUQ7O0dBRUc7QUFDSCx3QkFBc0IsaUJBQWlCLENBQ3JDLElBQUksRUFBRSxXQUFXLEVBQ2pCLE9BQU8sRUFBRSxjQUFjLEVBQ3ZCLE1BQU0sRUFBRSxDQUFDLEdBQUcsRUFBRSxNQUFNLEtBQUssSUFBSSxHQUM1QixPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0E2QjNCIn0=

package/dest/node-cjs/bb_backends/node/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC5B,OAAO,CAAC,YAAY,CAAC,CAgDvB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CA6B3B"}

package/dest/node-cjs/bb_backends/node/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsyncBackend = createAsyncBackend;
+exports.createSyncBackend = createSyncBackend;
+const native_socket_js_1 = require("./native_socket.js");
+const wasm_js_1 = require("../wasm.js");
+const native_shm_js_1 = require("./native_shm.js");
+const native_shm_async_js_1 = require("./native_shm_async.js");
+const platform_js_1 = require("./platform.js");
+const index_js_1 = require("../../barretenberg/index.js");
+const index_js_2 = require("../index.js");
+/**
+ * Create backend of specific type (no fallback)
+ */
+async function createAsyncBackend(type, options, logger) {
+    options = {
+        ...options,
+        wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+    };
+    switch (type) {
+        case index_js_2.BackendType.NativeUnixSocket: {
+            const bbPath = (0, platform_js_1.findBbBinary)(options.bbPath);
+            if (!bbPath) {
+                throw new Error('Native backend requires bb binary.');
+            }
+            logger(`Using native Unix socket backend: ${bbPath}`);
+            const socket = new native_socket_js_1.BarretenbergNativeSocketAsyncBackend(bbPath, options.threads, options.logger);
+            return new index_js_1.Barretenberg(socket, options);
+        }
+        case index_js_2.BackendType.NativeSharedMemory: {
+            const bbPath = (0, platform_js_1.findBbBinary)(options.bbPath);
+            if (!bbPath) {
+                throw new Error('Native backend requires bb binary.');
+            }
+            const napiPath = (0, platform_js_1.findNapiBinary)();
+            if (!napiPath) {
+                throw new Error('Native async backend requires napi client stub.');
+            }
+            logger(`Using native shared memory async backend: ${bbPath}`);
+            const asyncBackend = await native_shm_async_js_1.BarretenbergNativeShmAsyncBackend.new(bbPath, options.threads, options.logger);
+            return new index_js_1.Barretenberg(asyncBackend, options);
+        }
+        case index_js_2.BackendType.Wasm:
+        case index_js_2.BackendType.WasmWorker: {
+            const useWorker = type === index_js_2.BackendType.WasmWorker;
+            logger(`Using WASM backend (worker: ${useWorker})`);
+            const wasm = await wasm_js_1.BarretenbergWasmAsyncBackend.new({
+                threads: options.threads,
+                wasmPath: options.wasmPath,
+                logger: options.logger,
+                memory: options.memory,
+                useWorker,
+            });
+            return new index_js_1.Barretenberg(wasm, options);
+        }
+        default:
+            throw new Error(`Unknown backend type: ${type}`);
+    }
+}
+/**
+ * Create backend of specific type (no fallback)
+ */
+async function createSyncBackend(type, options, logger) {
+    options = {
+        ...options,
+        wasmPath: options.wasmPath ?? process.env.BB_WASM_PATH,
+    };
+    switch (type) {
+        case index_js_2.BackendType.NativeSharedMemory: {
+            const bbPath = (0, platform_js_1.findBbBinary)(options.bbPath);
+            if (!bbPath) {
+                throw new Error('Native backend requires bb binary.');
+            }
+            const napiPath = (0, platform_js_1.findNapiBinary)();
+            if (!napiPath) {
+                throw new Error('Native sync backend requires napi client stub.');
+            }
+            logger(`Using native shared memory backend: ${bbPath}`);
+            const shm = await native_shm_js_1.BarretenbergNativeShmSyncBackend.new(bbPath, options.threads, options.logger);
+            return new index_js_1.BarretenbergSync(shm);
+        }
+        case index_js_2.BackendType.Wasm:
+            logger('Using WASM backend');
+            const wasm = await wasm_js_1.BarretenbergWasmSyncBackend.new(options.wasmPath, logger);
+            return new index_js_1.BarretenbergSync(wasm);
+        default:
+            throw new Error(`Backend ${type} not supported for BarretenbergSync`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node-cjs/bb_backends/node/native_pipe.d.ts

@@ -0,0 +1,25 @@
+import { IMsgpackBackendAsync } from '../interface.js';
+/**
+ * Asynchronous native backend that communicates with bb binary via stdin/stdout.
+ * Uses event-based I/O with a state machine to handle partial reads.
+ *
+ * Protocol:
+ * - Request: 4-byte little-endian length + msgpack buffer
+ * - Response: 4-byte little-endian length + msgpack buffer
+ */
+export declare class BarretenbergNativePipeAsyncBackend implements IMsgpackBackendAsync {
+    private process;
+    private pendingResolve;
+    private pendingReject;
+    private readingLength;
+    private lengthBuffer;
+    private lengthBytesRead;
+    private responseLength;
+    private responseBuffer;
+    private responseBytesRead;
+    constructor(bbBinaryPath: string);
+    private handleData;
+    call(inputBuffer: Uint8Array): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3BpcGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL25hdGl2ZV9waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBdUIsb0JBQW9CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUU1RTs7Ozs7OztHQU9HO0FBQ0gscUJBQWEsa0NBQW1DLFlBQVcsb0JBQW9CO0lBQzdFLE9BQU8sQ0FBQyxPQUFPLENBQWU7SUFDOUIsT0FBTyxDQUFDLGNBQWMsQ0FBNkM7SUFDbkUsT0FBTyxDQUFDLGFBQWEsQ0FBeUM7SUFHOUQsT0FBTyxDQUFDLGFBQWEsQ0FBaUI7SUFDdEMsT0FBTyxDQUFDLFlBQVksQ0FBMkI7SUFDL0MsT0FBTyxDQUFDLGVBQWUsQ0FBYTtJQUNwQyxPQUFPLENBQUMsY0FBYyxDQUFhO0lBQ25DLE9BQU8sQ0FBQyxjQUFjLENBQXVCO0lBQzdDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBYTtJQUV0QyxZQUFZLFlBQVksRUFBRSxNQUFNLEVBZ0MvQjtJQUVELE9BQU8sQ0FBQyxVQUFVO0lBNENaLElBQUksQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FldkQ7SUFFSyxPQUFPLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUs3QjtDQUNGIn0=

package/dest/node-cjs/bb_backends/node/native_pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native_pipe.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_pipe.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,kCAAmC,YAAW,oBAAoB;IAC7E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,cAAc,CAA6C;IACnE,OAAO,CAAC,aAAa,CAAyC;IAG9D,OAAO,CAAC,aAAa,CAAiB;IACtC,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,iBAAiB,CAAa;IAEtC,YAAY,YAAY,EAAE,MAAM,EAgC/B;IAED,OAAO,CAAC,UAAU;IA4CZ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAevD;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;CACF"}

package/dest/node-cjs/bb_backends/node/native_pipe.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BarretenbergNativePipeAsyncBackend = void 0;
+const child_process_1 = require("child_process");
+/**
+ * Asynchronous native backend that communicates with bb binary via stdin/stdout.
+ * Uses event-based I/O with a state machine to handle partial reads.
+ *
+ * Protocol:
+ * - Request: 4-byte little-endian length + msgpack buffer
+ * - Response: 4-byte little-endian length + msgpack buffer
+ */
+class BarretenbergNativePipeAsyncBackend {
+    process;
+    pendingResolve = null;
+    pendingReject = null;
+    // State machine for reading responses
+    readingLength = true;
+    lengthBuffer = Buffer.alloc(4);
+    lengthBytesRead = 0;
+    responseLength = 0;
+    responseBuffer = null;
+    responseBytesRead = 0;
+    constructor(bbBinaryPath) {
+        this.process = (0, child_process_1.spawn)(bbBinaryPath, ['msgpack', 'run'], {
+            stdio: ['pipe', 'pipe', 'inherit'],
+        });
+        this.process.stdout.on('data', (chunk) => {
+            this.handleData(chunk);
+        });
+        this.process.on('error', err => {
+            if (this.pendingReject) {
+                this.pendingReject(new Error(`Native backend process error: ${err.message}`));
+                this.pendingReject = null;
+                this.pendingResolve = null;
+            }
+        });
+        this.process.on('exit', (code, signal) => {
+            if (this.pendingReject) {
+                if (code !== null && code !== 0) {
+                    this.pendingReject(new Error(`Native backend process exited with code ${code}`));
+                }
+                else if (signal) {
+                    if (signal != 'SIGTERM') {
+                        this.pendingReject(new Error(`Native backend process killed with signal ${signal}`));
+                    }
+                }
+                else {
+                    this.pendingReject(new Error('Native backend process exited unexpectedly'));
+                }
+                this.pendingReject = null;
+                this.pendingResolve = null;
+            }
+        });
+    }
+    handleData(chunk) {
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (this.readingLength) {
+                // Reading 4-byte length prefix
+                const bytesToCopy = Math.min(4 - this.lengthBytesRead, chunk.length - offset);
+                chunk.copy(this.lengthBuffer, this.lengthBytesRead, offset, offset + bytesToCopy);
+                this.lengthBytesRead += bytesToCopy;
+                offset += bytesToCopy;
+                if (this.lengthBytesRead === 4) {
+                    // Length is complete, switch to reading data
+                    this.responseLength = this.lengthBuffer.readUInt32LE(0);
+                    this.responseBuffer = Buffer.alloc(this.responseLength);
+                    this.responseBytesRead = 0;
+                    this.readingLength = false;
+                }
+            }
+            else {
+                // Reading response data
+                const bytesToCopy = Math.min(this.responseLength - this.responseBytesRead, chunk.length - offset);
+                chunk.copy(this.responseBuffer, this.responseBytesRead, offset, offset + bytesToCopy);
+                this.responseBytesRead += bytesToCopy;
+                offset += bytesToCopy;
+                if (this.responseBytesRead === this.responseLength) {
+                    // Response is complete
+                    if (this.pendingResolve) {
+                        this.pendingResolve(new Uint8Array(this.responseBuffer));
+                        this.pendingResolve = null;
+                        this.pendingReject = null;
+                    }
+                    // Reset state for next message
+                    this.readingLength = true;
+                    this.lengthBytesRead = 0;
+                    this.responseLength = 0;
+                    this.responseBuffer = null;
+                    this.responseBytesRead = 0;
+                }
+            }
+        }
+    }
+    async call(inputBuffer) {
+        if (this.pendingResolve) {
+            throw new Error('Cannot call while another call is pending (no pipelining supported)');
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingResolve = resolve;
+            this.pendingReject = reject;
+            // Write request: 4-byte little-endian length + msgpack data
+            const lengthBuf = Buffer.alloc(4);
+            lengthBuf.writeUInt32LE(inputBuffer.length, 0);
+            this.process.stdin.write(lengthBuf);
+            this.process.stdin.write(inputBuffer);
+        });
+    }
+    async destroy() {
+        this.process.kill();
+        return new Promise(resolve => {
+            this.process.once('exit', () => resolve());
+        });
+    }
+}
+exports.BarretenbergNativePipeAsyncBackend = BarretenbergNativePipeAsyncBackend;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/node-cjs/bb_backends/node/native_shm.d.ts

@@ -0,0 +1,28 @@
+import { IMsgpackBackendSync } from '../interface.js';
+/**
+ * Synchronous shared memory backend that communicates with bb binary via shared memory.
+ * Uses NAPI module to interface with shared memory IPC.
+ *
+ * Architecture: bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the shared memory region
+ * - TypeScript connects via NAPI wrapper
+ *
+ * Protocol:
+ * - Handled internally by IpcClient (no manual length prefixes needed)
+ */
+export declare class BarretenbergNativeShmSyncBackend implements IMsgpackBackendSync {
+    private process;
+    private client;
+    private logFd?;
+    private constructor();
+    /**
+     * Create and initialize a shared memory backend.
+     * @param bbBinaryPath Path to bb binary
+     * @param threads Optional number of threads
+     */
+    static new(bbBinaryPath: string, threads?: number, logger?: (msg: string) => void): Promise<BarretenbergNativeShmSyncBackend>;
+    call(inputBuffer: Uint8Array): Uint8Array;
+    private cleanup;
+    destroy(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2JiX2JhY2tlbmRzL25vZGUvbmF0aXZlX3NobS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQW9CdEQ7Ozs7Ozs7Ozs7R0FVRztBQUNILHFCQUFhLGdDQUFpQyxZQUFXLG1CQUFtQjtJQUMxRSxPQUFPLENBQUMsT0FBTyxDQUFlO0lBQzlCLE9BQU8sQ0FBQyxNQUFNLENBQU07SUFDcEIsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFTO0lBRXZCLE9BQU8sZUFJTjtJQUVEOzs7O09BSUc7SUFDSCxPQUFhLEdBQUcsQ0FDZCxZQUFZLEVBQUUsTUFBTSxFQUNwQixPQUFPLENBQUMsRUFBRSxNQUFNLEVBQ2hCLE1BQU0sQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLE1BQU0sS0FBSyxJQUFJLEdBQzdCLE9BQU8sQ0FBQyxnQ0FBZ0MsQ0FBQyxDQTBHM0M7SUFFRCxJQUFJLENBQUMsV0FBVyxFQUFFLFVBQVUsR0FBRyxVQUFVLENBT3hDO0lBRUQsT0FBTyxDQUFDLE9BQU87SUFpQmYsT0FBTyxJQUFJLElBQUksQ0FLZDtDQUNGIn0=

package/dest/node-cjs/bb_backends/node/native_shm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native_shm.d.ts","sourceRoot":"","sources":["../../../../src/bb_backends/node/native_shm.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAoBtD;;;;;;;;;;GAUG;AACH,qBAAa,gCAAiC,YAAW,mBAAmB;IAC1E,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,KAAK,CAAC,CAAS;IAEvB,OAAO,eAIN;IAED;;;;OAIG;IACH,OAAa,GAAG,CACd,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC7B,OAAO,CAAC,gCAAgC,CAAC,CA0G3C;IAED,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,CAOxC;IAED,OAAO,CAAC,OAAO;IAiBf,OAAO,IAAI,IAAI,CAKd;CACF"}

package/dest/node-cjs/bb_backends/node/native_shm.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BarretenbergNativeShmSyncBackend = void 0;
+const module_1 = require("module");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const platform_js_1 = require("./platform.js");
+// Import the NAPI module
+// The addon is built to the nodejs_module directory
+const addonPath = (0, platform_js_1.findNapiBinary)();
+// Try loading, but don't throw if it doesn't exist (will be caught in constructor)
+let addon = null;
+try {
+    if (addonPath) {
+        const require = (0, module_1.createRequire)((0, platform_js_1.findPackageRoot)());
+        addon = require(addonPath);
+    }
+}
+catch (err) {
+    // Addon not built yet or not available
+    addon = null;
+}
+let instanceCounter = 0;
+/**
+ * Synchronous shared memory backend that communicates with bb binary via shared memory.
+ * Uses NAPI module to interface with shared memory IPC.
+ *
+ * Architecture: bb acts as the SERVER, TypeScript is the CLIENT
+ * - bb creates the shared memory region
+ * - TypeScript connects via NAPI wrapper
+ *
+ * Protocol:
+ * - Handled internally by IpcClient (no manual length prefixes needed)
+ */
+class BarretenbergNativeShmSyncBackend {
+    process;
+    client; // NAPI MsgpackClient instance
+    logFd; // File descriptor for logs
+    constructor(process, client, logFd) {
+        this.process = process;
+        this.client = client;
+        this.logFd = logFd;
+    }
+    /**
+     * Create and initialize a shared memory backend.
+     * @param bbBinaryPath Path to bb binary
+     * @param threads Optional number of threads
+     */
+    static async new(bbBinaryPath, threads, logger) {
+        if (!addon || !addon.MsgpackClient) {
+            throw new Error('Shared memory NAPI not available.');
+        }
+        // Create a unique shared memory name
+        const shmName = `bb-sync-${process.pid}-${instanceCounter++}`;
+        // If threads not set use 1 thread. We're not expected to do long lived work on sync backends.
+        const hwc = threads ? threads.toString() : '1';
+        const env = { ...process.env, HARDWARE_CONCURRENCY: hwc };
+        // Set up file logging if logger is provided.
+        // Direct file redirection bypasses Node event loop - logs are written even if process hangs.
+        let logFd;
+        let logPath;
+        if (logger) {
+            logPath = `/tmp/${shmName}.log`;
+            logFd = (0, fs_1.openSync)(logPath, 'w');
+            logger(`BB process logs redirected to: ${logPath}`);
+        }
+        // Spawn bb process with shared memory mode (SPSC-only, no max-clients needed)
+        const args = ['msgpack', 'run', '--input', `${shmName}.shm`, '--request-ring-size', `${1024 * 1024 * 4}`];
+        const bbProcess = (0, child_process_1.spawn)(bbBinaryPath, args, {
+            stdio: ['ignore', logFd ?? 'ignore', logFd ?? 'ignore'],
+            env,
+        });
+        // Disconnect from event loop so process can exit without waiting for bb
+        // The bb process has parent death monitoring (prctl on Linux, kqueue on macOS)
+        // so it will automatically exit when Node.js exits
+        bbProcess.unref();
+        // Track if process has exited
+        let processExited = false;
+        let exitError = null;
+        bbProcess.on('error', err => {
+            processExited = true;
+            exitError = new Error(`Native backend process error: ${err.message}`);
+        });
+        bbProcess.on('exit', (code, signal) => {
+            processExited = true;
+            if (code !== null && code !== 0) {
+                exitError = new Error(`Native backend process exited with code ${code}`);
+            }
+            else if (signal && signal !== 'SIGTERM') {
+                exitError = new Error(`Native backend process killed with signal ${signal}`);
+            }
+        });
+        // Wait for bb to create shared memory
+        // Retry connection every 100ms for up to 3 seconds
+        const retryInterval = 100; // ms
+        const timeout = 3000; // ms
+        const maxAttempts = Math.floor(timeout / retryInterval);
+        let client = null;
+        try {
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                // Check if bb process has exited before attempting connection
+                if (processExited) {
+                    throw exitError || new Error('Native backend process exited unexpectedly during startup');
+                }
+                // Wait before attempting connection (except first attempt)
+                if (attempt > 0) {
+                    await new Promise(resolve => setTimeout(resolve, retryInterval));
+                }
+                try {
+                    // Create NAPI client (SPSC-only, no max_clients needed)
+                    client = new addon.MsgpackClient(shmName);
+                    break; // Success!
+                }
+                catch (err) {
+                    // Connection failed, will retry
+                    if (attempt === maxAttempts - 1) {
+                        // Last attempt failed - check one more time if process exited
+                        if (processExited && exitError) {
+                            throw exitError;
+                        }
+                        throw new Error(`Failed to connect to shared memory after ${timeout}ms: ${err.message}`);
+                    }
+                }
+            }
+            if (!client) {
+                throw new Error('Failed to create client connection');
+            }
+            return new BarretenbergNativeShmSyncBackend(bbProcess, client, logFd);
+        }
+        finally {
+            // If we failed to connect, ensure the process is killed and log file closed
+            // kill() returns false if process already exited, but doesn't throw
+            if (!client) {
+                bbProcess.kill('SIGKILL');
+                if (logFd !== undefined) {
+                    try {
+                        (0, fs_1.closeSync)(logFd);
+                    }
+                    catch (e) {
+                        // Ignore errors during cleanup
+                    }
+                }
+            }
+        }
+    }
+    call(inputBuffer) {
+        try {
+            const responseBuffer = this.client.call(Buffer.from(inputBuffer));
+            return new Uint8Array(responseBuffer);
+        }
+        catch (err) {
+            throw new Error(`Shared memory call failed: ${err.message}`);
+        }
+    }
+    cleanup() {
+        if (this.client) {
+            try {
+                this.client.close();
+            }
+            catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+        if (this.logFd !== undefined) {
+            try {
+                (0, fs_1.closeSync)(this.logFd);
+            }
+            catch (e) {
+                // Ignore errors during cleanup
+            }
+        }
+    }
+    destroy() {
+        this.cleanup();
+        this.process.kill('SIGTERM');
+        // Remove process event listeners to prevent hanging
+        this.process.removeAllListeners();
+    }
+}
+exports.BarretenbergNativeShmSyncBackend = BarretenbergNativeShmSyncBackend;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlX3NobS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iYl9iYWNrZW5kcy9ub2RlL25hdGl2ZV9zaG0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQXVDO0FBQ3ZDLGlEQUFvRDtBQUNwRCwyQkFBeUM7QUFFekMsK0NBQWdFO0FBRWhFLHlCQUF5QjtBQUN6QixvREFBb0Q7QUFDcEQsTUFBTSxTQUFTLEdBQUcsSUFBQSw0QkFBYyxHQUFFLENBQUM7QUFDbkMsbUZBQW1GO0FBQ25GLElBQUksS0FBSyxHQUFRLElBQUksQ0FBQztBQUN0QixJQUFJLENBQUM7SUFDSCxJQUFJLFNBQVMsRUFBRSxDQUFDO1FBQ2QsTUFBTSxPQUFPLEdBQUcsSUFBQSxzQkFBYSxFQUFDLElBQUEsNkJBQWUsR0FBRyxDQUFDLENBQUM7UUFDbEQsS0FBSyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM3QixDQUFDO0FBQ0gsQ0FBQztBQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7SUFDYix1Q0FBdUM7SUFDdkMsS0FBSyxHQUFHLElBQUksQ0FBQztBQUNmLENBQUM7QUFFRCxJQUFJLGVBQWUsR0FBRyxDQUFDLENBQUM7QUFFeEI7Ozs7Ozs7Ozs7R0FVRztBQUNIO0lBQ1UsT0FBTyxDQUFlO0lBQ3RCLE1BQU0sQ0FBTSxDQUFDLDhCQUE4QjtJQUMzQyxLQUFLLENBQVUsQ0FBQywyQkFBMkI7SUFFbkQsWUFBb0IsT0FBcUIsRUFBRSxNQUFXLEVBQUUsS0FBYyxFQUFFO1FBQ3RFLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO0lBQUEsQ0FDcEI7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQ2QsWUFBb0IsRUFDcEIsT0FBZ0IsRUFDaEIsTUFBOEIsRUFDYTtRQUMzQyxJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztRQUN2RCxDQUFDO1FBRUQscUNBQXFDO1FBQ3JDLE1BQU0sT0FBTyxHQUFHLFdBQVcsT0FBTyxDQUFDLEdBQUcsSUFBSSxlQUFlLEVBQUUsRUFBRSxDQUFDO1FBRTlELDhGQUE4RjtRQUM5RixNQUFNLEdBQUcsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDO1FBQy9DLE1BQU0sR0FBRyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLG9CQUFvQixFQUFFLEdBQUcsRUFBRSxDQUFDO1FBRTFELDZDQUE2QztRQUM3Qyw2RkFBNkY7UUFDN0YsSUFBSSxLQUF5QixDQUFDO1FBQzlCLElBQUksT0FBMkIsQ0FBQztRQUNoQyxJQUFJLE1BQU0sRUFBRSxDQUFDO1lBQ1gsT0FBTyxHQUFHLFFBQVEsT0FBTyxNQUFNLENBQUM7WUFDaEMsS0FBSyxHQUFHLElBQUEsYUFBUSxFQUFDLE9BQU8sRUFBRSxHQUFHLENBQUMsQ0FBQztZQUMvQixNQUFNLENBQUMsa0NBQWtDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDdEQsQ0FBQztRQUVELDhFQUE4RTtRQUM5RSxNQUFNLElBQUksR0FBRyxDQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLEdBQUcsT0FBTyxNQUFNLEVBQUUscUJBQXFCLEVBQUUsR0FBRyxJQUFJLEdBQUcsSUFBSSxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDMUcsTUFBTSxTQUFTLEdBQUcsSUFBQSxxQkFBSyxFQUFDLFlBQVksRUFBRSxJQUFJLEVBQUU7WUFDMUMsS0FBSyxFQUFFLENBQUMsUUFBUSxFQUFFLEtBQUssSUFBSSxRQUFRLEVBQUUsS0FBSyxJQUFJLFFBQVEsQ0FBQztZQUN2RCxHQUFHO1NBQ0osQ0FBQyxDQUFDO1FBRUgsd0VBQXdFO1FBQ3hFLCtFQUErRTtRQUMvRSxtREFBbUQ7UUFDbkQsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBRWxCLDhCQUE4QjtRQUM5QixJQUFJLGFBQWEsR0FBRyxLQUFLLENBQUM7UUFDMUIsSUFBSSxTQUFTLEdBQWlCLElBQUksQ0FBQztRQUVuQyxTQUFTLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzNCLGFBQWEsR0FBRyxJQUFJLENBQUM7WUFDckIsU0FBUyxHQUFHLElBQUksS0FBSyxDQUFDLGlDQUFpQyxHQUFHLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUFBLENBQ3ZFLENBQUMsQ0FBQztRQUVILFNBQVMsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxFQUFFLENBQUM7WUFDckMsYUFBYSxHQUFHLElBQUksQ0FBQztZQUNyQixJQUFJLElBQUksS0FBSyxJQUFJLElBQUksSUFBSSxLQUFLLENBQUMsRUFBRSxDQUFDO2dCQUNoQyxTQUFTLEdBQUcsSUFBSSxLQUFLLENBQUMsMkNBQTJDLElBQUksRUFBRSxDQUFDLENBQUM7WUFDM0UsQ0FBQztpQkFBTSxJQUFJLE1BQU0sSUFBSSxNQUFNLEtBQUssU0FBUyxFQUFFLENBQUM7Z0JBQzFDLFNBQVMsR0FBRyxJQUFJLEtBQUssQ0FBQyw2Q0FBNkMsTUFBTSxFQUFFLENBQUMsQ0FBQztZQUMvRSxDQUFDO1FBQUEsQ0FDRixDQUFDLENBQUM7UUFFSCxzQ0FBc0M7UUFDdEMsbURBQW1EO1FBQ25ELE1BQU0sYUFBYSxHQUFHLEdBQUcsQ0FBQyxDQUFDLEtBQUs7UUFDaEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLENBQUMsS0FBSztRQUMzQixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sR0FBRyxhQUFhLENBQUMsQ0FBQztRQUN4RCxJQUFJLE1BQU0sR0FBUSxJQUFJLENBQUM7UUFFdkIsSUFBSSxDQUFDO1lBQ0gsS0FBSyxJQUFJLE9BQU8sR0FBRyxDQUFDLEVBQUUsT0FBTyxHQUFHLFdBQVcsRUFBRSxPQUFPLEVBQUUsRUFBRSxDQUFDO2dCQUN2RCw4REFBOEQ7Z0JBQzlELElBQUksYUFBYSxFQUFFLENBQUM7b0JBQ2xCLE1BQU0sU0FBUyxJQUFJLElBQUksS0FBSyxDQUFDLDJEQUEyRCxDQUFDLENBQUM7Z0JBQzVGLENBQUM7Z0JBRUQsMkRBQTJEO2dCQUMzRCxJQUFJLE9BQU8sR0FBRyxDQUFDLEVBQUUsQ0FBQztvQkFDaEIsTUFBTSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsYUFBYSxDQUFDLENBQUMsQ0FBQztnQkFDbkUsQ0FBQztnQkFFRCxJQUFJLENBQUM7b0JBQ0gsd0RBQXdEO29CQUN4RCxNQUFNLEdBQUcsSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxDQUFDO29CQUMxQyxNQUFNLENBQUMsV0FBVztnQkFDcEIsQ0FBQztnQkFBQyxPQUFPLEdBQVEsRUFBRSxDQUFDO29CQUNsQixnQ0FBZ0M7b0JBQ2hDLElBQUksT0FBTyxLQUFLLFdBQVcsR0FBRyxDQUFDLEVBQUUsQ0FBQzt3QkFDaEMsOERBQThEO3dCQUM5RCxJQUFJLGFBQWEsSUFBSSxTQUFTLEVBQUUsQ0FBQzs0QkFDL0IsTUFBTSxTQUFTLENBQUM7d0JBQ2xCLENBQUM7d0JBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyw0Q0FBNEMsT0FBTyxPQUFPLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO29CQUMzRixDQUFDO2dCQUNILENBQUM7WUFDSCxDQUFDO1lBRUQsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUNaLE1BQU0sSUFBSSxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztZQUN4RCxDQUFDO1lBRUQsT0FBTyxJQUFJLGdDQUFnQyxDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDeEUsQ0FBQztnQkFBUyxDQUFDO1lBQ1QsNEVBQTRFO1lBQzVFLG9FQUFvRTtZQUNwRSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7Z0JBQ1osU0FBUyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztnQkFDMUIsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7b0JBQ3hCLElBQUksQ0FBQzt3QkFDSCxJQUFBLGNBQVMsRUFBQyxLQUFLLENBQUMsQ0FBQztvQkFDbkIsQ0FBQztvQkFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO3dCQUNYLCtCQUErQjtvQkFDakMsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztRQUNILENBQUM7SUFBQSxDQUNGO0lBRUQsSUFBSSxDQUFDLFdBQXVCLEVBQWM7UUFDeEMsSUFBSSxDQUFDO1lBQ0gsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO1lBQ2xFLE9BQU8sSUFBSSxVQUFVLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDeEMsQ0FBQztRQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7WUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQyw4QkFBOEIsR0FBRyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFDL0QsQ0FBQztJQUFBLENBQ0Y7SUFFTyxPQUFPLEdBQVM7UUFDdEIsSUFBSSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDO2dCQUNILElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDdEIsQ0FBQztZQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7Z0JBQ1gsK0JBQStCO1lBQ2pDLENBQUM7UUFDSCxDQUFDO1FBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQztnQkFDSCxJQUFBLGNBQVMsRUFBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDeEIsQ0FBQztZQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7Z0JBQ1gsK0JBQStCO1lBQ2pDLENBQUM7UUFDSCxDQUFDO0lBQUEsQ0FDRjtJQUVELE9BQU8sR0FBUztRQUNkLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNmLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzdCLG9EQUFvRDtRQUNwRCxJQUFJLENBQUMsT0FBTyxDQUFDLGtCQUFrQixFQUFFLENBQUM7SUFBQSxDQUNuQztDQUNGIn0=