facebetter 2.0.0 → 2.0.1

package/dist/facebetter.js

@@ -11,58 +11,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'}'}`;
     }
   }
 
@@ -312,40 +287,6 @@
     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
@@ -410,8 +351,6 @@
 
       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;
@@ -431,7 +370,8 @@
       this._toImageData = platformAPI.toImageData;
       this._ensureFacebetterCanvas = platformAPI.ensureFacebetterCanvas;
       this._cleanupFacebetterCanvas = platformAPI.cleanupFacebetterCanvas;
-      
+      this._pendingLogConfig = null;
+
       // Browser-specific state
       this._facebetterCanvas = null;
       this._createdFacebetterCanvas = false;
@@ -442,9 +382,8 @@
       if (this._ensureFacebetterCanvas) {
         this._ensureFacebetterCanvas();
       }
-      
-      // Start loading WASM module immediately in constructor
-      this._wasmLoadPromise = this._loadWasmModule();
+
+      this._wasmLoadPromise = null;
       this._initPromise = null;
     }
 
@@ -501,8 +440,12 @@
     /**
      * 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 = {}) {
@@ -519,9 +462,18 @@
       // 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,
@@ -531,6 +483,11 @@
             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
@@ -556,66 +513,12 @@
             };
           }
 
-          // 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.
@@ -659,7 +562,8 @@
           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;
         }
       })();
@@ -716,8 +620,9 @@
     }
 
     /**
-     * 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
@@ -726,8 +631,15 @@
      * @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);
@@ -1632,100 +1544,204 @@
 
   }
 
-  /** 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;
   }
 
   /**
@@ -1734,6 +1750,7 @@
    * Uses document.currentScript for automatic path detection in UMD builds
    */
 
+
   /**
    * Gets the base path of the current script
    * Similar to Node.js __dirname
@@ -1839,6 +1856,7 @@
    */
   async function loadWasmModule(options = {}) {
     if (wasmModuleInstance) {
+      options.onProgress?.({ loaded: 1, total: 1, percent: 100 });
       return wasmModuleInstance;
     }
 
@@ -1848,57 +1866,44 @@
 
     wasmModulePromise = (async () => {
       try {
-        let FaceBetterModuleFactory;
-        
+        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 {
-          // Try to import from facebetter-core npm package
-          // Note: In UMD builds, this may not work if facebetter-core is not available
-          // In that case, fallback to relative path detection
           try {
             const wasmModule = await import('facebetter-core');
-            FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
-          } catch (e) {
-            // Fallback: try to find facebetter-core.js relative to current script
-            // This handles UMD builds where npm packages may not be available
+            factory = wasmModule.default || wasmModule.createFaceBetterModule;
+          } catch {
             const basePath = getScriptBasePath();
-            const wasmPath = resolvePath('facebetter-core.js', basePath);
-            const wasmModule = await import(wasmPath);
-            FaceBetterModuleFactory = wasmModule.default || wasmModule.createFaceBetterModule;
+            const gluePath = resolvePath('facebetter-core.js', basePath);
+            const wasmModule = await import(gluePath);
+            factory = wasmModule.default || wasmModule.createFaceBetterModule;
+            if (!options.assetBaseUrl) {
+              options = { ...options, assetBaseUrl: basePath };
+            }
           }
         }
-        
-        if (!FaceBetterModuleFactory) {
-          throw new Error('WASM module does not export createFaceBetterModule function');
-        }
-
-        // 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 Error('Failed to initialize WASM module');
+        if (!factory) {
+          throw new Error('WASM module does not export createFaceBetterModule function');
         }
 
-        wasmModuleInstance.ready = true;
+        const urls = await resolveRuntimeAssetUrls(options);
+        const { wasmBytes, resourceBytes } = await fetchRuntimeAssets({
+          ...urls,
+          onProgress: options.onProgress,
+        });
+        wasmModuleInstance = await instantiateRuntime(
+          factory,
+          wasmBytes,
+          resourceBytes
+        );
         return wasmModuleInstance;
       } catch (e) {
         wasmModulePromise = null;
-        throw new Error(`Failed to load WASM module: ${e.message}`);
+        throw new FacebetterError(`Failed to load WASM module: ${e.message}`, 'WASM_LOAD_ERROR');
       }
     })();
 
@@ -2016,7 +2021,7 @@
 
   // Create platform API
   const platformAPI = {
-    loadWasmModule: () => loadWasmModule(),
+    loadWasmModule: (options) => loadWasmModule(options),
     getWasmModule: getWasmModule,
     getWasmBuffer: getWasmBuffer,
     toImageData: toImageData,
@@ -2065,9 +2070,6 @@
     BeautyEffectEngine: BrowserBeautyEffectEngine,
     EngineConfig,
     FacebetterError,
-    FACEBETTER_AUTH_URL,
-    createDirectAuthFetcher,
-    requestFacebetterAuth,
     ...constants,
     loadWasmModule: loadWasmModule
   };
@@ -2087,7 +2089,6 @@
   exports.EyebrowStyle = EyebrowStyle;
   exports.EyelashColor = EyelashColor;
   exports.EyelashStyle = EyelashStyle;
-  exports.FACEBETTER_AUTH_URL = FACEBETTER_AUTH_URL;
   exports.FacebetterError = FacebetterError;
   exports.FrameType = FrameType;
   exports.LipstickColor = LipstickColor;
@@ -2097,10 +2098,8 @@
   exports.SmoothingStyle = SmoothingStyle;
   exports.WhiteningStyle = WhiteningStyle;
   exports.createBeautyEffectEngine = createBeautyEffectEngine;
-  exports.createDirectAuthFetcher = createDirectAuthFetcher;
   exports.default = index;
   exports.loadWasmModule = loadWasmModule;
-  exports.requestFacebetterAuth = requestFacebetterAuth;
 
   Object.defineProperty(exports, '__esModule', { value: true });