@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/viem/internal/viem-p.ts

@@ -0,0 +1,105 @@
+import type { PublicClient } from 'viem';
+import type { TrustedClient } from '../../core/modules/ethereum/types.js';
+import type { FhevmRuntime, FhevmRuntimeConfig } from '../../core/types/coreFhevmRuntime.js';
+import type { CreateFhevmRuntimeParameters } from '../../core/runtime/CoreFhevmRuntime-p.js';
+import { verifyTrustedValue } from '../../core/base/trustedValue.js';
+import { createFhevmRuntime as createFhevmRuntime_ } from '../../core/runtime/CoreFhevmRuntime-p.js';
+import { createTrustedClient } from '../../core/modules/ethereum/createTrustedClient.js';
+import { ethereumModule } from './ethereum.js';
+import { relayerModule } from '../../core/modules/relayer/module/index.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Will leak in js
+export const PRIVATE_VIEM_TOKEN = Symbol('viem.token');
+
+////////////////////////////////////////////////////////////////////////////////
+
+let viemFhevmRuntime: FhevmRuntime | undefined;
+let viemFhevmRuntimeConfig: FhevmRuntimeConfig | undefined;
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Sets the global {@link FhevmRuntimeConfig} used by the viem adapter.
+ *
+ * Must be called before any runtime or client is created.
+ * May be called multiple times with identical parameters (idempotent).
+ * Throws if called again with different parameters.
+ *
+ * @param config - The runtime configuration.
+ * @throws If a different config has already been set.
+ */
+export function setFhevmRuntimeConfig(config: FhevmRuntimeConfig): void {
+  if (viemFhevmRuntimeConfig === undefined) {
+    viemFhevmRuntimeConfig = { ...config };
+    return;
+  }
+  if (
+    viemFhevmRuntimeConfig.logger !== config.logger ||
+    viemFhevmRuntimeConfig.locateFile !== config.locateFile ||
+    viemFhevmRuntimeConfig.singleThread !== config.singleThread ||
+    viemFhevmRuntimeConfig.numberOfThreads !== config.numberOfThreads
+  ) {
+    throw new Error(
+      'FhevmRuntime config has already been set and cannot be changed. ' +
+        'Ensure setFhevmRuntimeConfig is called only once, or with identical parameters.',
+    );
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function getViemRuntime(): FhevmRuntime {
+  if (viemFhevmRuntimeConfig === undefined) {
+    throw new Error('Call setFhevmRuntimeConfig first.');
+  }
+
+  const em = ethereumModule();
+  const rm = relayerModule();
+
+  viemFhevmRuntime ??= createFhevmRuntime({
+    ethereum: em.ethereum,
+    relayer: rm.relayer,
+    config: viemFhevmRuntimeConfig,
+  });
+  return viemFhevmRuntime;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Seals a viem `PublicClient` into an opaque {@link TrustedClient}.
+ *
+ * The returned value can be passed through the core layer without exposing
+ * the underlying viem instance. Only the viem adapter can later recover
+ * the original public client via {@link trustedClientToViemPublicClient}.
+ *
+ * @param publicClient - The viem public client to seal.
+ * @returns An opaque {@link TrustedClient} bound to the viem origin token.
+ */
+export function viemPublicClientToTrustedClient<client extends PublicClient>(
+  publicClient: client,
+): TrustedClient<client> {
+  return createTrustedClient(publicClient, PRIVATE_VIEM_TOKEN);
+}
+
+/**
+ * Verifies that the {@link TrustedClient} was created by the viem adapter
+ * and extracts the original `PublicClient`.
+ *
+ * @param trustedClient - The host client to verify.
+ * @returns The original viem `PublicClient`.
+ * @throws {Error} If the client was not created by {@link viemPublicClientToTrustedClient}.
+ */
+export function trustedClientToViemPublicClient<client extends PublicClient>(
+  trustedClient: TrustedClient<client>,
+): client {
+  return verifyTrustedValue(trustedClient, PRIVATE_VIEM_TOKEN);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function createFhevmRuntime(parameters: CreateFhevmRuntimeParameters): FhevmRuntime {
+  return createFhevmRuntime_(PRIVATE_VIEM_TOKEN, parameters);
+}

package/viem/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/viem/index.d.ts",
+  "module": "../_esm/viem/index.js",
+  "main": "../_cjs/viem/index.js"
+}

package/viem/runtime/initFhevmDecryptRuntime.ts

@@ -0,0 +1,8 @@
+import { getViemRuntime, PRIVATE_VIEM_TOKEN } from '../internal/viem-p.js';
+import { initFhevmDecryptRuntime as initFhevmDecyptRuntime_ } from '../../core/runtime/initFhevmDecryptRuntime-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function initFhevmDecryptRuntime(): Promise<void> {
+  return initFhevmDecyptRuntime_(getViemRuntime(), PRIVATE_VIEM_TOKEN);
+}

package/viem/runtime/initFhevmEncryptRuntime.ts

@@ -0,0 +1,8 @@
+import { getViemRuntime, PRIVATE_VIEM_TOKEN } from '../internal/viem-p.js';
+import { initFhevmEncryptRuntime as initFhevmEncryptRuntime_ } from '../../core/runtime/initFhevmEncryptRuntime-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function initFhevmEncryptRuntime(): Promise<void> {
+  return initFhevmEncryptRuntime_(getViemRuntime(), PRIVATE_VIEM_TOKEN);
+}

package/viem/runtime/initFhevmRuntime.ts

@@ -0,0 +1,8 @@
+import { getViemRuntime, PRIVATE_VIEM_TOKEN } from '../internal/viem-p.js';
+import { initFhevmRuntime as initFhevmRuntime_ } from '../../core/runtime/initFhevmRuntime-p.js';
+
+////////////////////////////////////////////////////////////////////////////////
+
+export function initFhevmRuntime(): Promise<void> {
+  return initFhevmRuntime_(getViemRuntime(), PRIVATE_VIEM_TOKEN);
+}

package/wasm/tfhe/compile-worker.js

@@ -0,0 +1,8 @@
+// One-shot worker: loads base64 wasm, decodes, compiles, posts back the Module
+import { parentPort } from "node:worker_threads";
+import { tfheWasmBase64 } from "./tfhe_bg.v1.5.3.wasm.base64.js";
+
+const res = await fetch(`data:application/octet-stream;base64,${tfheWasmBase64}`);
+const bytes = new Uint8Array(await res.arrayBuffer());
+const module = await WebAssembly.compile(bytes);
+parentPort.postMessage(module);

package/wasm/tfhe/startWorkers.v1.5.3.js

@@ -0,0 +1,426 @@
+/**
+ * Detect browser-like environment by checking for global event listener APIs.
+ */
+function __isBrowserLike() {
+  return (
+    typeof addEventListener === "function" &&
+    typeof removeEventListener === "function"
+  );
+}
+
+/**
+ * Create a Worker from the given URL, handling browser and Node.js differences.
+ * In Node.js, data: URLs are decoded and executed via eval mode since
+ * `node:worker_threads` does not support them natively.
+ * @param {string | URL} url - Script URL for the worker (supports data: URLs in Node.js).
+ * @returns {Promise<Worker>}
+ */
+async function __newIsomorphicWorker(url) {
+  // Browser
+  if (__isBrowserLike()) {
+    //var Worker: new (scriptURL: string | URL, options?: WorkerOptions | undefined) => Worker
+    return new Worker(url, {
+      type: "module",
+      name: "wasm_bindgen_worker",
+    });
+  }
+
+  // Node.js
+  const nodeModuleName = "worker_threads";
+  const nodeModuleId = `node:${nodeModuleName}`;
+  const { Worker: NodeWorker } = await import(/* @vite-ignore */ nodeModuleId);
+
+  // Node's Worker doesn't support data: or blob: URLs.
+  // For data: URLs, extract the code and use eval mode.
+  if (typeof url === "string" && url.startsWith("data:")) {
+    const base64 = url.split(",")[1];
+    const code = Buffer.from(base64, "base64").toString("utf-8");
+    return new NodeWorker(code, { eval: true });
+  }
+
+  return new NodeWorker(url);
+}
+
+/**
+ * Create a Worker from a base64-encoded JavaScript source string.
+ * In the browser, decodes to a Blob URL; in Node.js, decodes and runs via eval mode.
+ * @param {string} jsCodeBase64 - Base64-encoded JavaScript source code.
+ * @returns {Promise<{ worker: Worker, blobUrl: string | undefined }>}
+ */
+async function __newWorkerFromJsCodeBase64(jsCodeBase64) {
+  // Browser
+  if (__isBrowserLike()) {
+    const blob = new Blob([atob(jsCodeBase64)], {
+      type: "application/javascript",
+    });
+
+    const blobUrl = URL.createObjectURL(blob);
+
+    try {
+      const worker = new Worker(blobUrl, {
+        type: "module",
+        name: "wasm_bindgen_worker",
+      });
+
+      // Caller is responsible for revoking blobUrl after the worker is ready.
+      return { worker, blobUrl };
+    } catch (e) {
+      URL.revokeObjectURL(blobUrl);
+      throw e;
+    }
+  }
+
+  // Node.js
+  const nodeModuleName = "worker_threads";
+  const nodeModuleId = `node:${nodeModuleName}`;
+  const { Worker: NodeWorker } = await import(/* @vite-ignore */ nodeModuleId);
+
+  const code = Buffer.from(jsCodeBase64, "base64").toString("utf-8");
+
+  return { worker: new NodeWorker(code, { eval: true }), blobUrl: undefined };
+}
+
+/**
+ * Wait for a message of the given type from a Worker.
+ * Handles both Node.js EventEmitter (`on`/`off`) and browser DOM event APIs.
+ * Rejects on worker errors or non-zero exit codes (Node.js).
+ * @param {Worker} target - The worker to listen on.
+ * @param {string} type - The `type` field of the expected message.
+ * @returns {Promise<object>} Resolves with the matching message data.
+ */
+function __waitForMsgType(target, type) {
+  return new Promise((resolve, reject) => {
+    function cleanup() {
+      if (typeof target.removeEventListener === "function") {
+        target.removeEventListener("message", onBrowserMsg);
+        target.removeEventListener("error", onBrowserError);
+      } else {
+        target.off("message", onNodeMsg);
+        target.off("error", onNodeError);
+        target.off("exit", onNodeExit);
+      }
+    }
+
+    // Browser handlers
+    function onBrowserMsg({ data }) {
+      if (data?.type !== type) return;
+      cleanup();
+      resolve(data);
+    }
+    function onBrowserError(e) {
+      cleanup();
+      reject(e.error || new Error("Worker error"));
+    }
+
+    // Node handlers
+    function onNodeMsg(data) {
+      if (data?.type !== type) return;
+      cleanup();
+      resolve(data);
+    }
+    function onNodeError(err) {
+      cleanup();
+      reject(err);
+    }
+    function onNodeExit(code) {
+      cleanup();
+      reject(new Error(`Worker exited with code ${code}`));
+    }
+
+    if (typeof target.removeEventListener === "function") {
+      // Browser: DOM events
+      target.addEventListener("message", onBrowserMsg);
+      target.addEventListener("error", onBrowserError);
+    } else {
+      // Node: EventEmitter
+      target.on("message", onNodeMsg);
+      target.on("error", onNodeError);
+      target.on("exit", onNodeExit);
+    }
+  });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Module variables
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/** @type {Promise<PromiseSettledResult<void>[]> | undefined} In-flight termination promise, if any. */
+let _terminating;
+
+/** @type {boolean} Whether {@link setWorkerUrlConfig} has already been called. */
+let _configSet = false;
+
+/** @type {URL | undefined} Custom URL for the worker script, if provided. */
+let _workerUrl = undefined;
+
+/** @type {{ debug: Function, error: Function } | undefined} Optional logger. */
+let _logger = undefined;
+
+/** @type {boolean} Whether {@link startWorkers} has already been called. */
+let _started = false;
+
+// Note: this is never used, but necessary to prevent a bug in Firefox
+// (https://bugzilla.mozilla.org/show_bug.cgi?id=1702191) where it collects
+// Web Workers that have a shared WebAssembly memory with the main thread,
+// but are not explicitly rooted via a `Worker` instance.
+//
+// By storing them in a variable, we can keep `Worker` objects around and
+// prevent them from getting GC-d.
+/** @type {Worker[] | undefined} */
+let _workers;
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Exported functions
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Return the current running TFHE worker threads.
+ * @returns {Worker[] | undefined}
+ */
+function getTfheWorkers() {
+  return _workers;
+}
+
+/**
+ * Configure the worker script URL and logger. Can only be called once.
+ * @param {object} [config]
+ * @param {URL | undefined} [config.workerUrl] - URL to the worker script. Falls back to embedded base64 if omitted.
+ * @param {{ debug: Function, error: Function } | undefined} [config.logger] - Optional logger instance.
+ * @throws {Error} If called more than once.
+ * @throws {TypeError} If `workerUrl` is not a `URL` instance.
+ */
+function setWorkerUrlConfig({
+  workerUrl = undefined,
+  logger = undefined,
+} = {}) {
+  if (_configSet) {
+    throw new Error("Cannot set worker url (already set)");
+  }
+
+  if (workerUrl !== undefined) {
+    if (!(workerUrl instanceof URL)) {
+      throw new TypeError("workerUrl must be a URL");
+    }
+    _workerUrl = workerUrl;
+  }
+
+  _logger = logger;
+
+  _configSet = true;
+}
+
+/**
+ * Create a Worker from the embedded base64-encoded worker script.
+ * Used as the last-resort fallback when no `workerUrl` is available
+ * or when direct/blob URL creation fails.
+ * - copy/paste base64 from `./tfhe-worker.v1.5.3.inline.js`
+ * - run `./inline-worker.build.mjs` to generate
+ * @returns {Promise<{ worker: Worker, blobUrl: string | undefined }>}
+ */
+async function __createWorkerFromBase64() {
+  // SHA-256: caa32a0babf2c76b7097e67b1cbae06256c3db638e31c02348c9c37988cc5f2e
+  const workerBase64 =
+    "function ___isBrowserLike(){return typeof addEventListener=="function"&&typeof removeEventListener=="function"}async function ___getTarget(){if(___isBrowserLike())return self;const _="node:worker_threads",{parentPort:e}=await import(_);return e}function ___waitForMsgType(t,_){return new Promise(e=>{typeof t.on=="function"?t.on("message",function n(r){r?.type===_&&(t.off("message",n),e(r))}):t.addEventListener("message",function n({data:r}){r?.type===_&&(t.removeEventListener("message",n),e(r))})})}___getTarget().then(t=>___waitForMsgType(t,"wasm_bindgen_worker_init").then(async({init:_,receiver:e})=>{const n=await Promise.resolve().then(function(){return tfhe});await n.default(_),t.postMessage({type:"wasm_bindgen_worker_ready"}),n.wbg_rayon_start_worker(e)}));function wbg_rayon_start_worker(t){wasm.wbg_rayon_start_worker(t)}function debugString(t){const _=typeof t;if(_=="number"||_=="boolean"||t==null)return`${t}`;if(_=="string")return`"${t}"`;if(_=="symbol"){const r=t.description;return r==null?"Symbol":`Symbol(${r})`}if(_=="function"){const r=t.name;return typeof r=="string"&&r.length>0?`Function(${r})`:"Function"}if(Array.isArray(t)){const r=t.length;let o="[";r>0&&(o+=debugString(t[0]));for(let i=1;i<r;i++)o+=", "+debugString(t[i]);return o+="]",o}const e=/\[object ([^\]]+)\]/.exec(toString.call(t));let n;if(e&&e.length>1)n=e[1];else return toString.call(t);if(n=="Object")try{return"Object("+JSON.stringify(t)+")"}catch{return"Object"}return t instanceof Error?`${t.name}: ${t.message}
${t.stack}`:n}function getStringFromWasm0(t,_){return t=t>>>0,decodeText(t,_)}let cachedTextDecoder=typeof TextDecoder<"u"?new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}):void 0;cachedTextDecoder&&cachedTextDecoder.decode();const MAX_SAFARI_DECODE_BYTES=2146435072;let numBytesDecoded=0;function decodeText(t,_){return numBytesDecoded+=_,numBytesDecoded>=MAX_SAFARI_DECODE_BYTES&&(cachedTextDecoder=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),cachedTextDecoder.decode(),numBytesDecoded=_),cachedTextDecoder.decode(getUint8ArrayMemory0().slice(t,t+_))}function addToExternrefTable0(t){const _=wasm.__externref_table_alloc();return wasm.__wbindgen_externrefs.set(_,t),_}let cachedDataViewMemory0=null;function getDataViewMemory0(){return(cachedDataViewMemory0===null||cachedDataViewMemory0.buffer!==wasm.memory.buffer)&&(cachedDataViewMemory0=new DataView(wasm.memory.buffer)),cachedDataViewMemory0}let cachedUint8ArrayMemory0=null;function getUint8ArrayMemory0(){return(cachedUint8ArrayMemory0===null||cachedUint8ArrayMemory0.buffer!==wasm.memory.buffer)&&(cachedUint8ArrayMemory0=new Uint8Array(wasm.memory.buffer)),cachedUint8ArrayMemory0}function getArrayU8FromWasm0(t,_){return t=t>>>0,getUint8ArrayMemory0().subarray(t/1,t/1+_)}let WASM_VECTOR_LEN=0;const cachedTextEncoder=typeof TextEncoder<"u"?new TextEncoder:void 0;cachedTextEncoder&&(cachedTextEncoder.encodeInto=function(t,_){const e=cachedTextEncoder.encode(t);return _.set(e),{read:t.length,written:e.length}});function passStringToWasm0(t,_,e){if(e===void 0){const c=cachedTextEncoder.encode(t),s=_(c.length,1)>>>0;return getUint8ArrayMemory0().subarray(s,s+c.length).set(c),WASM_VECTOR_LEN=c.length,s}let n=t.length,r=_(n,1)>>>0;const o=getUint8ArrayMemory0();let i=0;for(;i<n;i++){const c=t.charCodeAt(i);if(c>127)break;o[r+i]=c}if(i!==n){i!==0&&(t=t.slice(i)),r=e(r,n,n=i+t.length*3,1)>>>0;const c=getUint8ArrayMemory0().subarray(r+i,r+n),s=cachedTextEncoder.encodeInto(t,c);i+=s.written,r=e(r,n,i,1)>>>0}return WASM_VECTOR_LEN=i,r}function handleError(t,_){try{return t.apply(this,_)}catch(e){const n=addToExternrefTable0(e);wasm.__wbindgen_exn_store(n)}}function isLikeNone(t){return t==null}function __wbg_get_imports(t){return{__proto__:null,"./tfhe_bg.js":{__proto__:null,__wbg_BigInt_7ea1e749ce6b92fd:function(){return handleError(function(e){return BigInt(e)},arguments)},__wbg_BigInt_b7bbccdff258c9f2:function(e){return BigInt(e)},__wbg_Error_8c4e43fe74559d73:function(e,n){return Error(getStringFromWasm0(e,n))},__wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2:function(e,n){const r=n,o=typeof r=="bigint"?r:void 0;getDataViewMemory0().setBigInt64(e+8,isLikeNone(o)?BigInt(0):o,!0),getDataViewMemory0().setInt32(e+0,!isLikeNone(o),!0)},__wbg___wbindgen_bit_and_4362b1176950d42a:function(e,n){return e&n},__wbg___wbindgen_bit_or_71a02d39796ea13d:function(e,n){return e|n},__wbg___wbindgen_debug_string_0bc8482c6e3508ae:function(e,n){const r=debugString(n),o=passStringToWasm0(r,wasm.__wbindgen_malloc,wasm.__wbindgen_realloc),i=WASM_VECTOR_LEN;getDataViewMemory0().setInt32(e+4,i,!0),getDataViewMemory0().setInt32(e+0,o,!0)},__wbg___wbindgen_is_function_0095a73b8b156f76:function(e){return typeof e=="function"},__wbg___wbindgen_is_object_5ae8e5880f2c1fbd:function(e){const n=e;return typeof n=="object"&&n!==null},__wbg___wbindgen_is_string_cd444516edc5b180:function(e){return typeof e=="string"},__wbg___wbindgen_is_undefined_9e4d92534c42d778:function(e){return e===void 0},__wbg___wbindgen_jsval_eq_11888390b0186270:function(e,n){return e===n},__wbg___wbindgen_lt_bb59cc3d23526e0d:function(e,n){return e<n},__wbg___wbindgen_memory_bd1fbcf21fbef3c8:function(){return wasm.memory},__wbg___wbindgen_module_f6b8052d79c1cc16:function(){return wasmModule},__wbg___wbindgen_neg_6b4d356dff49dcc6:function(e){return-e},__wbg___wbindgen_shl_8d64d06761f9ea4e:function(e,n){return e<<n},__wbg___wbindgen_shr_ef8e07cce709eb54:function(e,n){return e>>n},__wbg___wbindgen_string_get_72fb696202c56729:function(e,n){const r=n,o=typeof r=="string"?r:void 0;var i=isLikeNone(o)?0:passStringToWasm0(o,wasm.__wbindgen_malloc,wasm.__wbindgen_realloc),c=WASM_VECTOR_LEN;getDataViewMemory0().setInt32(e+4,c,!0),getDataViewMemory0().setInt32(e+0,i,!0)},__wbg___wbindgen_throw_be289d5034ed271b:function(e,n){throw new Error(getStringFromWasm0(e,n))},__wbg_call_389efe28435a9388:function(){return handleError(function(e,n){return e.call(n)},arguments)},__wbg_call_4708e0c13bdc8e95:function(){return handleError(function(e,n,r){return e.call(n,r)},arguments)},__wbg_crypto_86f2631e91b51511:function(e){return e.crypto},__wbg_error_7534b8e9a36f1ab4:function(e,n){let r,o;try{r=e,o=n,console.error(getStringFromWasm0(e,n))}finally{wasm.__wbindgen_free(r,o,1)}},__wbg_getRandomValues_b3f15fcbfabb0f8b:function(){return handleError(function(e,n){e.getRandomValues(n)},arguments)},__wbg_getTime_1e3cd1391c5c3995:function(e){return e.getTime()},__wbg_instanceof_Window_ed49b2db8df90359:function(e){let n;try{n=e instanceof Window}catch{n=!1}return n},__wbg_length_32ed9a279acd054c:function(e){return e.length},__wbg_msCrypto_d562bbe83e0d4b91:function(e){return e.msCrypto},__wbg_new_0_73afc35eb544e539:function(){return new Date},__wbg_new_8a6f238a6ece86ea:function(){return new Error},__wbg_new_no_args_1c7c842f08d00ebb:function(e,n){return new Function(getStringFromWasm0(e,n))},__wbg_new_with_length_a2c39cbe88fd8ff1:function(e){return new Uint8Array(e>>>0)},__wbg_node_e1f24f89a7336c2e:function(e){return e.node},__wbg_process_3975fd6c72f520aa:function(e){return e.process},__wbg_prototypesetcall_bdcdcc5842e4d77d:function(e,n,r){Uint8Array.prototype.set.call(getArrayU8FromWasm0(e,n),r)},__wbg_randomFillSync_f8c153b79f285817:function(){return handleError(function(e,n){e.randomFillSync(n)},arguments)},__wbg_require_b74f47fc2d022fd6:function(){return handleError(function(){return module.require},arguments)},__wbg_stack_0ed75d68575b0f3c:function(e,n){const r=n.stack,o=passStringToWasm0(r,wasm.__wbindgen_malloc,wasm.__wbindgen_realloc),i=WASM_VECTOR_LEN;getDataViewMemory0().setInt32(e+4,i,!0),getDataViewMemory0().setInt32(e+0,o,!0)},__wbg_startWorkers_2ca11761e08ff5d5:function(e,n,r){handleError(function(){throw new Error("startWorkers not supported from a worker thread")})},__wbg_static_accessor_GLOBAL_12837167ad935116:function(){const e=typeof global>"u"?null:global;return isLikeNone(e)?0:addToExternrefTable0(e)},__wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f:function(){const e=typeof globalThis>"u"?null:globalThis;return isLikeNone(e)?0:addToExternrefTable0(e)},__wbg_static_accessor_SELF_a621d3dfbb60d0ce:function(){const e=typeof self>"u"?null:self;return isLikeNone(e)?0:addToExternrefTable0(e)},__wbg_static_accessor_WINDOW_f8727f0cf888e0bd:function(){const e=typeof window>"u"?null:window;return isLikeNone(e)?0:addToExternrefTable0(e)},__wbg_subarray_a96e1fef17ed23cb:function(e,n,r){return e.subarray(n>>>0,r>>>0)},__wbg_toString_029ac24421fd7a24:function(e){return e.toString()},__wbg_toString_56d946daff83867b:function(e,n,r){const o=n.toString(r),i=passStringToWasm0(o,wasm.__wbindgen_malloc,wasm.__wbindgen_realloc),c=WASM_VECTOR_LEN;getDataViewMemory0().setInt32(e+4,c,!0),getDataViewMemory0().setInt32(e+0,i,!0)},__wbg_versions_4e31226f5e8dc909:function(e){return e.versions},__wbindgen_cast_0000000000000001:function(e){return e},__wbindgen_cast_0000000000000002:function(e,n){return BigInt.asUintN(64,e)|n<<BigInt(64)},__wbindgen_cast_0000000000000003:function(e){return e},__wbindgen_cast_0000000000000004:function(e,n){return getArrayU8FromWasm0(e,n)},__wbindgen_cast_0000000000000005:function(e,n){return getStringFromWasm0(e,n)},__wbindgen_cast_0000000000000006:function(e,n){return BigInt.asUintN(64,e)|BigInt.asUintN(64,n)<<BigInt(64)},__wbindgen_cast_0000000000000007:function(e){return BigInt.asUintN(64,e)},__wbindgen_init_externref_table:function(){const e=wasm.__wbindgen_externrefs,n=e.grow(4);e.set(0,void 0),e.set(n+0,void 0),e.set(n+1,null),e.set(n+2,!0),e.set(n+3,!1)},memory:t||new WebAssembly.Memory({initial:21,maximum:16384,shared:!0})}}}let wasmModule,wasm;function __wbg_finalize_init(t,_,e){if(wasm=t.exports,wasmModule=_,cachedDataViewMemory0=null,cachedUint8ArrayMemory0=null,typeof e<"u"&&(typeof e!="number"||e===0||e%65536!==0))throw"invalid stack size";return wasm.__wbindgen_start(e),wasm}async function __wbg_load(t,_){if(typeof Response=="function"&&t instanceof Response){if(typeof WebAssembly.instantiateStreaming=="function")try{return await WebAssembly.instantiateStreaming(t,_)}catch(r){if(t.ok&&e(t.type)&&t.headers.get("Content-Type")!=="application/wasm")console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",r);else throw r}const n=await t.arrayBuffer();return await WebAssembly.instantiate(n,_)}else{const n=await WebAssembly.instantiate(t,_);return n instanceof WebAssembly.Instance?{instance:n,module:t}:n}function e(n){switch(n){case"basic":case"cors":case"default":return!0}return!1}}async function __wbg_init(t,_){if(wasm!==void 0)return wasm;let e;t!==void 0&&(Object.getPrototypeOf(t)===Object.prototype?{module_or_path:t,memory:_,thread_stack_size:e}=t:console.warn("using deprecated parameters for the initialization function; pass a single object instead"));const n=__wbg_get_imports(_),{instance:r,module:o}=await __wbg_load(await t,n);return __wbg_finalize_init(r,o,e)}var tfhe=Object.freeze({__proto__:null,default:__wbg_init,wbg_rayon_start_worker});
";
+  return await __newWorkerFromJsCodeBase64(workerBase64);
+}
+
+/**
+ * Spawn TFHE worker threads, initialize them with the given WASM module
+ * and shared memory, and finalize the thread pool via the builder.
+ * Can be called only once. No reset.
+ * @param {WebAssembly.Module} module - Compiled WASM module to send to each worker.
+ * @param {WebAssembly.Memory} memory - Shared memory instance for cross-thread communication.
+ * @param {{ numThreads(): number, receiver(): SharedArrayBuffer, build(): void }} builder - Thread pool builder from the TFHE WASM bindings.
+ * @throws {Error} If termination is in progress, numThreads is 0, or any worker fails to start.
+ * @returns {Promise<void>}
+ */
+async function startWorkers(module, memory, builder) {
+  if (_started) {
+    throw new Error("Already started");
+  }
+
+  _started = true;
+
+  if (_terminating) {
+    throw new Error("Cannot start workers while termination is in progress");
+  }
+
+  if (builder.numThreads() === 0) {
+    throw new Error(`num_threads must be > 0.`);
+  }
+
+  const workerInit = {
+    type: "wasm_bindgen_worker_init",
+    init: { module_or_path: module, memory },
+    // SharedArrayBuffer
+    receiver: builder.receiver(),
+  };
+
+  const results = await Promise.allSettled(
+    Array.from({ length: builder.numThreads() }, async (_, workerIndex) => {
+      // Self-spawn into a new Worker.
+      //
+      // TODO: while `new URL('...', import.meta.url) becomes a semi-standard
+      // way to get asset URLs relative to the module across various bundlers
+      // and browser, ideally we should switch to `import.meta.resolve`
+      // once it becomes a standard.
+      //
+      // Note: we could use `../../..` as the URL here to inline workerHelpers.js
+      // into the parent entry instead of creating another split point -
+      // this would be preferable from optimization perspective -
+      // however, Webpack then eliminates all message handler code
+      // because wasm-pack produces "sideEffects":false in package.json
+      // unconditionally.
+      //
+      // The only way to work around that is to have side effect code
+      // in an entry point such as Worker file itself.
+
+      let blobUrl = undefined;
+      let worker;
+
+      // Worker creation fallback chain (see matrix in types.ts):
+      //
+      // | workerUrl | Result                                    |
+      // |-----------|-------------------------------------------|
+      // | defined   | Direct URL → fetch+blob → embedded base64 |
+      // | undefined | Embedded base64 worker                    |
+
+      if (_workerUrl) {
+        // Step 1: Try direct URL — new Worker(url)
+        try {
+          worker = await __newIsomorphicWorker(_workerUrl);
+          _logger?.debug(
+            `[Worker #${workerIndex}] - created at url: ${_workerUrl}`,
+          );
+        } catch (e) {
+          _logger?.error(
+            `[Worker #${workerIndex}] - create failed: ${e.message}`,
+            e,
+          );
+        }
+
+        // Step 2: Fetch script and create blob URL — handles cross-origin restrictions
+        if (worker === undefined) {
+          try {
+            const scriptBlob = await fetch(_workerUrl).then((r) => r.blob());
+            blobUrl = URL.createObjectURL(scriptBlob);
+            worker = await __newIsomorphicWorker(blobUrl);
+            _logger?.debug(
+              `[Worker #${workerIndex}] - created fallback blob worker at url: ${_workerUrl}`,
+            );
+          } catch (e) {
+            if (blobUrl) {
+              URL.revokeObjectURL(blobUrl);
+              blobUrl = undefined;
+            }
+
+            _logger?.error(
+              `[Worker #${workerIndex}] - create fallback blob worker failed: ${e.message}`,
+              e,
+            );
+          }
+        }
+      }
+
+      try {
+        // Step 3: Embedded base64 worker — last resort fallback
+        if (!worker) {
+          try {
+            const result = await __createWorkerFromBase64();
+            worker = result.worker;
+            blobUrl = result.blobUrl ?? blobUrl;
+            _logger?.debug(
+              `[Worker #${workerIndex}] - created blob worker using base64`,
+            );
+          } catch (e) {
+            _logger?.error(
+              `[Worker #${workerIndex}] - create blob worker using base64 failed`,
+              e,
+            );
+
+            throw new Error(
+              "All worker creation methods failed. Check CSP, COOP/COEP headers, and cross-origin policies.",
+              { cause: e },
+            );
+          }
+        }
+
+        try {
+          worker.postMessage(workerInit);
+        } catch (e) {
+          _logger?.error(`[Worker #${workerIndex}] - postMessage failed`, e);
+          throw e;
+        }
+
+        await __waitForMsgType(worker, "wasm_bindgen_worker_ready");
+
+        // Revoke blob URL only after the worker has loaded its script
+        if (blobUrl) {
+          URL.revokeObjectURL(blobUrl);
+          blobUrl = undefined;
+        }
+
+        _logger?.debug(`[Worker #${workerIndex}] - ready`);
+
+        return worker;
+      } catch (err) {
+        if (blobUrl) {
+          URL.revokeObjectURL(blobUrl);
+          blobUrl = undefined;
+        }
+
+        throw err;
+      }
+    }),
+  );
+
+  // Separate fulfilled workers from failures
+  const workers = [];
+  const errors = [];
+
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      workers.push(result.value);
+    } else {
+      errors.push(result.reason);
+    }
+  }
+
+  // If any worker failed, terminate the ones that succeeded to prevent orphaned threads
+  if (errors.length > 0) {
+    await Promise.allSettled(workers.map((w) => w.terminate()));
+    throw errors[0];
+  }
+
+  _workers = workers;
+  builder.build();
+}
+
+/**
+ * Terminate all active TFHE workers and wait for cleanup to complete.
+ * Safe to call concurrently — subsequent calls will await the in-progress termination.
+ * Called only once. No reset.
+ * @returns {Promise<unknown>}
+ */
+async function terminateWorkers() {
+  if (_terminating) {
+    return _terminating;
+  }
+
+  if (!_workers) {
+    return;
+  }
+
+  const workers = _workers;
+  _workers = undefined;
+
+  _terminating = Promise.allSettled(workers.map((w) => w.terminate()));
+
+  return _terminating;
+}
+
+export { getTfheWorkers, startWorkers, terminateWorkers, setWorkerUrlConfig };