@luxfhe/wasm 0.2.0 → 0.2.2

package/dist/node/index.cjs

@@ -1,8 +1,14 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,14 +17,159 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/node.ts
 var node_exports = {};
+__export(node_exports, {
+  CompactCiphertextList: () => CompactCiphertextList,
+  CompactCiphertextListBuilder: () => CompactCiphertextListBuilder,
+  CompactPkeCrs: () => CompactPkeCrs,
+  CompactPkePublicParams: () => CompactPkePublicParams,
+  TfheCompactPublicKey: () => TfheCompactPublicKey,
+  ZkComputeLoad: () => ZkComputeLoad,
+  decrypt: () => decrypt,
+  default: () => initTFHE,
+  encrypt: () => encrypt,
+  generateKeys: () => generateKeys,
+  getLuxFHE: () => getLuxFHE,
+  init: () => init,
+  initThreadPool: () => initThreadPool,
+  init_panic_hook: () => init_panic_hook
+});
 module.exports = __toCommonJS(node_exports);
-__reExport(node_exports, require("node-tfhe"), module.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;
+  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) {
+    throw new Error("FHE not initialized. Call init() first.");
+  }
+  return globalThis.luxfhe;
+}
+async function generateKeys() {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.generateKeys();
+}
+async function encrypt(value, publicKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.encrypt(value, publicKey);
+}
+async function decrypt(ciphertext, privateKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.decrypt(ciphertext, privateKey);
+}
+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 = {
-  ...require("node-tfhe")
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
+  decrypt,
+  encrypt,
+  generateKeys,
+  getLuxFHE,
+  init,
+  initThreadPool,
+  init_panic_hook
 });

package/dist/node/index.d.cts

