@luxfhe/wasm 0.2.1 → 0.2.2

package/dist/node/index.cjs

@@ -30,29 +30,42 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/node.ts
 var node_exports = {};
 __export(node_exports, {
+  CompactCiphertextList: () => CompactCiphertextList,
+  CompactCiphertextListBuilder: () => CompactCiphertextListBuilder,
+  CompactPkeCrs: () => CompactPkeCrs,
+  CompactPkePublicParams: () => CompactPkePublicParams,
+  TfheCompactPublicKey: () => TfheCompactPublicKey,
+  ZkComputeLoad: () => ZkComputeLoad,
   decrypt: () => decrypt,
-  default: () => node_default,
+  default: () => initTFHE,
   encrypt: () => encrypt,
   generateKeys: () => generateKeys,
   getLuxFHE: () => getLuxFHE,
-  init: () => init
+  init: () => init,
+  initThreadPool: () => initThreadPool,
+  init_panic_hook: () => init_panic_hook
 });
 module.exports = __toCommonJS(node_exports);
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
 var wasmInstance = null;
 var goInstance = null;
+var initPromise = null;
 async function init() {
   if (wasmInstance) return;
-  const wasmExecPath = path.join(__dirname, "..", "wasm", "wasm_exec.js");
-  require(wasmExecPath);
-  const go = new Go();
-  goInstance = go;
-  const wasmPath = path.join(__dirname, "..", "wasm", "luxfhe.wasm");
-  const wasmBuffer = fs.readFileSync(wasmPath);
-  const wasmModule = await WebAssembly.compile(wasmBuffer);
-  wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
-  go.run(wasmInstance);
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    const wasmExecPath = path.join(__dirname, "..", "wasm", "wasm_exec.js");
+    require(wasmExecPath);
+    const go = new Go();
+    goInstance = go;
+    const wasmPath = path.join(__dirname, "..", "wasm", "luxfhe.wasm");
+    const wasmBuffer = fs.readFileSync(wasmPath);
+    const wasmModule = await WebAssembly.compile(wasmBuffer);
+    wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
+    go.run(wasmInstance);
+  })();
+  return initPromise;
 }
 function getLuxFHE() {
   if (!wasmInstance) {
@@ -75,18 +88,88 @@ async function decrypt(ciphertext, privateKey) {
   const fhe = getLuxFHE();
   return fhe.decrypt(ciphertext, privateKey);
 }
-var node_default = {
-  init,
-  getLuxFHE,
-  generateKeys,
-  encrypt,
-  decrypt
+function init_panic_hook() {
+}
+async function initThreadPool(numThreads) {
+}
+var TfheCompactPublicKey = class _TfheCompactPublicKey {
+  key;
+  constructor(key) {
+    this.key = key || new Uint8Array();
+  }
+  static deserialize(bytes) {
+    return new _TfheCompactPublicKey(bytes);
+  }
+  serialize() {
+    return this.key;
+  }
+};
+var CompactPkeCrs = class _CompactPkeCrs {
+  static from_config(config, maxBits) {
+    return new _CompactPkeCrs();
+  }
 };
+var CompactPkePublicParams = class _CompactPkePublicParams {
+  static new(crs, maxBits) {
+    return new _CompactPkePublicParams();
+  }
+  static deserialize(bytes) {
+    return new _CompactPkePublicParams();
+  }
+  serialize() {
+    return new Uint8Array();
+  }
+};
+var CompactCiphertextList = class _CompactCiphertextList {
+  data;
+  constructor(data) {
+    this.data = data || new Uint8Array();
+  }
+  static builder(params) {
+    return new CompactCiphertextListBuilder();
+  }
+  static deserialize(bytes) {
+    return new _CompactCiphertextList(bytes);
+  }
+  serialize() {
+    return this.data;
+  }
+};
+var CompactCiphertextListBuilder = class {
+  push(value) {
+    return this;
+  }
+  build() {
+    return new CompactCiphertextList();
+  }
+  build_with_proof_packed(key, load) {
+    return {
+      list: new CompactCiphertextList(),
+      proof: new Uint8Array()
+    };
+  }
+};
+var ZkComputeLoad = /* @__PURE__ */ ((ZkComputeLoad2) => {
+  ZkComputeLoad2["Proof"] = "Proof";
+  ZkComputeLoad2["Verify"] = "Verify";
+  return ZkComputeLoad2;
+})(ZkComputeLoad || {});
+async function initTFHE(options) {
+  await init();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
   decrypt,
   encrypt,
   generateKeys,
   getLuxFHE,
-  init
+  init,
+  initThreadPool,
+  init_panic_hook
 });

package/dist/node/index.d.cts

@@ -2,7 +2,12 @@
  * LuxFHE WASM Node.js bindings
  *
  * Native Go FHE compiled to WebAssembly for Node.js
+ * Includes backward-compatible exports for Zama TFHE interface
  */
+/**
+ * InitInput type for backward compatibility with Zama TFHE
+ */
+type InitInput = string | URL | ArrayBuffer | WebAssembly.Module;
 /**
  * Initialize the FHE WASM module
  */
@@ -28,12 +33,70 @@ declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise
  * Decrypt a ciphertext
  */
 declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
-declare const _default: {
-    init: typeof init;
-    getLuxFHE: typeof getLuxFHE;
-    generateKeys: typeof generateKeys;
-    encrypt: typeof encrypt;
-    decrypt: typeof decrypt;
-};
+/**
+ * Initialize panic hook - stub for Zama compatibility
+ */
+declare function init_panic_hook(): void;
+/**
+ * Initialize thread pool - stub for Zama compatibility
+ */
+declare function initThreadPool(numThreads?: number): Promise<void>;
+/**
+ * TfheCompactPublicKey - stub class for Zama compatibility
+ */
+declare class TfheCompactPublicKey {
+    private key;
+    constructor(key?: Uint8Array);
+    static deserialize(bytes: Uint8Array): TfheCompactPublicKey;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactPkeCrs - stub class for Zama compatibility
+ */
+declare class CompactPkeCrs {
+    static from_config(config: any, maxBits: number): CompactPkeCrs;
+}
+/**
+ * CompactPkePublicParams - stub class for Zama compatibility
+ */
+declare class CompactPkePublicParams {
+    static new(crs: CompactPkeCrs, maxBits: number): CompactPkePublicParams;
+    static deserialize(bytes: Uint8Array): CompactPkePublicParams;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextList - stub class for Zama compatibility
+ */
+declare class CompactCiphertextList {
+    private data;
+    constructor(data?: Uint8Array);
+    static builder(params: CompactPkePublicParams): CompactCiphertextListBuilder;
+    static deserialize(bytes: Uint8Array): CompactCiphertextList;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextListBuilder - stub class for Zama compatibility
+ */
+declare class CompactCiphertextListBuilder {
+    push(value: any): CompactCiphertextListBuilder;
+    build(): CompactCiphertextList;
+    build_with_proof_packed(key: TfheCompactPublicKey, load: ZkComputeLoad): {
+        list: CompactCiphertextList;
+        proof: Uint8Array;
+    };
+}
+/**
+ * ZkComputeLoad enum - stub for Zama compatibility
+ */
+declare enum ZkComputeLoad {
+    Proof = "Proof",
+    Verify = "Verify"
+}
+/**
+ * Default export matching Zama TFHE init signature
+ */
+declare function initTFHE(options?: {
+    module_or_path?: InitInput;
+}): Promise<void>;
 
-export { type LuxFHEKeys, decrypt, _default as default, encrypt, generateKeys, getLuxFHE, init };
+export { CompactCiphertextList, CompactCiphertextListBuilder, CompactPkeCrs, CompactPkePublicParams, type InitInput, type LuxFHEKeys, TfheCompactPublicKey, ZkComputeLoad, decrypt, initTFHE as default, encrypt, generateKeys, getLuxFHE, init, initThreadPool, init_panic_hook };

package/dist/node/index.d.ts

@@ -2,7 +2,12 @@
  * LuxFHE WASM Node.js bindings
  *
  * Native Go FHE compiled to WebAssembly for Node.js
+ * Includes backward-compatible exports for Zama TFHE interface
  */
+/**
+ * InitInput type for backward compatibility with Zama TFHE
+ */
+type InitInput = string | URL | ArrayBuffer | WebAssembly.Module;
 /**
  * Initialize the FHE WASM module
  */
@@ -28,12 +33,70 @@ declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise
  * Decrypt a ciphertext
  */
 declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
-declare const _default: {
-    init: typeof init;
-    getLuxFHE: typeof getLuxFHE;
-    generateKeys: typeof generateKeys;
-    encrypt: typeof encrypt;
-    decrypt: typeof decrypt;
-};
+/**
+ * Initialize panic hook - stub for Zama compatibility
+ */
+declare function init_panic_hook(): void;
+/**
+ * Initialize thread pool - stub for Zama compatibility
+ */
+declare function initThreadPool(numThreads?: number): Promise<void>;
+/**
+ * TfheCompactPublicKey - stub class for Zama compatibility
+ */
+declare class TfheCompactPublicKey {
+    private key;
+    constructor(key?: Uint8Array);
+    static deserialize(bytes: Uint8Array): TfheCompactPublicKey;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactPkeCrs - stub class for Zama compatibility
+ */
+declare class CompactPkeCrs {
+    static from_config(config: any, maxBits: number): CompactPkeCrs;
+}
+/**
+ * CompactPkePublicParams - stub class for Zama compatibility
+ */
+declare class CompactPkePublicParams {
+    static new(crs: CompactPkeCrs, maxBits: number): CompactPkePublicParams;
+    static deserialize(bytes: Uint8Array): CompactPkePublicParams;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextList - stub class for Zama compatibility
+ */
+declare class CompactCiphertextList {
+    private data;
+    constructor(data?: Uint8Array);
+    static builder(params: CompactPkePublicParams): CompactCiphertextListBuilder;
+    static deserialize(bytes: Uint8Array): CompactCiphertextList;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextListBuilder - stub class for Zama compatibility
+ */
+declare class CompactCiphertextListBuilder {
+    push(value: any): CompactCiphertextListBuilder;
+    build(): CompactCiphertextList;
+    build_with_proof_packed(key: TfheCompactPublicKey, load: ZkComputeLoad): {
+        list: CompactCiphertextList;
+        proof: Uint8Array;
+    };
+}
+/**
+ * ZkComputeLoad enum - stub for Zama compatibility
+ */
+declare enum ZkComputeLoad {
+    Proof = "Proof",
+    Verify = "Verify"
+}
+/**
+ * Default export matching Zama TFHE init signature
+ */
+declare function initTFHE(options?: {
+    module_or_path?: InitInput;
+}): Promise<void>;
 
-export { type LuxFHEKeys, decrypt, _default as default, encrypt, generateKeys, getLuxFHE, init };
+export { CompactCiphertextList, CompactCiphertextListBuilder, CompactPkeCrs, CompactPkePublicParams, type InitInput, type LuxFHEKeys, TfheCompactPublicKey, ZkComputeLoad, decrypt, initTFHE as default, encrypt, generateKeys, getLuxFHE, init, initThreadPool, init_panic_hook };

package/dist/node/index.js

@@ -10,17 +10,22 @@ import * as fs from "fs";
 import * as path from "path";
 var wasmInstance = null;
 var goInstance = null;
+var initPromise = null;
 async function init() {
   if (wasmInstance) return;
-  const wasmExecPath = path.join(__dirname, "..", "wasm", "wasm_exec.js");
-  __require(wasmExecPath);
-  const go = new Go();
-  goInstance = go;
-  const wasmPath = path.join(__dirname, "..", "wasm", "luxfhe.wasm");
-  const wasmBuffer = fs.readFileSync(wasmPath);
-  const wasmModule = await WebAssembly.compile(wasmBuffer);
-  wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
-  go.run(wasmInstance);
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    const wasmExecPath = path.join(__dirname, "..", "wasm", "wasm_exec.js");
+    __require(wasmExecPath);
+    const go = new Go();
+    goInstance = go;
+    const wasmPath = path.join(__dirname, "..", "wasm", "luxfhe.wasm");
+    const wasmBuffer = fs.readFileSync(wasmPath);
+    const wasmModule = await WebAssembly.compile(wasmBuffer);
+    wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
+    go.run(wasmInstance);
+  })();
+  return initPromise;
 }
 function getLuxFHE() {
   if (!wasmInstance) {
@@ -43,18 +48,88 @@ async function decrypt(ciphertext, privateKey) {
   const fhe = getLuxFHE();
   return fhe.decrypt(ciphertext, privateKey);
 }
-var node_default = {
-  init,
-  getLuxFHE,
-  generateKeys,
-  encrypt,
-  decrypt
+function init_panic_hook() {
+}
+async function initThreadPool(numThreads) {
+}
+var TfheCompactPublicKey = class _TfheCompactPublicKey {
+  key;
+  constructor(key) {
+    this.key = key || new Uint8Array();
+  }
+  static deserialize(bytes) {
+    return new _TfheCompactPublicKey(bytes);
+  }
+  serialize() {
+    return this.key;
+  }
+};
+var CompactPkeCrs = class _CompactPkeCrs {
+  static from_config(config, maxBits) {
+    return new _CompactPkeCrs();
+  }
 };
+var CompactPkePublicParams = class _CompactPkePublicParams {
+  static new(crs, maxBits) {
+    return new _CompactPkePublicParams();
+  }
+  static deserialize(bytes) {
+    return new _CompactPkePublicParams();
+  }
+  serialize() {
+    return new Uint8Array();
+  }
+};
+var CompactCiphertextList = class _CompactCiphertextList {
+  data;
+  constructor(data) {
+    this.data = data || new Uint8Array();
+  }
+  static builder(params) {
+    return new CompactCiphertextListBuilder();
+  }
+  static deserialize(bytes) {
+    return new _CompactCiphertextList(bytes);
+  }
+  serialize() {
+    return this.data;
+  }
+};
+var CompactCiphertextListBuilder = class {
+  push(value) {
+    return this;
+  }
+  build() {
+    return new CompactCiphertextList();
+  }
+  build_with_proof_packed(key, load) {
+    return {
+      list: new CompactCiphertextList(),
+      proof: new Uint8Array()
+    };
+  }
+};
+var ZkComputeLoad = /* @__PURE__ */ ((ZkComputeLoad2) => {
+  ZkComputeLoad2["Proof"] = "Proof";
+  ZkComputeLoad2["Verify"] = "Verify";
+  return ZkComputeLoad2;
+})(ZkComputeLoad || {});
+async function initTFHE(options) {
+  await init();
+}
 export {
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
   decrypt,
-  node_default as default,
+  initTFHE as default,
   encrypt,
   generateKeys,
   getLuxFHE,
-  init
+  init,
+  initThreadPool,
+  init_panic_hook
 };

package/dist/web/index.cjs

@@ -20,12 +20,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/web.ts
 var web_exports = {};
 __export(web_exports, {
+  CompactCiphertextList: () => CompactCiphertextList,
+  CompactCiphertextListBuilder: () => CompactCiphertextListBuilder,
+  CompactPkeCrs: () => CompactPkeCrs,
+  CompactPkePublicParams: () => CompactPkePublicParams,
+  TfheCompactPublicKey: () => TfheCompactPublicKey,
+  ZkComputeLoad: () => ZkComputeLoad,
   decrypt: () => decrypt,
-  default: () => web_default,
+  default: () => initTFHE,
   encrypt: () => encrypt,
   generateKeys: () => generateKeys,
   getLuxFHE: () => getLuxFHE,
-  init: () => init
+  init: () => init,
+  initThreadPool: () => initThreadPool,
+  init_panic_hook: () => init_panic_hook
 });
 module.exports = __toCommonJS(web_exports);
 var import_meta = {};
@@ -80,18 +88,92 @@ async function decrypt(ciphertext, privateKey) {
   const fhe = getLuxFHE();
   return fhe.decrypt(ciphertext, privateKey);
 }
-var web_default = {
-  init,
-  getLuxFHE,
-  generateKeys,
-  encrypt,
-  decrypt
+function init_panic_hook() {
+}
+async function initThreadPool(numThreads) {
+}
+var TfheCompactPublicKey = class _TfheCompactPublicKey {
+  key;
+  constructor(key) {
+    this.key = key || new Uint8Array();
+  }
+  static deserialize(bytes) {
+    return new _TfheCompactPublicKey(bytes);
+  }
+  serialize() {
+    return this.key;
+  }
+};
+var CompactPkeCrs = class _CompactPkeCrs {
+  static from_config(config, maxBits) {
+    return new _CompactPkeCrs();
+  }
 };
+var CompactPkePublicParams = class _CompactPkePublicParams {
+  static new(crs, maxBits) {
+    return new _CompactPkePublicParams();
+  }
+  static deserialize(bytes) {
+    return new _CompactPkePublicParams();
+  }
+  serialize() {
+    return new Uint8Array();
+  }
+};
+var CompactCiphertextList = class _CompactCiphertextList {
+  data;
+  constructor(data) {
+    this.data = data || new Uint8Array();
+  }
+  static builder(params) {
+    return new CompactCiphertextListBuilder();
+  }
+  static deserialize(bytes) {
+    return new _CompactCiphertextList(bytes);
+  }
+  serialize() {
+    return this.data;
+  }
+};
+var CompactCiphertextListBuilder = class {
+  push(value) {
+    return this;
+  }
+  build() {
+    return new CompactCiphertextList();
+  }
+  build_with_proof_packed(key, load) {
+    return {
+      list: new CompactCiphertextList(),
+      proof: new Uint8Array()
+    };
+  }
+};
+var ZkComputeLoad = /* @__PURE__ */ ((ZkComputeLoad2) => {
+  ZkComputeLoad2["Proof"] = "Proof";
+  ZkComputeLoad2["Verify"] = "Verify";
+  return ZkComputeLoad2;
+})(ZkComputeLoad || {});
+async function initTFHE(options) {
+  if (options?.module_or_path && typeof options.module_or_path === "string") {
+    await init(options.module_or_path);
+  } else {
+    await init();
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
   decrypt,
   encrypt,
   generateKeys,
   getLuxFHE,
-  init
+  init,
+  initThreadPool,
+  init_panic_hook
 });

package/dist/web/index.d.cts

@@ -2,7 +2,12 @@
  * LuxFHE WASM Web bindings
  *
  * Native Go FHE compiled to WebAssembly for browser
+ * Includes backward-compatible exports for Zama TFHE interface
  */
+/**
+ * InitInput type for backward compatibility with Zama TFHE
+ */
+type InitInput = string | URL | Request | Response | ArrayBuffer | WebAssembly.Module;
 /**
  * Initialize the FHE WASM module
  */
@@ -28,12 +33,70 @@ declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise
  * Decrypt a ciphertext
  */
 declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
-declare const _default: {
-    init: typeof init;
-    getLuxFHE: typeof getLuxFHE;
-    generateKeys: typeof generateKeys;
-    encrypt: typeof encrypt;
-    decrypt: typeof decrypt;
-};
+/**
+ * Initialize panic hook - stub for Zama compatibility
+ */
+declare function init_panic_hook(): void;
+/**
+ * Initialize thread pool - stub for Zama compatibility
+ */
+declare function initThreadPool(numThreads?: number): Promise<void>;
+/**
+ * TfheCompactPublicKey - stub class for Zama compatibility
+ */
+declare class TfheCompactPublicKey {
+    private key;
+    constructor(key?: Uint8Array);
+    static deserialize(bytes: Uint8Array): TfheCompactPublicKey;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactPkeCrs - stub class for Zama compatibility
+ */
+declare class CompactPkeCrs {
+    static from_config(config: any, maxBits: number): CompactPkeCrs;
+}
+/**
+ * CompactPkePublicParams - stub class for Zama compatibility
+ */
+declare class CompactPkePublicParams {
+    static new(crs: CompactPkeCrs, maxBits: number): CompactPkePublicParams;
+    static deserialize(bytes: Uint8Array): CompactPkePublicParams;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextList - stub class for Zama compatibility
+ */
+declare class CompactCiphertextList {
+    private data;
+    constructor(data?: Uint8Array);
+    static builder(params: CompactPkePublicParams): CompactCiphertextListBuilder;
+    static deserialize(bytes: Uint8Array): CompactCiphertextList;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextListBuilder - stub class for Zama compatibility
+ */
+declare class CompactCiphertextListBuilder {
+    push(value: any): CompactCiphertextListBuilder;
+    build(): CompactCiphertextList;
+    build_with_proof_packed(key: TfheCompactPublicKey, load: ZkComputeLoad): {
+        list: CompactCiphertextList;
+        proof: Uint8Array;
+    };
+}
+/**
+ * ZkComputeLoad enum - stub for Zama compatibility
+ */
+declare enum ZkComputeLoad {
+    Proof = "Proof",
+    Verify = "Verify"
+}
+/**
+ * Default export matching Zama TFHE init signature
+ */
+declare function initTFHE(options?: {
+    module_or_path?: InitInput;
+}): Promise<void>;
 
-export { type LuxFHEKeys, decrypt, _default as default, encrypt, generateKeys, getLuxFHE, init };
+export { CompactCiphertextList, CompactCiphertextListBuilder, CompactPkeCrs, CompactPkePublicParams, type InitInput, type LuxFHEKeys, TfheCompactPublicKey, ZkComputeLoad, decrypt, initTFHE as default, encrypt, generateKeys, getLuxFHE, init, initThreadPool, init_panic_hook };

package/dist/web/index.d.ts

@@ -2,7 +2,12 @@
  * LuxFHE WASM Web bindings
  *
  * Native Go FHE compiled to WebAssembly for browser
+ * Includes backward-compatible exports for Zama TFHE interface
  */
+/**
+ * InitInput type for backward compatibility with Zama TFHE
+ */
+type InitInput = string | URL | Request | Response | ArrayBuffer | WebAssembly.Module;
 /**
  * Initialize the FHE WASM module
  */
@@ -28,12 +33,70 @@ declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise
  * Decrypt a ciphertext
  */
 declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
-declare const _default: {
-    init: typeof init;
-    getLuxFHE: typeof getLuxFHE;
-    generateKeys: typeof generateKeys;
-    encrypt: typeof encrypt;
-    decrypt: typeof decrypt;
-};
+/**
+ * Initialize panic hook - stub for Zama compatibility
+ */
+declare function init_panic_hook(): void;
+/**
+ * Initialize thread pool - stub for Zama compatibility
+ */
+declare function initThreadPool(numThreads?: number): Promise<void>;
+/**
+ * TfheCompactPublicKey - stub class for Zama compatibility
+ */
+declare class TfheCompactPublicKey {
+    private key;
+    constructor(key?: Uint8Array);
+    static deserialize(bytes: Uint8Array): TfheCompactPublicKey;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactPkeCrs - stub class for Zama compatibility
+ */
+declare class CompactPkeCrs {
+    static from_config(config: any, maxBits: number): CompactPkeCrs;
+}
+/**
+ * CompactPkePublicParams - stub class for Zama compatibility
+ */
+declare class CompactPkePublicParams {
+    static new(crs: CompactPkeCrs, maxBits: number): CompactPkePublicParams;
+    static deserialize(bytes: Uint8Array): CompactPkePublicParams;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextList - stub class for Zama compatibility
+ */
+declare class CompactCiphertextList {
+    private data;
+    constructor(data?: Uint8Array);
+    static builder(params: CompactPkePublicParams): CompactCiphertextListBuilder;
+    static deserialize(bytes: Uint8Array): CompactCiphertextList;
+    serialize(): Uint8Array;
+}
+/**
+ * CompactCiphertextListBuilder - stub class for Zama compatibility
+ */
+declare class CompactCiphertextListBuilder {
+    push(value: any): CompactCiphertextListBuilder;
+    build(): CompactCiphertextList;
+    build_with_proof_packed(key: TfheCompactPublicKey, load: ZkComputeLoad): {
+        list: CompactCiphertextList;
+        proof: Uint8Array;
+    };
+}
+/**
+ * ZkComputeLoad enum - stub for Zama compatibility
+ */
+declare enum ZkComputeLoad {
+    Proof = "Proof",
+    Verify = "Verify"
+}
+/**
+ * Default export matching Zama TFHE init signature
+ */
+declare function initTFHE(options?: {
+    module_or_path?: InitInput;
+}): Promise<void>;
 
-export { type LuxFHEKeys, decrypt, _default as default, encrypt, generateKeys, getLuxFHE, init };
+export { CompactCiphertextList, CompactCiphertextListBuilder, CompactPkeCrs, CompactPkePublicParams, type InitInput, type LuxFHEKeys, TfheCompactPublicKey, ZkComputeLoad, decrypt, initTFHE as default, encrypt, generateKeys, getLuxFHE, init, initThreadPool, init_panic_hook };

package/dist/web/index.js

@@ -50,18 +50,92 @@ async function decrypt(ciphertext, privateKey) {
   const fhe = getLuxFHE();
   return fhe.decrypt(ciphertext, privateKey);
 }
-var web_default = {
-  init,
-  getLuxFHE,
-  generateKeys,
-  encrypt,
-  decrypt
+function init_panic_hook() {
+}
+async function initThreadPool(numThreads) {
+}
+var TfheCompactPublicKey = class _TfheCompactPublicKey {
+  key;
+  constructor(key) {
+    this.key = key || new Uint8Array();
+  }
+  static deserialize(bytes) {
+    return new _TfheCompactPublicKey(bytes);
+  }
+  serialize() {
+    return this.key;
+  }
+};
+var CompactPkeCrs = class _CompactPkeCrs {
+  static from_config(config, maxBits) {
+    return new _CompactPkeCrs();
+  }
 };
+var CompactPkePublicParams = class _CompactPkePublicParams {
+  static new(crs, maxBits) {
+    return new _CompactPkePublicParams();
+  }
+  static deserialize(bytes) {
+    return new _CompactPkePublicParams();
+  }
+  serialize() {
+    return new Uint8Array();
+  }
+};
+var CompactCiphertextList = class _CompactCiphertextList {
+  data;
+  constructor(data) {
+    this.data = data || new Uint8Array();
+  }
+  static builder(params) {
+    return new CompactCiphertextListBuilder();
+  }
+  static deserialize(bytes) {
+    return new _CompactCiphertextList(bytes);
+  }
+  serialize() {
+    return this.data;
+  }
+};
+var CompactCiphertextListBuilder = class {
+  push(value) {
+    return this;
+  }
+  build() {
+    return new CompactCiphertextList();
+  }
+  build_with_proof_packed(key, load) {
+    return {
+      list: new CompactCiphertextList(),
+      proof: new Uint8Array()
+    };
+  }
+};
+var ZkComputeLoad = /* @__PURE__ */ ((ZkComputeLoad2) => {
+  ZkComputeLoad2["Proof"] = "Proof";
+  ZkComputeLoad2["Verify"] = "Verify";
+  return ZkComputeLoad2;
+})(ZkComputeLoad || {});
+async function initTFHE(options) {
+  if (options?.module_or_path && typeof options.module_or_path === "string") {
+    await init(options.module_or_path);
+  } else {
+    await init();
+  }
+}
 export {
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
   decrypt,
-  web_default as default,
+  initTFHE as default,
   encrypt,
   generateKeys,
   getLuxFHE,
-  init
+  init,
+  initThreadPool,
+  init_panic_hook
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxfhe/wasm",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "LuxFHE Go WASM bindings for web and node",
   "type": "module",
   "main": "./dist/node/index.js",