facebetter 2.0.0 → 2.0.1

package/dist/facebetter.esm.js

@@ -5,58 +5,33 @@
 
 /**
  * Engine configuration class
- * Analogous to EngineConfig in C++ / Java / Objective-C, with Web-only auth fields.
+ * Analogous to EngineConfig in C++ / Java / Objective-C. Web only accepts licenseToken.
  */
 class EngineConfig {
   /**
    * @param {Object} config
-   * @param {string} [config.licenseToken] Compact JWS, or the raw `{success, token}`
+   * @param {string} config.licenseToken Compact JWS, or the raw `{success, token}`
    *   HTTP response body from your auth server.
-   * @param {string} [config.authProxyUrl] Production: forward the WASM auth
-   *   challenge to your server, which holds app_id/app_key and calls Cloudflare.
-   * @param {Function} [config.fetchAuthResponse] Custom auth hook with signature
-   *   `async (challenge) => string|object`. For local debugging you can use
-   *   `createDirectAuthFetcher` to hit Cloudflare directly — never ship keys in
-   *   a production frontend bundle.
    * @param {boolean} [config.externalContext] Kept for cross-platform alignment;
-   *   unused on Web/WASM today.
+   *   unused on Web today.
    */
   constructor(config = {}) {
     this.licenseToken = config.licenseToken || null;
-    this.authProxyUrl = config.authProxyUrl || null;
-    this.fetchAuthResponse = config.fetchAuthResponse || null;
     this.resourcePath = '/resource.fbd';
     /**
      * Whether to use an external GL context (native platforms only).
-     * On Web/WASM this field is kept for config-shape alignment and has no effect.
+     * On Web this field is kept for config-shape alignment and has no effect.
      */
     this.externalContext = !!config.externalContext;
   }
 
   isValid() {
-    if (this.licenseToken && typeof this.licenseToken === 'string' &&
-        this.licenseToken.trim() !== '') {
-      return true;
-    }
-    if (typeof this.fetchAuthResponse === 'function') {
-      return true;
-    }
-    if (this.authProxyUrl && typeof this.authProxyUrl === 'string' &&
-        this.authProxyUrl.trim() !== '') {
-      return true;
-    }
-    return false;
+    return typeof this.licenseToken === 'string' &&
+           this.licenseToken.trim() !== '';
   }
 
   toString() {
-    const mode = this.licenseToken
-      ? 'licenseToken'
-      : this.fetchAuthResponse
-        ? 'fetchAuthResponse'
-        : this.authProxyUrl
-          ? 'authProxyUrl'
-          : 'invalid';
-    return `EngineConfig{mode='${mode}'}`;
+    return `EngineConfig{mode='${this.isValid() ? 'licenseToken' : 'invalid'}'}`;
   }
 }
 
@@ -306,40 +281,6 @@ var constants = /*#__PURE__*/Object.freeze({
   WhiteningStyle: WhiteningStyle$1
 });
 