@@ -1 +1,102 @@
-export * from 'node-tfhe';
+/**
+ * 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
+ */
+declare function init(): Promise<void>;
+/**
+ * Get the LuxFHE instance after initialization
+ */
+declare function getLuxFHE(): any;
+interface LuxFHEKeys {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+    evaluationKey: Uint8Array;
+}
+/**
+ * Generate FHE keys
+ */
+declare function generateKeys(): Promise<LuxFHEKeys>;
+/**
+ * Encrypt a value
+ */
+declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decrypt a ciphertext
+ */
+declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
+/**
+ * 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 { 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

@@ -1 +1,102 @@
-export * from 'node-tfhe';
+/**
+ * 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
+ */
+declare function init(): Promise<void>;
+/**
+ * Get the LuxFHE instance after initialization
+ */
+declare function getLuxFHE(): any;
+interface LuxFHEKeys {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+    evaluationKey: Uint8Array;
+}
+/**
+ * Generate FHE keys
+ */
+declare function generateKeys(): Promise<LuxFHEKeys>;
+/**
+ * Encrypt a value
+ */
+declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decrypt a ciphertext
+ */
+declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
+/**
+ * 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 { 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

@@ -1,2 +1,135 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/node.ts
-export * from "node-tfhe";
+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;
+  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) {
+    throw new Error("FHE not initialized. Call init() first.");
+  }
+  return globalThis.luxfhe;
+}
+async function generateKeys() {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.generateKeys();
+}
+async function encrypt(value, publicKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.encrypt(value, publicKey);
+}
+async function decrypt(ciphertext, privateKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.decrypt(ciphertext, privateKey);
+}
+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,
+  initTFHE as default,
+  encrypt,
+  generateKeys,
+  getLuxFHE,
+  init,
+  initThreadPool,
+  init_panic_hook
+};

package/dist/web/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,26 +15,165 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/web.ts
 var web_exports = {};
 __export(web_exports, {
-  default: () => import_tfhe.default
+  CompactCiphertextList: () => CompactCiphertextList,
+  CompactCiphertextListBuilder: () => CompactCiphertextListBuilder,
+  CompactPkeCrs: () => CompactPkeCrs,
+  CompactPkePublicParams: () => CompactPkePublicParams,
+  TfheCompactPublicKey: () => TfheCompactPublicKey,
+  ZkComputeLoad: () => ZkComputeLoad,
+  decrypt: () => decrypt,
+  default: () => initTFHE,
+  encrypt: () => encrypt,
+  generateKeys: () => generateKeys,
+  getLuxFHE: () => getLuxFHE,
+  init: () => init,
+  initThreadPool: () => initThreadPool,
+  init_panic_hook: () => init_panic_hook
 });
 module.exports = __toCommonJS(web_exports);
-__reExport(web_exports, require("tfhe"), module.exports);
-var import_tfhe = __toESM(require("tfhe"), 1);
+var import_meta = {};
+var wasmInstance = null;
+var goInstance = null;
+var initPromise = null;
+async function init(wasmUrl) {
+  if (wasmInstance) return;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    if (typeof Go === "undefined") {
+      await loadScript(new URL("../wasm/wasm_exec.js", import_meta.url).href);
+    }
+    const go = new Go();
+    goInstance = go;
+    const wasmPath = wasmUrl || new URL("../wasm/luxfhe.wasm", import_meta.url).href;
+    const response = await fetch(wasmPath);
+    const wasmBuffer = await response.arrayBuffer();
+    const wasmModule = await WebAssembly.compile(wasmBuffer);
+    wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
+    go.run(wasmInstance);
+  })();
+  return initPromise;
+}
+function loadScript(src) {
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = src;
+    script.onload = () => resolve();
+    script.onerror = reject;
+    document.head.appendChild(script);
+  });
+}
+function getLuxFHE() {
+  if (!wasmInstance) {
+    throw new Error("FHE not initialized. Call init() first.");
+  }
+  return globalThis.luxfhe;
+}
+async function generateKeys() {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.generateKeys();
+}
+async function encrypt(value, publicKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.encrypt(value, publicKey);
+}
+async function decrypt(ciphertext, privateKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.decrypt(ciphertext, privateKey);
+}
+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 = {
-  ...require("tfhe")
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
+  decrypt,
+  encrypt,
+  generateKeys,
+  getLuxFHE,
+  init,
+  initThreadPool,
+  init_panic_hook
 });

package/dist/web/index.d.cts

@@ -1,2 +1,102 @@
-export * from 'tfhe';
-export { default } from 'tfhe';
+/**
+ * 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
+ */
+declare function init(wasmUrl?: string): Promise<void>;
+/**
+ * Get the LuxFHE instance after initialization
+ */
+declare function getLuxFHE(): any;
+interface LuxFHEKeys {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+    evaluationKey: Uint8Array;
+}
+/**
+ * Generate FHE keys
+ */
+declare function generateKeys(): Promise<LuxFHEKeys>;
+/**
+ * Encrypt a value
+ */
+declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decrypt a ciphertext
+ */
+declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
+/**
+ * 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 { 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

@@ -1,2 +1,102 @@
-export * from 'tfhe';
-export { default } from 'tfhe';
+/**
+ * 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
+ */
+declare function init(wasmUrl?: string): Promise<void>;
+/**
+ * Get the LuxFHE instance after initialization
+ */
+declare function getLuxFHE(): any;
+interface LuxFHEKeys {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+    evaluationKey: Uint8Array;
+}
+/**
+ * Generate FHE keys
+ */
+declare function generateKeys(): Promise<LuxFHEKeys>;
+/**
+ * Encrypt a value
+ */
+declare function encrypt(value: number | bigint, publicKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decrypt a ciphertext
+ */
+declare function decrypt(ciphertext: Uint8Array, privateKey: Uint8Array): Promise<bigint>;
+/**
+ * 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 { 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

@@ -1,6 +1,141 @@
 // src/web.ts
-export * from "tfhe";
-import { default as default2 } from "tfhe";
+var wasmInstance = null;
+var goInstance = null;
+var initPromise = null;
+async function init(wasmUrl) {
+  if (wasmInstance) return;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    if (typeof Go === "undefined") {
+      await loadScript(new URL("../wasm/wasm_exec.js", import.meta.url).href);
+    }
+    const go = new Go();
+    goInstance = go;
+    const wasmPath = wasmUrl || new URL("../wasm/luxfhe.wasm", import.meta.url).href;
+    const response = await fetch(wasmPath);
+    const wasmBuffer = await response.arrayBuffer();
+    const wasmModule = await WebAssembly.compile(wasmBuffer);
+    wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
+    go.run(wasmInstance);
+  })();
+  return initPromise;
+}
+function loadScript(src) {
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = src;
+    script.onload = () => resolve();
+    script.onerror = reject;
+    document.head.appendChild(script);
+  });
+}
+function getLuxFHE() {
+  if (!wasmInstance) {
+    throw new Error("FHE not initialized. Call init() first.");
+  }
+  return globalThis.luxfhe;
+}
+async function generateKeys() {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.generateKeys();
+}
+async function encrypt(value, publicKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.encrypt(value, publicKey);
+}
+async function decrypt(ciphertext, privateKey) {
+  await init();
+  const fhe = getLuxFHE();
+  return fhe.decrypt(ciphertext, privateKey);
+}
+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 {
-  default2 as default
+  CompactCiphertextList,
+  CompactCiphertextListBuilder,
+  CompactPkeCrs,
+  CompactPkePublicParams,
+  TfheCompactPublicKey,
+  ZkComputeLoad,
+  decrypt,
+  initTFHE as default,
+  encrypt,
+  generateKeys,
+  getLuxFHE,
+  init,
+  initThreadPool,
+  init_panic_hook
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxfhe/wasm",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "LuxFHE Go WASM bindings for web and node",
   "type": "module",
   "main": "./dist/node/index.js",
@@ -28,7 +28,8 @@
       "types": "./dist/web/index.d.ts",
       "import": "./dist/web/index.js",
       "require": "./dist/web/index.cjs"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist"
@@ -37,10 +38,11 @@
     "build:wasm": "cd ~/work/lux/fhe && GOOS=js GOARCH=wasm go build -o sdk/wasm/luxfhe.wasm ./sdk/wasm/",
     "build:copy": "cp ~/work/lux/fhe/sdk/wasm/luxfhe.wasm wasm/ && cp $(go env GOROOT)/lib/wasm/wasm_exec.js wasm/",
     "build:ts": "tsup",
-    "build": "pnpm build:copy && pnpm build:ts"
+    "build": "npm run build:ts"
   },
   "dependencies": {},
   "devDependencies": {
+    "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   },