-/**
- * Browser-side console lines aligned with C++ Logger (src/base/logging.cc) Release pattern:
- * [%Y-%m-%d %H:%M:%S.%e] [facebetter] [%l] [%t] - %v
- * spdlog level names: info, warning, error (see spdlog SPDLOG_LEVEL_NAMES).
- */
-
-function pad2(n) {
-  return String(n).padStart(2, '0');
-}
-
-/**
- * @param {'info'|'warning'|'error'} levelTag — must match spdlog long level strings
- * @param {string} message
- * @returns {string}
- */
-function formatLogLine(levelTag, message) {
-  const d = new Date();
-  const ms = String(d.getMilliseconds()).padStart(3, '0');
-  const ts = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${pad2(
-    d.getHours()
-  )}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}.${ms}`;
-  return `[${ts}] [facebetter] [${levelTag}] [0] - ${message}`;
-}
-
-/** @param {string} message */
-function logInfo(message) {
-  console.info(formatLogLine('info', message));
-}
-
-/** @param {string} message */
-function logWarn(message) {
-  console.warn(formatLogLine('warning', message));
-}
-
 /**
  * Beauty Effect Engine Core
  * Platform-agnostic engine implementation with dependency injection
@@ -404,8 +345,6 @@ class BeautyEffectEngine {
 
     this.config = engineConfig;
     this.licenseToken = engineConfig.licenseToken;
-    this.authProxyUrl = engineConfig.authProxyUrl;
-    this.fetchAuthResponse = engineConfig.fetchAuthResponse;
     this.resourcePath = '/resource.fbd';
     this.enginePtr = null;
     this.initialized = false;
@@ -425,7 +364,8 @@ class BeautyEffectEngine {
     this._toImageData = platformAPI.toImageData;
     this._ensureFacebetterCanvas = platformAPI.ensureFacebetterCanvas;
     this._cleanupFacebetterCanvas = platformAPI.cleanupFacebetterCanvas;
-    
+    this._pendingLogConfig = null;
+
     // Browser-specific state
     this._facebetterCanvas = null;
     this._createdFacebetterCanvas = false;
@@ -436,9 +376,8 @@ class BeautyEffectEngine {
     if (this._ensureFacebetterCanvas) {
       this._ensureFacebetterCanvas();
     }
-    
-    // Start loading WASM module immediately in constructor
-    this._wasmLoadPromise = this._loadWasmModule();
+
+    this._wasmLoadPromise = null;
     this._initPromise = null;
   }
 
@@ -495,8 +434,12 @@ class BeautyEffectEngine {
   /**
    * Initializes the engine
    * @param {Object} [options] - Initialization options
-   * @param {number} [options.timeout] - Timeout in milliseconds (default: 30000 for WASM, 10000 for auth)
-   * @param {number} [options.authTimeout] - Timeout for online authentication in milliseconds (default: 10000)
+   * @param {number} [options.timeout] - Timeout in milliseconds (default: 120000)
+   * @param {number} [options.authTimeout] - Unused. Kept for compatibility.
+   * @param {function} [options.onProgress] - Download progress:
+   *   `{ loaded, total, percent }` while fetching the runtime files.
+   * @param {string} [options.assetBaseUrl] - Directory that contains
+   *   `facebetter-core.wasm` and `resource.fbd`. Optional when using npm.
    * @returns {Promise<void>} Promise that resolves when initialization is complete
    */
   async init(options = {}) {
@@ -513,9 +456,18 @@ class BeautyEffectEngine {
     // Create initialization Promise
     this._initPromise = (async () => {
       try {
-        const wasmTimeout = options.timeout || 30000;
+        const wasmTimeout = options.timeout || 120000;
+
+        if (!this._wasmLoadPromise) {
+          this._wasmLoadPromise = this._loadWasmModule({
+            onProgress: options.onProgress,
+            assetBaseUrl: options.assetBaseUrl,
+            wasmUrl: options.wasmUrl,
+            wasmAssetUrl: options.wasmAssetUrl,
+            resourceAssetUrl: options.resourceAssetUrl,
+          });
+        }
 
-        // Wait for WASM module loading (with timeout)
         try {
           await Promise.race([
             this._wasmLoadPromise,
@@ -525,6 +477,11 @@ class BeautyEffectEngine {
           throw this._enhanceError(error, 'Failed to load WASM module');
         }
 
+        if (this._pendingLogConfig) {
+          await this._applyLogConfig(this._pendingLogConfig);
+          this._pendingLogConfig = null;
+        }
+
         const Module = this._getWasmModule();
 
         // Setup usage report proxy for WASM
@@ -550,66 +507,12 @@ class BeautyEffectEngine {
           };
         }
 
-        // Web v2 auth: never accept appId/appKey in the browser.
-        // - licenseToken: pre-fetched JWS or `{success, token}` body
-        // - authProxyUrl: production — forward the challenge to your server
-        // - fetchAuthResponse: custom hook; locally use createDirectAuthFetcher
+        // Web: fetch the token outside the engine, then pass licenseToken.
         if (!this.licenseToken) {
-          if (typeof this.fetchAuthResponse === 'function') {
-            Module.onOnlineAuth = async (payloadJson) => {
-              try {
-                const challenge = JSON.parse(payloadJson);
-                const result = await this.fetchAuthResponse(challenge);
-                if (result && typeof result === 'object' && typeof result.response === 'string') {
-                  return { response: result.response };
-                }
-                if (typeof result === 'string') {
-                  return result;
-                }
-                if (result && typeof result === 'object') {
-                  return JSON.stringify(result);
-                }
-                return '';
-              } catch (err) {
-                logWarn(
-                  `Online license: fetchAuthResponse error${err?.message ? `: ${err.message}` : ''}`
-                );
-                return JSON.stringify({
-                  success: false,
-                  error: 'auth_fetch_failed',
-                  message: err?.message || 'auth fetch failed',
-                });
-              }
-            };
-          } else if (this.authProxyUrl) {
-            Module.onOnlineAuth = async (payloadJson) => {
-              logInfo('Online license: proxying auth challenge');
-              try {
-                const response = await fetch(this.authProxyUrl, {
-                  method: 'POST',
-                  headers: { 'Content-Type': 'application/json' },
-                  body: payloadJson,
-                });
-                if (!response.ok) {
-                  logWarn(`Online license: proxy HTTP ${response.status}`);
-                  return '';
-                }
-                const text = await response.text();
-                logInfo('Online license: proxy response ok');
-                return text;
-              } catch (err) {
-                logWarn(
-                  `Online license: proxy error${err?.message ? `: ${err.message}` : ''}`
-                );
-                return '';
-              }
-            };
-          } else {
-            throw new FacebetterError(
-              'Web auth requires licenseToken, authProxyUrl, or fetchAuthResponse.',
-              'LICENSE_ERROR'
-            );
-          }
+          throw new FacebetterError(
+            'Web auth requires licenseToken. Fetch it from your server before init().',
+            'LICENSE_ERROR'
+          );
         }
 
         // C ABI still has app_id/app_key slots; leave them empty on Web.
@@ -653,7 +556,8 @@ class BeautyEffectEngine {
         this.initialized = true;
         this._initPromise = null; // Clear Promise cache, allow re-initialization (if needed)
       } catch (error) {
-        this._initPromise = null; // Clear Promise cache, allow retry
+        this._initPromise = null;
+        this._wasmLoadPromise = null;
         throw error;
       }
     })();
@@ -710,8 +614,9 @@ class BeautyEffectEngine {
   }
 
   /**
-   * Sets log configuration
-   * Can be called before init() since fb_set_log_config is a global function
+   * Sets log configuration.
+   * If called before `init()`, the values are applied after the runtime downloads
+   * and before the engine is created.
    * @param {Object} config - Log configuration
    * @param {boolean} config.consoleEnabled - Enable console logging
    * @param {boolean} config.fileEnabled - Enable file logging
@@ -720,8 +625,15 @@ class BeautyEffectEngine {
    * @returns {Promise<void>} Promise that resolves when log config is set
    */
   async setLogConfig(config) {
-    // Wait for WASM module to be loaded (started in constructor)
+    if (!this._wasmLoadPromise) {
+      this._pendingLogConfig = config;
+      return;
+    }
     await this._wasmLoadPromise;
+    await this._applyLogConfig(config);
+  }
+
+  async _applyLogConfig(config) {
     const Module = this._getWasmModule();
 
     const fileNamePtr = allocUtf8(Module, config.fileName);
@@ -1626,100 +1538,204 @@ class BeautyEffectEngine {
 
 }
 
-/** Cloudflare v2 online auth URL. Proxy through your server in production; never ship keys in the frontend bundle. */
-const FACEBETTER_AUTH_URL =
-  'https://facebetter.pixpark.net/facebetter/v2/auth';
+const WASM_FILE = 'facebetter-core.wasm';
+const RESOURCE_FILE = 'resource.fbd';
+const MEMFS_RESOURCE_PATH = '/resource.fbd';
 
-function toHex(buffer) {
-  return Array.from(new Uint8Array(buffer), (b) =>
-    b.toString(16).padStart(2, '0')
-  ).join('');
+function emitProgress(onProgress, loaded, total) {
+  if (typeof onProgress !== 'function') {
+    return;
+  }
+  const safeTotal = total > 0 ? total : loaded;
+  const percent =
+    safeTotal > 0 ? Math.min(100, Math.round((loaded / safeTotal) * 100)) : 0;
+  onProgress({ loaded, total: safeTotal, percent });
 }
 
-async function hmacSha256Hex(key, message) {
-  const encoder = new TextEncoder();
-  const cryptoKey = await crypto.subtle.importKey(
-    'raw',
-    encoder.encode(key),
-    { name: 'HMAC', hash: 'SHA-256' },
-    false,
-    ['sign']
-  );
-  const signature = await crypto.subtle.sign(
-    'HMAC',
-    cryptoKey,
-    encoder.encode(message)
-  );
-  return toHex(signature);
+async function readFileUrl(url, onChunk) {
+  const { readFile } = await import('node:fs/promises');
+  const { fileURLToPath } = await import('node:url');
+  const buf = await readFile(fileURLToPath(url));
+  const bytes = new Uint8Array(buf);
+  onChunk(bytes.byteLength, bytes.byteLength);
+  return bytes;
 }
 
 /**
- * Call Cloudflare v2/auth directly with app_id / app_key.
- * Intended for local debugging, or environments where key leakage is not a risk.
- *
- * @param {Object} options
- * @param {string} options.appId
- * @param {string} options.appKey
- * @param {Object} options.challenge WASM challenge `{nonce, timestamp, platform, user_agent}`
- * @param {string} [options.authUrl]
- * @returns {Promise<string>} Raw HTTP body (`{success, token}` or an error envelope)
+ * Fetch a binary with byte-level download progress.
+ * @param {string} url
+ * @param {function(number, number): void} onChunk loaded, total (0 if unknown)
+ * @returns {Promise<Uint8Array>}
  */
-async function requestFacebetterAuth({
-  appId,
-  appKey,
-  challenge,
-  authUrl = FACEBETTER_AUTH_URL,
-}) {
-  const id = typeof appId === 'string' ? appId.trim() : '';
-  const key = typeof appKey === 'string' ? appKey.trim() : '';
-  if (!id || !key) {
-    throw new FacebetterError(
-      'requestFacebetterAuth requires appId and appKey',
-      'LICENSE_ERROR'
-    );
+async function fetchBinary(url, onChunk) {
+  if (typeof url === 'string' && url.startsWith('file:')) {
+    return readFileUrl(url, onChunk);
   }
-  if (!challenge || typeof challenge !== 'object') {
+
+  const response = await fetch(url);
+  if (!response.ok) {
     throw new FacebetterError(
-      'requestFacebetterAuth requires a WASM auth challenge',
-      'LICENSE_ERROR'
+      `Failed to download ${url} (${response.status})`,
+      'WASM_LOAD_ERROR'
     );
   }
 
-  const nonce = String(challenge.nonce || '');
-  const timestamp = Number(challenge.timestamp);
-  const platform = String(challenge.platform || 'web');
-  const userAgent = String(challenge.user_agent || '');
-  const payload = `v2|${id}|${timestamp}|${nonce}|${platform}`;
-  const hmac = await hmacSha256Hex(key, payload);
-
-  const response = await fetch(authUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      app_id: id,
-      hmac_signature: hmac,
-      timestamp,
-      nonce,
-      platform,
-      user_agent: userAgent,
+  const totalHeader = Number(response.headers.get('content-length'));
+  const total = Number.isFinite(totalHeader) && totalHeader > 0 ? totalHeader : 0;
+
+  if (!response.body || typeof response.body.getReader !== 'function') {
+    const buffer = await response.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    onChunk(bytes.byteLength, total || bytes.byteLength);
+    return bytes;
+  }
+
+  const reader = response.body.getReader();
+  const chunks = [];
+  let loaded = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    chunks.push(value);
+    loaded += value.byteLength;
+    onChunk(loaded, total);
+  }
+
+  const bytes = new Uint8Array(loaded);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  onChunk(loaded, total || loaded);
+  return bytes;
+}
+
+async function fetchRuntimeAssets({ wasmUrl, resourceUrl, onProgress }) {
+  let wasmLoaded = 0;
+  let wasmTotal = 0;
+  let resourceLoaded = 0;
+  let resourceTotal = 0;
+
+  const emit = () => {
+    emitProgress(
+      onProgress,
+      wasmLoaded + resourceLoaded,
+      wasmTotal + resourceTotal
+    );
+  };
+
+  const [wasmBytes, resourceBytes] = await Promise.all([
+    fetchBinary(wasmUrl, (loaded, total) => {
+      wasmLoaded = loaded;
+      wasmTotal = total || loaded;
+      emit();
     }),
-  });
-  return response.text();
+    fetchBinary(resourceUrl, (loaded, total) => {
+      resourceLoaded = loaded;
+      resourceTotal = total || loaded;
+      emit();
+    }),
+  ]);
+
+  emitProgress(
+    onProgress,
+    wasmBytes.byteLength + resourceBytes.byteLength,
+    wasmBytes.byteLength + resourceBytes.byteLength
+  );
+  return { wasmBytes, resourceBytes };
+}
+
+function scriptDirectory() {
+  if (typeof document === 'undefined') {
+    return '';
+  }
+  if (document.currentScript?.src) {
+    return document.currentScript.src.slice(
+      0,
+      document.currentScript.src.lastIndexOf('/') + 1
+    );
+  }
+  const scripts = document.getElementsByTagName('script');
+  for (let i = scripts.length - 1; i >= 0; i--) {
+    const src = scripts[i].src;
+    if (src && (src.includes('facebetter.js') || src.includes('facebetter'))) {
+      return src.slice(0, src.lastIndexOf('/') + 1);
+    }
+  }
+  if (typeof location !== 'undefined') {
+    return new URL('.', location.href).href;
+  }
+  return './';
 }
 
 /**
- * Build an `EngineConfig.fetchAuthResponse` that talks to Cloudflare directly
- * (no customer proxy).
- *
- * @param {Object} options
- * @param {string} options.appId
- * @param {string} options.appKey
- * @param {string} [options.authUrl]
- * @returns {(challenge: Object) => Promise<string>}
+ * Resolve sidecar wasm / resource URLs.
+ * Prefer `assetBaseUrl`, then `facebetter-core/assets`, then the script directory.
  */
-function createDirectAuthFetcher({ appId, appKey, authUrl } = {}) {
-  return (challenge) =>
-    requestFacebetterAuth({ appId, appKey, challenge, authUrl });
+async function resolveRuntimeAssetUrls(options = {}) {
+  const joinBase = (base) => {
+    const prefix = base.endsWith('/') ? base : `${base}/`;
+    return {
+      wasmUrl: options.wasmAssetUrl || `${prefix}${WASM_FILE}`,
+      resourceUrl: options.resourceAssetUrl || `${prefix}${RESOURCE_FILE}`,
+    };
+  };
+
+  if (options.wasmAssetUrl && options.resourceAssetUrl) {
+    return {
+      wasmUrl: options.wasmAssetUrl,
+      resourceUrl: options.resourceAssetUrl,
+    };
+  }
+  if (options.assetBaseUrl) {
+    return joinBase(options.assetBaseUrl);
+  }
+  if (typeof options.wasmUrl === 'string' && /^(https?:|file:|\/)/.test(options.wasmUrl)) {
+    return joinBase(options.wasmUrl.slice(0, options.wasmUrl.lastIndexOf('/') + 1));
+  }
+
+  try {
+    const assets = await import('facebetter-core/assets');
+    return {
+      wasmUrl: options.wasmAssetUrl || assets.wasmUrl,
+      resourceUrl: options.resourceAssetUrl || assets.resourceUrl,
+    };
+  } catch {
+    return joinBase(scriptDirectory());
+  }
+}
+
+/**
+ * Instantiate the Emscripten factory using already-downloaded bytes.
+ */
+async function instantiateRuntime(factory, wasmBytes, resourceBytes) {
+  if (!factory) {
+    throw new FacebetterError(
+      'WASM module does not export createFaceBetterModule',
+      'WASM_LOAD_ERROR'
+    );
+  }
+
+  const module = await factory({
+    instantiateWasm(imports, receiveInstance) {
+      return WebAssembly.instantiate(wasmBytes, imports).then((result) => {
+        receiveInstance(result.instance, result.module);
+      });
+    },
+  });
+
+  if (!module) {
+    throw new FacebetterError('Failed to initialize WASM module', 'WASM_LOAD_ERROR');
+  }
+  if (!module.FS) {
+    throw new FacebetterError('Runtime filesystem is not available', 'WASM_LOAD_ERROR');
+  }
+  module.FS.writeFile(MEMFS_RESOURCE_PATH, resourceBytes);
+  module.ready = true;
+  return module;
 }
 
 /**
@@ -1778,21 +1794,19 @@ function toImageData(source, width, height) {
  */
 
 
-// ESM-specific WASM loader
 let wasmModuleInstance = null;
 let wasmModulePromise = null;
 
 /**
- * Loads the WebAssembly module (ESM version)
- * Supports ESM format WASM modules (generated with MODULARIZE and EXPORT_ES6)
- * With SINGLE_FILE=1, WASM binary and data files are embedded in the JS file
- * @param {Object} [options] - Options
- * @param {string} [options.wasmUrl] - Custom WASM module URL (defaults to facebetter-core npm package)
- * @param {Function} [options.locateFile] - Custom locateFile function (usually not needed with SINGLE_FILE=1)
- * @returns {Promise<Object>} Promise that resolves with the WASM module
+ * Load the runtime factory, then download .wasm and resource.fbd with progress.
+ * @param {Object} [options]
+ * @param {function} [options.onProgress]
+ * @param {string} [options.assetBaseUrl]
+ * @param {string} [options.wasmUrl] Glue JS URL (optional)
  */
 async function loadWasmModule(options = {}) {
   if (wasmModuleInstance) {
+    options.onProgress?.({ loaded: 1, total: 1, percent: 100 });
     return wasmModuleInstance;
   }
 
@@ -1801,53 +1815,32 @@ async function loadWasmModule(options = {}) {
   }
 
   wasmModulePromise = (async () => {
-    // Try to import the WASM module factory
-    // facebetter-core.js is an Emscripten-generated ESM file (with MODULARIZE and EXPORT_ES6)
-    // It's provided by the facebetter-core npm package
-    let FaceBetterModuleFactory;
-    
     try {
-      // Get the WASM module
+      let factory;
       if (options.wasmUrl) {
-        // If custom URL is provided, use it (for backward compatibility or custom builds)
-        const wasmModule = await import(options.wasmUrl);
-        FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
+        const wasmModule = await import(/* @vite-ignore */ options.wasmUrl);
+        factory = wasmModule.default || wasmModule.createFaceBetterModule;
       } else {
-        // Import from facebetter-core npm package
         const wasmModule = await import('facebetter-core');
-        
-        // Get the factory function (default export or named export)
-        FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
-      }
-      
-      if (!FaceBetterModuleFactory) {
-        throw new Error('WASM module does not export createFaceBetterModule function');
+        factory = wasmModule.default || wasmModule.createFaceBetterModule;
       }
-    } catch (e) {
-      throw new FacebetterError(`Failed to load WASM module: ${e.message}`);
-    }
-
-    // Configure module options
-    // With SINGLE_FILE=1, WASM binary and data files are embedded in the JS file
-    // No need to handle .wasm and .data file paths separately
-    const moduleOptions = {
-      locateFile: options.locateFile || function(path, prefix) {
-        // With SINGLE_FILE=1, Emscripten handles embedded files automatically
-        // Custom locateFile is only needed if user provides one
-        return prefix + path;
-      },
-      ...options
-    };
-
-    // Initialize the module (MODULARIZE returns a Promise)
-    wasmModuleInstance = await FaceBetterModuleFactory(moduleOptions);
-    
-    if (!wasmModuleInstance) {
-      throw new FacebetterError('Failed to initialize WASM module');
+      const urls = await resolveRuntimeAssetUrls(options);
+      const { wasmBytes, resourceBytes } = await fetchRuntimeAssets({
+        ...urls,
+        onProgress: options.onProgress,
+      });
+      wasmModuleInstance = await instantiateRuntime(
+        factory,
+        wasmBytes,
+        resourceBytes
+      );
+      return wasmModuleInstance;
+    } catch (error) {
+      wasmModulePromise = null;
+      throw error instanceof FacebetterError
+        ? error
+        : new FacebetterError(`Failed to load WASM module: ${error.message}`, 'WASM_LOAD_ERROR');
     }
-
-    wasmModuleInstance.ready = true;
-    return wasmModuleInstance;
   })();
 
   return wasmModulePromise;
@@ -1908,7 +1901,7 @@ function cleanupFacebetterCanvas() {
 
 // Create platform API
 const platformAPI = {
-  loadWasmModule: () => loadWasmModule(),
+  loadWasmModule: (options) => loadWasmModule(options),
   getWasmModule,
   getWasmBuffer,
   toImageData: toImageData,
@@ -1957,12 +1950,9 @@ var index = {
   BeautyEffectEngine: ESMBeautyEffectEngine,
   EngineConfig,
   FacebetterError,
-  FACEBETTER_AUTH_URL,
-  createDirectAuthFetcher,
-  requestFacebetterAuth,
   ...constants,
   loadWasmModule
 };
 
-export { ESMBeautyEffectEngine as BeautyEffectEngine, BlushColor, BlushStyle, ChromaKeyColor, ContourStyle, EngineConfig, EngineEventCode, EyeLinerColor, EyeLinerStyle, EyeShadowColor, EyeShadowStyle, EyebrowColor, EyebrowStyle, EyelashColor, EyelashStyle, FACEBETTER_AUTH_URL, FacebetterError, FrameType, LipstickColor, MirrorMode, PupilColor, Reshape, SmoothingStyle, WhiteningStyle, createBeautyEffectEngine, createDirectAuthFetcher, index as default, getWasmBuffer, getWasmModule, loadWasmModule, requestFacebetterAuth };
+export { ESMBeautyEffectEngine as BeautyEffectEngine, BlushColor, BlushStyle, ChromaKeyColor, ContourStyle, EngineConfig, EngineEventCode, EyeLinerColor, EyeLinerStyle, EyeShadowColor, EyeShadowStyle, EyebrowColor, EyebrowStyle, EyelashColor, EyelashStyle, FacebetterError, FrameType, LipstickColor, MirrorMode, PupilColor, Reshape, SmoothingStyle, WhiteningStyle, createBeautyEffectEngine, index as default, getWasmBuffer, getWasmModule, loadWasmModule };
 //# sourceMappingURL=facebetter.esm.js.map