facebetter 1.5.1 → 2.0.1

package/dist/facebetter.esm.js

@@ -1,3 +1,40 @@
+/**
+ * Engine Configuration
+ * Platform-agnostic configuration class
+ */
+
+/**
+ * Engine configuration class
+ * 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}`
+   *   HTTP response body from your auth server.
+   * @param {boolean} [config.externalContext] Kept for cross-platform alignment;
+   *   unused on Web today.
+   */
+  constructor(config = {}) {
+    this.licenseToken = config.licenseToken || null;
+    this.resourcePath = '/resource.fbd';
+    /**
+     * Whether to use an external GL context (native platforms only).
+     * On Web this field is kept for config-shape alignment and has no effect.
+     */
+    this.externalContext = !!config.externalContext;
+  }
+
+  isValid() {
+    return typeof this.licenseToken === 'string' &&
+           this.licenseToken.trim() !== '';
+  }
+
+  toString() {
+    return `EngineConfig{mode='${this.isValid() ? 'licenseToken' : 'invalid'}'}`;
+  }
+}
+
 /**
  * Facebetter Error Classes
  * Platform-agnostic error handling
@@ -26,257 +63,246 @@ function checkResult(result, errorMessage = 'Operation failed') {
 }
 
 /**
- * Engine Configuration
- * Platform-agnostic configuration class
+ * Facebetter Constants and Enums
+ * Platform-agnostic constants. Ordinals match facebetter::beauty_params.
  */
 
+const WhiteningStyle$1 = {
+  ColdWhite: 0,  // Cool white
+  PinkWhite: 1,  // Pink white
+  WarmWhite: 2,  // Warm white
+  Wheat: 3,      // Light wheat / olive
+  Tan: 4         // Tan / bronzed
+};
+
+const SmoothingStyle$1 = {
+  Natural: 0,  // Natural: keeps pores
+  Texture: 1,  // Cleaner skin while retaining texture
+  Smooth: 2    // Creamy / porcelain finish
+};
 
 /**
- * Engine configuration class
- * Similar to EngineConfig struct in C++/Java/OC
+ * Face reshape parameters.
+ * Values match facebetter::beauty_params::Reshape.
+ * Intensity range is [-1.0, 1.0]; 0 is off. Comments list + / - directions.
  */
-class EngineConfig {
-  /**
-   * Creates a new EngineConfig instance
-   * @param {Object} config - Configuration object
-   * @param {string} [config.appId] - Application ID (required if licenseJson is not provided)
-   * @param {string} [config.appKey] - Application key (required if licenseJson is not provided)
-   * @param {string} [config.licenseJson] - License JSON string (optional, if provided, appId and appKey are not required)
-   */
-  constructor(config = {}) {
-    this.appId = config.appId || null;
-    this.appKey = config.appKey || null;
-    this.licenseJson = config.licenseJson || null;
-    this.resourcePath = '/resource.fbd';
-    /**
-     * Whether to use an external GL context (native platforms only).
-     * In Web/WASM environments, this field is kept for configuration structure alignment,
-     * but it does not take effect in the current implementation.
-     */
-    this.externalContext = !!config.externalContext;
-  }
+const Reshape$1 = {
+  FaceThin: 0,        // +slim face / -fuller cheeks
+  FaceVShape: 1,      // +V-shape jaw / -square jaw
+  FaceNarrow: 2,      // +narrow face / -wider face
+  FaceShort: 3,       // +shorter face / -longer face
+  Cheekbone: 4,       // +slim cheekbones / -wider cheekbones
+  Jawbone: 5,         // +slim jaw / -wider jaw
+  Chin: 6,            // +longer chin / -shorter chin
+  NoseSlim: 7,        // +slimmer nose / -wider nose
+  EyeSize: 8,         // +larger eyes / -smaller eyes
+  EyeDistance: 9,     // +wider eye spacing / -closer eyes
+  FaceSmall: 10,      // +smaller face / -larger face
+  Forehead: 11,       // +fuller forehead / -lower forehead
+  NoseLong: 12,       // +longer nose / -shorter nose
+  Philtrum: 13,       // +shorter philtrum / -longer philtrum
+  MouthSize: 14,      // +larger mouth / -smaller mouth
+  MouthPosition: 15,  // +mouth lower / -mouth higher
+  MouthSmile: 16,     // +smile lift / -droop corners
+  LipThickness: 17,   // +thicker lips / -thinner lips
+  EyeRound: 18,       // +rounder eyes / -narrower eyes
+  EyePosition: 19,    // +eyes lower / -eyes higher
+  EyeAngle: 20,       // +outer corner up / -outer corner down
+  EyeCornerOpen: 21,  // +open eye corners / -close eye corners
+  LowerEyelid: 22,    // +lower eyelid down / -lift lower eyelid
+  BrowPosition: 23,   // +brows higher / -brows lower
+  BrowDistance: 24,   // +wider brow spacing / -closer brows
+  BrowThickness: 25   // +thicker brows / -thinner brows
+};
 
-  /**
-   * Validates the configuration
-   * @returns {boolean} True if valid
-   */
-  isValid() {
-    // If licenseJson is provided, use it for validation
-    if (this.licenseJson) {
-      return typeof this.licenseJson === 'string' && this.licenseJson.trim() !== '';
-    }
-    // Otherwise appId and appKey are required
-    return this.appId && typeof this.appId === 'string' && this.appId.trim() !== '' &&
-           this.appKey && typeof this.appKey === 'string' && this.appKey.trim() !== '';
-  }
+const EngineEventCode$1 = {
+  LicenseValidationSuccess: 0,
+  LicenseValidationFailed: 1,
+  InitializationComplete: 100,
+  InitializationFailed: 101
+};
 
-  /**
-   * Returns a string representation of the config
-   * @returns {string} String representation
-   */
-  toString() {
-    return `EngineConfig{appId='${this.appId ? this.appId.substring(0, Math.min(this.appId.length, 8)) + '...' : 'null'}', appKey='${this.appKey ? '***' : 'null'}', licenseJson=${this.licenseJson ? 'provided' : 'null'}}`;
-  }
-}
+const LipstickColor$1 = {
+  Rouge: 0,           // Classic rose
+  RetroRed: 1,        // Retro red
+  Peach: 2,           // Peach
+  CoralOrange: 3,     // Coral orange
+  GentlePink: 4,      // Soft pink
+  VitalityOrange: 5   // Bright orange
+};
 
-/**
- * Facebetter Constants and Enums
- * Platform-agnostic constants
- */
+const BlushStyle$1 = {
+  SunKissed: 0,  // Sun-kissed sweep across cheekbones and bridge
+  Igari: 1,      // Flushed band across the nose bridge
+  Soft: 2,       // Soft dual cheeks
+  Apple: 3,      // Round apple cheeks
+  Classic: 4,    // Classic two spots
+  Doll: 5,       // Cheeks + nose tip
+  Rose: 6        // Rose dual cheeks
+};
 
-/**
- * Beauty type enumeration
- */
-const BeautyType$1 = {
-  Basic: 0,             // Basic beauty (smoothing, whitening, etc.)
-  Reshape: 1,           // Face reshaping (face thinning, big eyes, etc.)
-  Makeup: 2,            // Makeup effects (lipstick, blush, etc.)
-  VirtualBackground: 3,  // Virtual background (blur, image replacement)
-  ChromaKey: 4,          // Chroma key (green screen removal)
-  Filter: 5,             // LUT based filter
-  Sticker: 6             // 2D/3D sticker
+const BlushColor$1 = {
+  CoralPink: 0,     // Coral pink
+  DustyRose: 1,     // Dusty rose
+  VividRed: 2,      // Vivid red
+  Berry: 3,         // Berry
+  SunsetOrange: 4   // Sunset orange
 };
 
-/**
- * Basic beauty parameter enumeration
- * All values should be in range [0.0, 1.0]
- */
-const BasicParam$1 = {
-  Smoothing: 0,   // Skin smoothing (0.0: none, 1.0: maximum)
-  Sharpening: 1,  // Image sharpening (0.0: none, 1.0: maximum)
-  Whitening: 2,   // Skin whitening (0.0: none, 1.0: maximum)
-  Rosiness: 3     // Skin rosiness (0.0: none, 1.0: maximum)
+const ContourStyle$1 = {
+  Natural: 0,  // Soft everyday contour
+  Sculpt: 1,   // Deeper sculpted contour
+  Glow: 2,     // Highlight-focused
+  Slim: 3,     // Slim cheekbones
+  Nose: 4,     // Nose bridge lift
+  Glam: 5      // Spot highlights
 };
 
-/**
- * Face reshape parameter enumeration
- * All values should be in range [0.0, 1.0]
- */
-const ReshapeParam$1 = {
-  FaceThinning: 0,  // Face thinning (0.0: none, 1.0: maximum)
-  FaceVShape: 1,    // V-shape face (0.0: none, 1.0: maximum)
-  FaceNarrowing: 2, // Face narrowing (0.0: none, 1.0: maximum)
-  FaceShortening: 3,// Face shortening (0.0: none, 1.0: maximum)
-  Cheekbone: 4,     // Cheekbone slimming (0.0: none, 1.0: maximum)
-  Jawbone: 5,       // Jawbone slimming (0.0: none, 1.0: maximum)
-  Chin: 6,          // Chin length adjustment (0.0: none, 1.0: maximum)
-  NoseSlimming: 7,  // Nose slimming (0.0: none, 1.0: maximum)
-  EyeSize: 8,       // Eye size (0.0: normal, 1.0: maximum)
-  EyeDistance: 9    // Eye distance (0.0: normal, 1.0: maximum)
+const EyeShadowStyle$1 = {
+  Soft: 0,    // Soft wash
+  Crease: 1,  // Crease deepen
+  Smoky: 2,   // Smoky surround
+  Halo: 3,    // Halo around the eye
+  Glow: 4,    // Outer-corner glow
+  Drama: 5,   // Full dramatic cover
+  Warm: 6     // Warm-tone wash
 };
 
-/**
- * Makeup parameter enumeration
- * All values should be in range [0.0, 1.0]
- */
-const MakeupParam$1 = {
-  Lipstick: 0,    // Lipstick intensity (0.0: none, 1.0: maximum)
-  Blush: 1        // Blush intensity (0.0: none, 1.0: maximum)
+const EyeShadowColor$1 = {
+  Plum: 0,   // Plum / mauve (default)
+  Brown: 1,  // Warm brown
+  Gold: 2,   // Soft gold
+  Pink: 3    // Dusty pink
 };
 
-/**
- * Lipstick style types
- */
-const LipstickStyle$1 = {
-  Rouge: 0,  // Rose red
-  Coral: 1,  // Coral
-  Pink: 2    // Pink
+const EyeLinerStyle$1 = {
+  Classic: 0,  // Full liner with winged tip
+  Flick: 1,    // Extended outer flick
+  CatEye: 2,   // Short cat-eye lift
+  Natural: 3,  // Thin soft natural line
+  Bold: 4,     // Bold cover
+  Soft: 5      // Soft feathered wing
 };
 
-/**
- * Blush style types
- */
-const BlushStyle$1 = {
-  Classic: 0,  // Classic
-  Peach: 1,    // Peach
-  Rose: 2      // Rose
+const EyeLinerColor$1 = {
+  Burgundy: 0,   // Burgundy brown
+  Plum: 1,       // Deep plum
+  Chocolate: 2,  // Chocolate brown
+  Coffee: 3,     // Near-black coffee
+  Mauve: 4       // Mauve grey
 };
 
-/**
- * Chroma Key parameter enumeration
- */
-const ChromaKeyParam$1 = {
-  KeyColor: 0,      // Key color (0.0: Green, 1.0: Blue, 2.0: Red)
-  Similarity: 1,    // Color similarity (0.0 - 1.0)
-  Smoothness: 2,    // Edge smoothness (0.0 - 1.0)
-  Desaturation: 3   // Spill desaturation (0.0 - 1.0)
+const EyebrowStyle$1 = {
+  Natural: 0,    // Natural arch with hair strokes
+  Soft: 1,       // Soft powdery thick brow
+  Feathered: 2,  // Feathered hair strokes
+  Mist: 3,       // Light powder mist
+  Arched: 4,     // Classic high arch
+  Powder: 5,     // Dense powder fill
+  Wild: 6,       // Wispy upper edge
+  Full: 7,       // Full balanced brow
+  Straight: 8    // Straight low arch
 };
 
-/**
- * Background mode enumeration
- */
-const BackgroundMode$1 = {
-  None: 0,        // No background processing
-  Blur: 1,        // Blurred background
-  Image: 2        // Background image replacement
+const EyebrowColor$1 = {
+  DarkBrown: 0,  // Dark brown (default)
+  Black: 1,      // Black
+  SoftBrown: 2   // Soft brown
 };
 
-/**
- * Frame type enumeration
- */
-const FrameType$1 = {
-  Image: 0,       // Image mode
-  Video: 1        // Video mode
+const EyelashStyle$1 = {
+  Classic: 0,    // Balanced clusters + lower lashes
+  Manga: 1,      // Bold spiked clusters
+  Winged: 2,     // Extended outer corner
+  Wispy: 3,      // Fluffy lifted tips
+  Clustered: 4,  // Distinct clusters
+  Doll: 5        // Short doll lashes
 };
 
-/**
- * Mirror mode enumeration (apply to input before processing)
- */
-const MirrorMode$1 = {
-  None: 0,        // No mirror
-  Horizontal: 1,  // Mirror horizontally (e.g. front camera selfie)
-  Vertical: 2,    // Mirror vertically
-  Both: 3         // Mirror both axes
+const EyelashColor$1 = {
+  Black: 0,      // Near-black (default)
+  Brown: 1,      // Soft brown
+  SoftBlack: 2   // Slightly softer black
 };
 
-/**
- * Virtual background options class
- * Matches the C++/Java/OC API design
- */
-let VirtualBackgroundOptions$1 = class VirtualBackgroundOptions {
-  /**
-   * Creates a new VirtualBackgroundOptions instance
-   * @param {Object} [options] - Options object
-   * @param {number} [options.mode] - Background mode (use BackgroundMode enum)
-   * @param {ImageData|HTMLImageElement|HTMLCanvasElement} [options.backgroundImage] - Background image (required when mode is Image)
-   */
-  constructor(options = {}) {
-    this.mode = options.mode !== undefined ? options.mode : BackgroundMode$1.None;
-    this.backgroundImage = options.backgroundImage || null;
-  }
+const PupilColor$1 = {
+  Hazel: 0,  // Amber / honey brown
+  Ice: 1,    // Icy blue
+  Mocha: 2,  // Dark brown with sparkle
+  Olive: 3,  // Forest green
+  Gloss: 4,  // Glossy dark brown
+  Moss: 5,   // Muted olive
+  Sand: 6,   // Sandy beige brown
+  Glow: 7,   // Lower-iris crescent highlight
+  Slate: 8   // Cool blue-grey
+};
 
-  /**
-   * Validates the options
-   * @returns {boolean} True if valid
-   */
-  isValid() {
-    if (this.mode === BackgroundMode$1.Image) {
-      return this.backgroundImage !== null;
-    }
-    return true;
-  }
+const ChromaKeyColor$1 = {
+  Green: 0,
+  Blue: 1,
+  Red: 2
+};
+
+/** Frame type for processing (affects temporal smoothing / tracking). */
+const FrameType$1 = {
+  Image: 0,  // Still image
+  Video: 1   // Continuous video stream
+};
+
+/** Mirror mode applied to the input before processing. */
+const MirrorMode$1 = {
+  None: 0,        // No mirror
+  Horizontal: 1,  // Horizontal (e.g. front-camera selfie)
+  Vertical: 2,    // Vertical
+  Both: 3         // Both axes
 };
 
 var constants = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  BackgroundMode: BackgroundMode$1,
-  BasicParam: BasicParam$1,
-  BeautyType: BeautyType$1,
+  BlushColor: BlushColor$1,
   BlushStyle: BlushStyle$1,
-  ChromaKeyParam: ChromaKeyParam$1,
+  ChromaKeyColor: ChromaKeyColor$1,
+  ContourStyle: ContourStyle$1,
+  EngineEventCode: EngineEventCode$1,
+  EyeLinerColor: EyeLinerColor$1,
+  EyeLinerStyle: EyeLinerStyle$1,
+  EyeShadowColor: EyeShadowColor$1,
+  EyeShadowStyle: EyeShadowStyle$1,
+  EyebrowColor: EyebrowColor$1,
+  EyebrowStyle: EyebrowStyle$1,
+  EyelashColor: EyelashColor$1,
+  EyelashStyle: EyelashStyle$1,
   FrameType: FrameType$1,
-  LipstickStyle: LipstickStyle$1,
-  MakeupParam: MakeupParam$1,
+  LipstickColor: LipstickColor$1,
   MirrorMode: MirrorMode$1,
-  ReshapeParam: ReshapeParam$1,
-  VirtualBackgroundOptions: VirtualBackgroundOptions$1
+  PupilColor: PupilColor$1,
+  Reshape: Reshape$1,
+  SmoothingStyle: SmoothingStyle$1,
+  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).
+ * Beauty Effect Engine Core
+ * Platform-agnostic engine implementation with dependency injection
  */
 
-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));
-}
+/** Byte layouts of fb_engine_config_t / fb_log_config_t on wasm32. */
+const FB_ENGINE_CONFIG_SIZE = 28;
+const FB_LOG_CONFIG_SIZE = 16;
 
-/** @param {string} message */
-function logWarn(message) {
-  console.warn(formatLogLine('warning', message));
+function allocUtf8(Module, text) {
+  const value = text || '';
+  const len = Module.lengthBytesUTF8(value) + 1;
+  const ptr = Module._malloc(len);
+  Module.stringToUTF8(value, ptr, len);
+  return ptr;
 }
 
-/** @param {string} message */
-function logError(message) {
-  console.error(formatLogLine('error', message));
+function writeI32(Module, ptr, index, value) {
+  Module.HEAP32[(ptr >> 2) + index] = value;
 }
 
-/**
- * Beauty Effect Engine Core
- * Platform-agnostic engine implementation with dependency injection
- */
-
-
 /**
  * Beauty effect engine class
  * Provides high-level API for face beauty effects processing
@@ -291,9 +317,8 @@ class BeautyEffectEngine {
    * @param {Function} platformAPI.getWasmModule - Get WASM module instance
    * @param {Function} platformAPI.getWasmBuffer - Get WASM memory buffer
    * @param {Function} platformAPI.toImageData - Convert to ImageData
-   * @param {Function} platformAPI.verifyAppKeyOnline - Verify app key online
-   * @param {Function} [platformAPI.ensureGPUPixelCanvas] - Ensure GPU canvas exists (browser only)
-   * @param {Function} [platformAPI.cleanupGPUPixelCanvas] - Cleanup GPU canvas (browser only)
+   * @param {Function} [platformAPI.ensureFacebetterCanvas] - Ensure GPU canvas exists (browser only)
+   * @param {Function} [platformAPI.cleanupFacebetterCanvas] - Cleanup GPU canvas (browser only)
    */
   constructor(config, platformAPI) {
     if (!config) {
@@ -319,9 +344,7 @@ class BeautyEffectEngine {
     }
 
     this.config = engineConfig;
-    this.appId = engineConfig.appId;
-    this.appKey = engineConfig.appKey;
-    this.licenseJson = engineConfig.licenseJson;
+    this.licenseToken = engineConfig.licenseToken;
     this.resourcePath = '/resource.fbd';
     this.enginePtr = null;
     this.initialized = false;
@@ -339,22 +362,22 @@ class BeautyEffectEngine {
     this._getWasmModule = platformAPI.getWasmModule;
     this._getWasmBuffer = platformAPI.getWasmBuffer;
     this._toImageData = platformAPI.toImageData;
-    this._ensureGPUPixelCanvas = platformAPI.ensureGPUPixelCanvas;
-    this._cleanupGPUPixelCanvas = platformAPI.cleanupGPUPixelCanvas;
-    
+    this._ensureFacebetterCanvas = platformAPI.ensureFacebetterCanvas;
+    this._cleanupFacebetterCanvas = platformAPI.cleanupFacebetterCanvas;
+    this._pendingLogConfig = null;
+
     // Browser-specific state
-    this._gpupixelCanvas = null;
-    this._createdGPUPixelCanvas = false;
+    this._facebetterCanvas = null;
+    this._createdFacebetterCanvas = false;
     this._offscreenCanvas = null;
     this._offscreenCtx = null;
     
-    // Automatically create gpupixel_canvas if it doesn't exist (browser only)
-    if (this._ensureGPUPixelCanvas) {
-      this._ensureGPUPixelCanvas();
+    // Automatically create facebetter_canvas if it doesn't exist (browser only)
+    if (this._ensureFacebetterCanvas) {
+      this._ensureFacebetterCanvas();
     }
-    
-    // Start loading WASM module immediately in constructor
-    this._wasmLoadPromise = this._loadWasmModule();
+
+    this._wasmLoadPromise = null;
     this._initPromise = null;
   }
 
@@ -411,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 = {}) {
@@ -429,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,
@@ -441,12 +477,21 @@ 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
         if (!Module.onReportUsage) {
           Module.onReportUsage = async (payloadJson) => {
             try {
+              const payload = JSON.parse(payloadJson);
+              if (!payload.app_id || !payload.hmac_signature) {
+                return true;
+              }
               const url = 'https://facebetter.pixpark.net/facebetter/v1/report';
               const response = await fetch(url, {
                 method: 'POST',
@@ -462,48 +507,43 @@ class BeautyEffectEngine {
           };
         }
 
-        // Setup online auth proxy for WASM（纯在线，失败不回退本地缓存）。
-        if (!Module.onOnlineAuth) {
-          Module.onOnlineAuth = async (payloadJson) => {
-            const authUrl = 'https://facebetter.pixpark.net/facebetter/v1/auth';
-            logInfo('Online license: requesting auth server');
-            try {
-              const response = await fetch(authUrl, {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/json',
-                },
-                body: payloadJson,
-              });
-              if (!response.ok) {
-                logWarn(`Online license: HTTP ${response.status}`);
-                return '';
-              }
-              const text = await response.text();
-              logInfo('Online license: server response ok');
-              return text;
-            } catch (err) {
-              logWarn(
-                `Online license: network error${err?.message ? `: ${err.message}` : ''}`
-              );
-              return '';
-            }
-          };
+        // Web: fetch the token outside the engine, then pass licenseToken.
+        if (!this.licenseToken) {
+          throw new FacebetterError(
+            'Web auth requires licenseToken. Fetch it from your server before init().',
+            'LICENSE_ERROR'
+          );
         }
 
-        // Create engine instance, auth (online/offline) is handled by WASM layer via onOnlineAuth
-        const enginePtr = Module.ccall(
-          'CreateBeautyEffectEngineEx',
-          'number',
-          ['string', 'string', 'string', 'string', 'number'],
-          [
-            this.resourcePath,
-            this.licenseJson || '',
-            this.appId || '',
-            this.appKey || '',
-            this.config.externalContext ? 1 : 0
-          ]
-        );
+        // C ABI still has app_id/app_key slots; leave them empty on Web.
+        const appIdPtr = allocUtf8(Module, '');
+        const appKeyPtr = allocUtf8(Module, '');
+        const licensePtr = allocUtf8(Module, this.licenseToken);
+        const resourcePtr = allocUtf8(Module, this.resourcePath);
+        const configPtr = Module._malloc(FB_ENGINE_CONFIG_SIZE);
+        writeI32(Module, configPtr, 0, appIdPtr);
+        writeI32(Module, configPtr, 1, appKeyPtr);
+        writeI32(Module, configPtr, 2, licensePtr);
+        writeI32(Module, configPtr, 3, resourcePtr);
+        writeI32(Module, configPtr, 4, 0);
+        writeI32(Module, configPtr, 5, this.config.externalContext ? 1 : 0);
+        writeI32(Module, configPtr, 6, 0);
+
+        let enginePtr = 0;
+        try {
+          enginePtr = Module.ccall(
+            'fb_engine_create',
+            'number',
+            ['number'],
+            [configPtr]
+          );
+        } finally {
+          Module._free(configPtr);
+          Module._free(appIdPtr);
+          Module._free(appKeyPtr);
+          Module._free(licensePtr);
+          Module._free(resourcePtr);
+        }
 
         if (!enginePtr) {
           throw new FacebetterError(
@@ -516,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;
       }
     })();
@@ -551,7 +592,10 @@ class BeautyEffectEngine {
       this._callbackSharedBufferSize = 0;
     }
 
-    Module.ccall('DestroyBeautyEffectEngine', null, ['number'], [this.enginePtr]);
+    Module.ccall('fb_engine_destroy', null, ['number'], [this.enginePtr]);
+    if (Module._engine_event_callbacks) {
+      delete Module._engine_event_callbacks[this.enginePtr];
+    }
     this.enginePtr = null;
     this.initialized = false;
     this.bufferSize = 0;
@@ -563,15 +607,16 @@ class BeautyEffectEngine {
       this._offscreenCtx = null;
     }
     
-    // Clean up gpupixel_canvas if we created it
-    if (this._cleanupGPUPixelCanvas) {
-      this._cleanupGPUPixelCanvas();
+    // Clean up facebetter_canvas if we created it
+    if (this._cleanupFacebetterCanvas) {
+      this._cleanupFacebetterCanvas();
     }
   }
 
   /**
-   * Sets log configuration
-   * Can be called before init() since SetLogConfig 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
@@ -580,410 +625,426 @@ 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 result = Module.ccall(
-      'SetLogConfig',
-      'number',
-      ['bool', 'bool', 'number', 'string'],
-      [
-        config.consoleEnabled || false,
-        config.fileEnabled || false,
-        config.level || 0,
-        config.fileName || ''
-      ]
-    );
+    const fileNamePtr = allocUtf8(Module, config.fileName);
+    const configPtr = Module._malloc(FB_LOG_CONFIG_SIZE);
+    writeI32(Module, configPtr, 0, config.consoleEnabled ? 1 : 0);
+    writeI32(Module, configPtr, 1, config.fileEnabled ? 1 : 0);
+    writeI32(Module, configPtr, 2, config.level || 0);
+    writeI32(Module, configPtr, 3, fileNamePtr);
+
+    let result;
+    try {
+      result = Module.ccall(
+        'fb_set_log_config',
+        'number',
+        ['number'],
+        [configPtr]
+      );
+    } finally {
+      Module._free(configPtr);
+      Module._free(fileNamePtr);
+    }
 
     checkResult(result, 'Failed to set log config');
   }
 
   /**
-   * [Deprecated] No-op in parameter-driven mode. Use:
-   * - setBasicParam/setReshapeParam/setMakeupParam
-   * - setVirtualBackground
-   * - setFilter/setSticker
-   * Kept for compatibility and may be removed in a future release.
-   * @deprecated
-   * @param {number} beautyType - Beauty type (use BeautyType enum)
-   * @param {boolean} enabled - Enable or disable
+   * Sets skin smoothing intensity
+   * @param {number} value - Parameter value (0.0 - 1.0)
    */
-  setBeautyTypeEnabled(beautyType, enabled) {
+  setSmoothing(value) {
     this._ensureInitialized();
-    const Module = this._getWasmModule();
-
-    const result = Module.ccall(
-      'SetBeautyTypeEnabled',
-      'number',
-      ['number', 'number', 'number'],
-      [this.enginePtr, beautyType, enabled ? 1 : 0]
-    );
+    this._setIntensity('fb_set_smoothing', value);
+  }
 
-    checkResult(result, `Failed to ${enabled ? 'enable' : 'disable'} beauty type`);
+  /**
+   * Sets skin smoothing style
+   * @param {number} style - Style (use SmoothingStyle enum, e.g., SmoothingStyle.Natural)
+   */
+  setSmoothingStyle(style) {
+    this._setMakeupStyle('fb_set_smoothing_style', style, 'Failed to set smoothing style');
   }
 
   /**
-   * [Deprecated] Always returns false in parameter-driven mode.
-   * Query your own UI state or parameters instead.
-   * Kept for compatibility and may be removed in a future release.
-   * @deprecated
-   * @param {number} beautyType - Beauty type (use BeautyType enum)
-   * @returns {boolean} True if enabled
+   * Sets skin whitening intensity
+   * @param {number} value - Parameter value (0.0 - 1.0)
    */
-  isBeautyTypeEnabled(beautyType) {
+  setWhitening(value) {
     this._ensureInitialized();
-    const Module = this._getWasmModule();
-
-    const result = Module.ccall(
-      'IsBeautyTypeEnabled',
-      'number',
-      ['number', 'number'],
-      [this.enginePtr, beautyType]
-    );
-
-    if (result === -1) {
-      throw new FacebetterError('Failed to check beauty type status');
-    }
+    this._setIntensity('fb_set_whitening', value);
+  }
 
-    return result === 1;
+  /**
+   * Sets whitening style by swapping the custom LUT
+   * @param {number} style - Style (use WhiteningStyle enum, e.g., WhiteningStyle.ColdWhite)
+   */
+  setWhiteningStyle(style) {
+    this._setMakeupStyle('fb_set_whitening_style', style, 'Failed to set whitening style');
   }
 
   /**
-   * [Deprecated] No-op that returns success. To reset, explicitly zero parameters
-   * and clear effects via parameter-driven APIs. Kept for compatibility and may
-   * be removed in a future release.
-   * @deprecated
+   * Sets image sharpening intensity
+   * @param {number} value - Parameter value (0.0 - 1.0)
    */
-  disableAllBeautyTypes() {
+  setSharpening(value) {
     this._ensureInitialized();
-    const Module = this._getWasmModule();
-
-    const result = Module.ccall(
-      'DisableAllBeautyTypes',
-      'number',
-      ['number'],
-      [this.enginePtr]
-    );
-
-    checkResult(result, 'Failed to disable all beauty types');
+    this._setIntensity('fb_set_sharpening', value);
   }
 
   /**
-   * Sets a basic beauty parameter
-   * @param {number} param - Parameter (use BasicParam enum, e.g., BasicParam.Smoothing)
+   * Sets skin rosiness intensity
    * @param {number} value - Parameter value (0.0 - 1.0)
    */
-  setBasicParam(param, value) {
+  setRosiness(value) {
     this._ensureInitialized();
-    this._setBeautyParam('SetBeautyParamBasic', param, value);
+    this._setIntensity('fb_set_rosiness', value);
   }
 
   /**
    * Sets a reshape parameter
-   * @param {number} param - Parameter (use ReshapeParam enum, e.g., ReshapeParam.FaceThinning)
-   * @param {number} value - Parameter value (0.0 - 1.0)
+   * @param {number} param - Parameter (use Reshape enum, e.g., Reshape.FaceThin)
+   * @param {number} value - Parameter value in [-1.0, 1.0]. 0 is off.
    */
-  setReshapeParam(param, value) {
+  setReshape(param, value) {
     this._ensureInitialized();
-    this._setBeautyParam('SetBeautyParamReshape', param, value);
+    this._setBeautyParam('fb_set_reshape', param, value);
   }
 
   /**
-   * Sets a makeup parameter
-   * @param {number} param - Parameter (use MakeupParam enum, e.g., MakeupParam.Lipstick)
+   * Sets lipstick intensity
    * @param {number} value - Parameter value (0.0 - 1.0)
    */
-  setMakeupParam(param, value) {
+  setLipstick(value) {
     this._ensureInitialized();
-    this._setBeautyParam('SetBeautyParamMakeup', param, value);
+    this._setIntensity('fb_set_lipstick', value);
   }
 
   /**
-   * Sets lipstick style/texture
-   * @param {number} style - Style (use LipstickStyle enum, e.g., LipstickStyle.Rouge)
+   * Sets lipstick colour preset
+   * @param {number} style - Style (use LipstickColor enum, e.g., LipstickColor.Rouge)
    */
-  setLipstickStyle(style) {
-    this._ensureInitialized();
-    const Module = this._getWasmModule();
-    const result = Module.ccall(
-      'SetLipstickStyle',
-      'number',
-      ['number', 'number'],
-      [this.enginePtr, style]
-    );
-    checkResult(result, 'Failed to set lipstick style');
+  setLipstickColor(style) {
+    this._setMakeupStyle('fb_set_lipstick_color', style, 'Failed to set lipstick style');
   }
 
   /**
-   * Sets blush style/texture
-   * @param {number} style - Style (use BlushStyle enum, e.g., BlushStyle.Classic)
+   * Sets blush intensity
+   * @param {number} value - Parameter value (0.0 - 1.0)
    */
+  setBlush(value) {
+    this._ensureInitialized();
+    this._setIntensity('fb_set_blush', value);
+  }
+
   setBlushStyle(style) {
+    this._setMakeupStyle('fb_set_blush_style', style, 'Failed to set blush style');
+  }
+
+  setBlushColor(color) {
+    this._setMakeupStyle('fb_set_blush_color', color, 'Failed to set blush color');
+  }
+
+  setContour(value) {
     this._ensureInitialized();
-    const Module = this._getWasmModule();
-    const result = Module.ccall(
-      'SetBlushStyle',
-      'number',
-      ['number', 'number'],
-      [this.enginePtr, style]
-    );
-    checkResult(result, 'Failed to set blush style');
+    this._setIntensity('fb_set_contour', value);
   }
 
-  /**
-   * Sets chroma key parameter
-   * @param {number} param - Parameter (use ChromaKeyParam enum, e.g., ChromaKeyParam.Similarity)
-   * @param {number} value - Parameter value (KeyColor: 0.0=Green, 1.0=Blue, 2.0=Red; others 0.0-1.0)
-   */
-  setChromaKeyParam(param, value) {
+  setContourStyle(style) {
+    this._setMakeupStyle('fb_set_contour_style', style, 'Failed to set contour style');
+  }
+
+  setEyeShadow(value) {
     this._ensureInitialized();
-    // For KeyColor, values are 0, 1, 2, not 0.0-1.0
-    if (param === 0) { // ChromaKeyParam.KeyColor
-        const Module = this._getWasmModule();
-        const result = Module.ccall(
-          'SetBeautyParamChromaKey',
-          'number',
-          ['number', 'number', 'number'],
-          [this.enginePtr, param, value]
-        );
-        checkResult(result, `Failed to set chroma key parameter`);
-        return;
-    }
-    this._setBeautyParam('SetBeautyParamChromaKey', param, value);
+    this._setIntensity('fb_set_eye_shadow', value);
+  }
+
+  setEyeShadowStyle(style) {
+    this._setMakeupStyle('fb_set_eye_shadow_style', style, 'Failed to set eyeshadow style');
+  }
+
+  setEyeShadowColor(style) {
+    this._setMakeupStyle('fb_set_eye_shadow_color', style, 'Failed to set eyeshadow style');
+  }
+
+  setEyeLiner(value) {
+    this._ensureInitialized();
+    this._setIntensity('fb_set_eye_liner', value);
+  }
+
+  setEyeLinerStyle(style) {
+    this._setMakeupStyle('fb_set_eye_liner_style', style, 'Failed to set eyeliner style');
+  }
+
+  setEyeLinerColor(style) {
+    this._setMakeupStyle('fb_set_eye_liner_color', style, 'Failed to set eyeliner style');
+  }
+
+  setEyebrow(value) {
+    this._ensureInitialized();
+    this._setIntensity('fb_set_eyebrow', value);
+  }
+
+  setEyebrowStyle(style) {
+    this._setMakeupStyle('fb_set_eyebrow_style', style, 'Failed to set eyebrow style');
+  }
+
+  setEyebrowColor(style) {
+    this._setMakeupStyle('fb_set_eyebrow_color', style, 'Failed to set eyebrow style');
+  }
+
+  setEyelash(value) {
+    this._ensureInitialized();
+    this._setIntensity('fb_set_eyelash', value);
+  }
+
+  setEyelashStyle(style) {
+    this._setMakeupStyle('fb_set_eyelash_style', style, 'Failed to set eyelash style');
+  }
+
+  setEyelashColor(style) {
+    this._setMakeupStyle('fb_set_eyelash_color', style, 'Failed to set eyelash style');
+  }
+
+  setPupil(value) {
+    this._ensureInitialized();
+    this._setIntensity('fb_set_pupil', value);
+  }
+
+  setPupilColor(style) {
+    this._setMakeupStyle('fb_set_pupil_color', style, 'Failed to set pupil style');
   }
 
   /**
-   * Sets a LUT-based filter
-   * @param {string} filterId - Unique identifier of the filter (e.g., "chuxin"). Pass "" to clear.
+   * Uses chroma keying as the virtual-background mask.
+   * Fill is still controlled by setVirtualBackgroundBlur / setVirtualBackground.
+   * @param {number} color - Key colour (use ChromaKeyColor enum)
    */
-  setFilter(filterId) {
-    this._ensureInitialized();
-    const Module = this._getWasmModule();
-    const result = Module.ccall(
-      'SetFilter',
-      'number',
-      ['number', 'string'],
-      [this.enginePtr, filterId || '']
-    );
-    checkResult(result, 'Failed to set filter');
+  setChromaKey(color) {
+    this._setMakeupStyle('fb_set_chroma_key', color, 'Failed to set chroma key');
   }
 
   /**
-   * Sets the intensity of the current filter
-   * @param {number} intensity - Filter intensity (0.0 - 1.0)
+   * Turns off chroma keying and restores portrait-segmentation as the mask.
    */
-  setFilterIntensity(intensity) {
+  clearChromaKey() {
     this._ensureInitialized();
     const Module = this._getWasmModule();
     const result = Module.ccall(
-      'SetFilterIntensity',
+      'fb_clear_chroma_key',
       'number',
-      ['number', 'number'],
-      [this.enginePtr, intensity]
+      ['number'],
+      [this.enginePtr]
     );
-    checkResult(result, 'Failed to set filter intensity');
+    checkResult(result, 'Failed to clear chroma key');
   }
 
-  /**
-   * Sets a 2D sticker
-   * @param {string} stickerId - Unique identifier of the sticker (e.g., "樱花"). Pass "" to clear.
-   */
-  setSticker(stickerId) {
+  /** How close a pixel must be to the key colour to be keyed out. [0.0, 1.0]. */
+  setChromaKeySimilarity(value) {
+    this._setChromaKeyFloat('fb_set_chroma_key_similarity', value);
+  }
+
+  /** Edge feather around the key. [0.0, 1.0]. */
+  setChromaKeySmoothness(value) {
+    this._setChromaKeyFloat('fb_set_chroma_key_smoothness', value);
+  }
+
+  /** Spill suppression on semi-transparent edges. [0.0, 1.0]. */
+  setChromaKeyDesaturation(value) {
+    this._setChromaKeyFloat('fb_set_chroma_key_desaturation', value);
+  }
+
+  _setChromaKeyFloat(cFuncName, value) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
     const result = Module.ccall(
-      'SetSticker',
+      cFuncName,
       'number',
-      ['number', 'string'],
-      [this.enginePtr, stickerId || '']
+      ['number', 'number'],
+      [this.enginePtr, value]
     );
-    checkResult(result, 'Failed to set sticker');
+    checkResult(result, `Failed to call ${cFuncName}`);
   }
 
   /**
-   * Registers a filter from a file path or data
-   * @param {string} filterId - Unique identifier for the filter
-   * @param {string|Uint8Array} resource - Path to .fbd file or Uint8Array data
+   * Applies a LUT filter from a file path or in-memory .fbd data.
+   * @param {string|Uint8Array} resource - Path to .fbd file or Uint8Array data.
    */
-  registerFilter(filterId, resource) {
+  setFilter(resource) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
 
     if (typeof resource === 'string') {
+      if (!resource) {
+        throw new FacebetterError('Filter path must not be empty; use clearFilter()');
+      }
       const result = Module.ccall(
-        'RegisterFilterPath',
+        'fb_set_filter',
         'number',
-        ['number', 'string', 'string'],
-        [this.enginePtr, filterId, resource]
+        ['number', 'string'],
+        [this.enginePtr, resource]
       );
-      checkResult(result, `Failed to register filter path: ${filterId}`);
-    } else if (resource instanceof Uint8Array) {
+      checkResult(result, 'Failed to set filter from path');
+      return;
+    }
+
+    if (resource instanceof Uint8Array) {
       const dataPtr = Module._malloc(resource.length);
       Module.HEAPU8.set(resource, dataPtr);
       try {
         const result = Module.ccall(
-          'RegisterFilterData',
+          'fb_set_filter_data',
           'number',
-          ['number', 'string', 'number', 'number'],
-          [this.enginePtr, filterId, dataPtr, resource.length]
+          ['number', 'number', 'number'],
+          [this.enginePtr, dataPtr, resource.length]
         );
-        checkResult(result, `Failed to register filter data: ${filterId}`);
+        checkResult(result, 'Failed to set filter from data');
       } finally {
         Module._free(dataPtr);
       }
-    } else {
-      throw new FacebetterError('Resource must be a string path or Uint8Array data');
+      return;
     }
+
+    throw new FacebetterError('Filter resource must be a string path or Uint8Array');
   }
 
   /**
-   * Registers a sticker from a file path or data
-   * @param {string} stickerId - Unique identifier for the sticker
-   * @param {string|Uint8Array} resource - Path to .fbd file or Uint8Array data
+   * Clears the current LUT filter.
    */
-  registerSticker(stickerId, resource) {
+  clearFilter() {
+    this._ensureInitialized();
+    const Module = this._getWasmModule();
+    const result = Module.ccall(
+      'fb_clear_filter',
+      'number',
+      ['number'],
+      [this.enginePtr]
+    );
+    checkResult(result, 'Failed to clear filter');
+  }
+
+  /**
+   * Sets the intensity of the current filter
+   * @param {number} intensity - Filter intensity (0.0 - 1.0)
+   */
+  setFilterIntensity(intensity) {
+    this._ensureInitialized();
+    const Module = this._getWasmModule();
+    const result = Module.ccall(
+      'fb_set_filter_intensity',
+      'number',
+      ['number', 'number'],
+      [this.enginePtr, intensity]
+    );
+    checkResult(result, 'Failed to set filter intensity');
+  }
+
+  /**
+   * Applies a 2D sticker from a file path or in-memory .fbd data.
+   * @param {string|Uint8Array} resource - Path to .fbd file or Uint8Array data.
+   */
+  setSticker(resource) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
 
     if (typeof resource === 'string') {
+      if (!resource) {
+        throw new FacebetterError('Sticker path must not be empty; use clearSticker()');
+      }
       const result = Module.ccall(
-        'RegisterStickerPath',
+        'fb_set_sticker',
         'number',
-        ['number', 'string', 'string'],
-        [this.enginePtr, stickerId, resource]
+        ['number', 'string'],
+        [this.enginePtr, resource]
       );
-      checkResult(result, `Failed to register sticker path: ${stickerId}`);
-    } else if (resource instanceof Uint8Array) {
+      checkResult(result, 'Failed to set sticker from path');
+      return;
+    }
+
+    if (resource instanceof Uint8Array) {
       const dataPtr = Module._malloc(resource.length);
       Module.HEAPU8.set(resource, dataPtr);
       try {
         const result = Module.ccall(
-          'RegisterStickerData',
+          'fb_set_sticker_data',
           'number',
-          ['number', 'string', 'number', 'number'],
-          [this.enginePtr, stickerId, dataPtr, resource.length]
+          ['number', 'number', 'number'],
+          [this.enginePtr, dataPtr, resource.length]
         );
-        checkResult(result, `Failed to register sticker data: ${stickerId}`);
+        checkResult(result, 'Failed to set sticker from data');
       } finally {
         Module._free(dataPtr);
       }
-    } else {
-      throw new FacebetterError('Resource must be a string path or Uint8Array data');
+      return;
     }
+
+    throw new FacebetterError('Sticker resource must be a string path or Uint8Array');
   }
 
   /**
-   * Unregisters a specific filter
-   * @param {string} filterId - Filter ID to unregister
+   * Clears the current 2D sticker.
    */
-  unregisterFilter(filterId) {
+  clearSticker() {
     this._ensureInitialized();
     const Module = this._getWasmModule();
     const result = Module.ccall(
-      'UnregisterFilter',
+      'fb_clear_sticker',
       'number',
-      ['number', 'string'],
-      [this.enginePtr, filterId]
+      ['number'],
+      [this.enginePtr]
     );
-    checkResult(result, `Failed to unregister filter: ${filterId}`);
+    checkResult(result, 'Failed to clear sticker');
   }
 
   /**
-   * Unregisters all filters
+   * Internal method to set a single intensity parameter
+   * @private
    */
-  unregisterAllFilters() {
-    this._ensureInitialized();
+  _setIntensity(functionName, value) {
+    if (value < 0 || value > 1) {
+      throw new FacebetterError('Parameter value must be between 0.0 and 1.0');
+    }
+
     const Module = this._getWasmModule();
     const result = Module.ccall(
-      'UnregisterAllFilters',
+      functionName,
       'number',
-      ['number'],
-      [this.enginePtr]
+      ['number', 'number'],
+      [this.enginePtr, value]
     );
-    checkResult(result, 'Failed to unregister all filters');
+
+    checkResult(result, `Failed to set beauty parameter`);
   }
 
-  /**
-   * Unregisters a specific sticker
-   * @param {string} stickerId - Sticker ID to unregister
-   */
-  unregisterSticker(stickerId) {
+  _setMakeupStyle(cFuncName, value, errorMessage) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
     const result = Module.ccall(
-      'UnregisterSticker',
+      cFuncName,
       'number',
-      ['number', 'string'],
-      [this.enginePtr, stickerId]
+      ['number', 'number'],
+      [this.enginePtr, value]
     );
-    checkResult(result, `Failed to unregister sticker: ${stickerId}`);
+    checkResult(result, errorMessage);
   }
 
   /**
-   * Unregisters all stickers
-   */
-  unregisterAllStickers() {
-     this._ensureInitialized();
-     const Module = this._getWasmModule();
-     const result = Module.ccall(
-       'UnregisterAllStickers',
-       'number',
-       ['number'],
-       [this.enginePtr]
-     );
-     checkResult(result, 'Failed to unregister all stickers');
-   }
- 
-   /**
-    * Gets the list of registered filter IDs
-    * @returns {string[]} Array of registered filter IDs
-    */
-   getRegisteredFilters() {
-     this._ensureInitialized();
-     const Module = this._getWasmModule();
-     const jsonStr = Module.ccall(
-       'GetRegisteredFilters',
-       'string',
-       ['number'],
-       [this.enginePtr]
-     );
-     try {
-       return JSON.parse(jsonStr || '[]');
-     } catch (e) {
-       logError(`Failed to parse registered filters JSON: ${e}`);
-       return [];
-     }
-   }
- 
-   /**
-    * Gets the list of registered sticker IDs
-    * @returns {string[]} Array of registered sticker IDs
-    */
-   getRegisteredStickers() {
-     this._ensureInitialized();
-     const Module = this._getWasmModule();
-     const jsonStr = Module.ccall(
-       'GetRegisteredStickers',
-       'string',
-       ['number'],
-       [this.enginePtr]
-     );
-     try {
-       return JSON.parse(jsonStr || '[]');
-     } catch (e) {
-       logError(`Failed to parse registered stickers JSON: ${e}`);
-       return [];
-     }
-   }
- 
-   /**
-    * Internal method to set beauty parameters
+   * Internal method to set beauty parameters
    * @private
    */
   _setBeautyParam(functionName, param, value) {
-    if (value < 0 || value > 1) {
-      throw new FacebetterError('Parameter value must be between 0.0 and 1.0');
+    if (value < -1 || value > 1) {
+      throw new FacebetterError('Parameter value must be between -1.0 and 1.0');
     }
 
     const Module = this._getWasmModule();
@@ -998,15 +1059,25 @@ class BeautyEffectEngine {
   }
 
   /**
-   * Sets engine callbacks (face landmarks detection)
+   * Sets engine callbacks (face landmarks and engine events)
    * @param {Object} callbacks - Callback functions
-   * @param {Function} callbacks.onFaceLandmarks - Callback for face landmarks detection
+   * @param {Function} [callbacks.onFaceLandmarks] - Callback for face landmarks detection
+   * @param {Function} [callbacks.onEngineEvent] - Callback for license / init events (code, message)
    * @param {number} [callbacks.maxFaces=10] - Maximum number of faces to support (affects shared buffer size)
    */
   setCallbacks(callbacks) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
-    
+
+    if (!Module._engine_event_callbacks) {
+      Module._engine_event_callbacks = {};
+    }
+    if (callbacks && typeof callbacks.onEngineEvent === 'function') {
+      Module._engine_event_callbacks[this.enginePtr] = callbacks.onEngineEvent;
+    } else {
+      delete Module._engine_event_callbacks[this.enginePtr];
+    }
+
     // Initialize callback storage (if it doesn't exist)
     if (!Module._face_landmarks_callbacks) {
       Module._face_landmarks_callbacks = [];
@@ -1022,9 +1093,9 @@ class BeautyEffectEngine {
       
       // Pre-allocate shared memory
       // Metadata: 2 ints (frame_number, face_count) = 8 bytes
-      // Face data: maxFaces * 343 floats * 4 bytes = maxFaces * 1372 bytes
+      // Face data: maxFaces * 342 floats * 4 bytes = maxFaces * 1368 bytes
       const metadataSize = 2 * 4;  // 2 ints
-      const faceDataSize = maxFaces * 343 * 4;  // 343 floats per face
+      const faceDataSize = maxFaces * 342 * 4;  // 342 floats per face
       sharedBufferSize = metadataSize + faceDataSize;
       sharedBufferPtr = Module._malloc(sharedBufferSize);
       
@@ -1041,7 +1112,7 @@ class BeautyEffectEngine {
           const dataOffset = dataPtr / 4;  // float is 4 bytes
           
           const results = [];
-          const FLOATS_PER_FACE = 343;
+          const FLOATS_PER_FACE = 342;
           
           for (let i = 0; i < faceCount; i++) {
             const faceOffset = dataOffset + i * FLOATS_PER_FACE;
@@ -1057,7 +1128,6 @@ class BeautyEffectEngine {
             
             // Read basic fields
             const faceId = Math.round(heap[offset++]);
-            const faceAction = Math.round(heap[offset++]);
             const score = heap[offset++];
             const pitch = heap[offset++];
             const roll = heap[offset++];
@@ -1083,7 +1153,6 @@ class BeautyEffectEngine {
               key_points: keyPoints,
               visibility,
               face_id: faceId,
-              face_action: faceAction,
               score,
               pitch,
               roll,
@@ -1102,7 +1171,7 @@ class BeautyEffectEngine {
     
     // Call C API
     const result = Module.ccall(
-      'SetCallbacks',
+      'fb_engine_set_wasm_callbacks',
       'number',
       ['number', 'number', 'number', 'number'],
       [
@@ -1131,55 +1200,81 @@ class BeautyEffectEngine {
   }
 
   /**
-   * Sets virtual background options (unified API, matches C++/Java/OC)
-   * @param {VirtualBackgroundOptions|Object} options - Virtual background options
-   * @param {number} [options.mode] - Background mode (use BackgroundMode enum)
-   * @param {ImageData|HTMLImageElement|HTMLCanvasElement} [options.backgroundImage] - Background image (required when mode is Image)
+   * Enables virtual background blur.
+   * Level is continuous in [0.0, 1.0] (downsample + mix, no shader rebuild).
+   * @param {number} level - Blur strength in [0.0, 1.0]. 0 clears the virtual background.
    */
-  setVirtualBackground(options) {
+  setVirtualBackgroundBlur(level) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
-    
-    // Support both VirtualBackgroundOptions object and plain object
-    const opts = options.mode !== undefined ? options : { mode: BackgroundMode$1.None, backgroundImage: null };
-    
-    let imageData = null;
-    let imageBufferPtr = null;
-    
-    try {
-      // If a background image is provided, convert to ImageData and prepare buffer
-      if (opts.backgroundImage) {
-        imageData = this._toImageData(opts.backgroundImage);
-        const bufferSize = imageData.width * imageData.height * 4;
-        imageBufferPtr = Module._malloc(bufferSize);
-        
-        const buffer = this._getWasmBuffer();
-        const view = new Uint8Array(buffer, imageBufferPtr, bufferSize);
-        view.set(imageData.data);
+    const result = Module.ccall(
+      'fb_set_virtual_background_blur',
+      'number',
+      ['number', 'number'],
+      [this.enginePtr, level]
+    );
+    checkResult(result, 'Failed to set virtual background blur');
+  }
+
+  /**
+   * Replaces the background with an image file path or encoded png/jpg bytes.
+   * @param {string|Uint8Array} resource - Image path or Uint8Array data.
+   */
+  setVirtualBackground(resource) {
+    this._ensureInitialized();
+    const Module = this._getWasmModule();
+
+    if (typeof resource === 'string') {
+      if (!resource) {
+        throw new FacebetterError(
+          'Virtual background path must not be empty; use clearVirtualBackground()'
+        );
       }
-      
-      // Use unified SetVirtualBackground C interface (consistent with other platforms)
       const result = Module.ccall(
-        'SetVirtualBackground',
+        'fb_set_virtual_background',
         'number',
-        ['number', 'number', 'number', 'number', 'number', 'number'],
-        [
-          this.enginePtr,
-          opts.mode,
-          imageBufferPtr || 0,  // If null, pass 0
-          imageData ? imageData.width : 0,
-          imageData ? imageData.height : 0,
-          imageData ? imageData.width * 4 : 0
-        ]
+        ['number', 'string'],
+        [this.enginePtr, resource]
       );
-      
-      checkResult(result, 'Failed to set virtual background');
-    } finally {
-      // Free memory
-      if (imageBufferPtr) {
-        Module._free(imageBufferPtr);
+      checkResult(result, 'Failed to set virtual background from path');
+      return;
+    }
+
+    if (resource instanceof Uint8Array) {
+      const dataPtr = Module._malloc(resource.length);
+      Module.HEAPU8.set(resource, dataPtr);
+      try {
+        const result = Module.ccall(
+          'fb_set_virtual_background_data',
+          'number',
+          ['number', 'number', 'number'],
+          [this.enginePtr, dataPtr, resource.length]
+        );
+        checkResult(result, 'Failed to set virtual background from data');
+      } finally {
+        Module._free(dataPtr);
       }
+      return;
     }
+
+    throw new FacebetterError(
+      'setVirtualBackground expects a file path string or Uint8Array'
+    );
+  }
+
+  /**
+   * Clears virtual background (blur or image replacement).
+   */
+  clearVirtualBackground() {
+    this._ensureInitialized();
+    const Module = this._getWasmModule();
+    const result = Module.ccall(
+      'fb_clear_virtual_background',
+      'number',
+      ['number'],
+      [this.enginePtr]
+    );
+    checkResult(result, 'Failed to clear virtual background');
   }
 
   /**
@@ -1187,12 +1282,12 @@ class BeautyEffectEngine {
    * When enabled, beauty effects will only be applied to detected skin areas.
    * @param {boolean} enabled - True to enable skin-only beauty, false to apply to entire image.
    */
-  setSkinOnlyBeauty(enabled) {
+  setBeautySkinOnly(enabled) {
     this._ensureInitialized();
     const Module = this._getWasmModule();
 
     const result = Module.ccall(
-      'SetSkinOnlyBeauty',
+      'fb_set_beauty_skin_only',
       'number',
       ['number', 'number'],
       [this.enginePtr, enabled ? 1 : 0]
@@ -1201,6 +1296,35 @@ class BeautyEffectEngine {
     checkResult(result, 'Failed to set skin only beauty');
   }
 
+  /**
+   * Gets engine performance statistics.
+   * @returns {{fps: number, avgProcessTimeMs: number, sessionTimeS: number}}
+   */
+  getStats() {
+    this._ensureInitialized();
+    const Module = this._getWasmModule();
+    const ptr = Module._malloc(24);
+    try {
+      const result = Module.ccall(
+        'fb_engine_get_stats',
+        'number',
+        ['number', 'number'],
+        [this.enginePtr, ptr]
+      );
+      checkResult(result, 'Failed to get stats');
+      if ((ptr & 7) !== 0) {
+        throw new FacebetterError('Unaligned stats buffer');
+      }
+      const base = ptr >> 3;
+      return {
+        fps: Module.HEAPF64[base],
+        avgProcessTimeMs: Module.HEAPF64[base + 1],
+        sessionTimeS: Module.HEAPF64[base + 2]
+      };
+    } finally {
+      Module._free(ptr);
+    }
+  }
 
   /**
    * Ensures buffers are allocated for the given dimensions
@@ -1254,7 +1378,7 @@ class BeautyEffectEngine {
       srcView.set(imageData.data);
 
       const result = Module.ccall(
-        'ProcessImageRGBA',
+        'fb_process_rgba',
         'number',
         ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'],
         [
@@ -1315,7 +1439,7 @@ class BeautyEffectEngine {
 
     try {
       const result = Module.ccall(
-        'ProcessImageTexture',
+        'fb_process_texture',
         'number',
         ['number', 'number', 'number', 'number', 'number', 'number', 'number'],
         [
@@ -1355,37 +1479,37 @@ class BeautyEffectEngine {
   }
 
   /**
-   * Ensures gpupixel_canvas exists in the DOM (browser only)
+   * Ensures facebetter_canvas exists in the DOM (browser only)
    * This canvas is required by GPUPixel for WebGL context creation
    * @private
    */
-  _ensureGPUPixelCanvas() {
+  _ensureFacebetterCanvas() {
     if (typeof document === 'undefined') {
       return;
     }
     
-    let canvas = document.getElementById('gpupixel_canvas');
+    let canvas = document.getElementById('facebetter_canvas');
     if (!canvas) {
       canvas = document.createElement('canvas');
-      canvas.id = 'gpupixel_canvas';
+      canvas.id = 'facebetter_canvas';
       canvas.style.display = 'none';
       canvas.width = 1;
       canvas.height = 1;
       document.body.appendChild(canvas);
-      this._createdGPUPixelCanvas = true;
+      this._createdFacebetterCanvas = true;
     }
-    this._gpupixelCanvas = canvas;
+    this._facebetterCanvas = canvas;
   }
 
   /**
-   * Cleans up gpupixel_canvas if it was created by this engine instance (browser only)
+   * Cleans up facebetter_canvas if it was created by this engine instance (browser only)
    * @private
    */
-  _cleanupGPUPixelCanvas() {
-    if (this._createdGPUPixelCanvas && this._gpupixelCanvas) {
-      this._gpupixelCanvas.remove();
-      this._gpupixelCanvas = null;
-      this._createdGPUPixelCanvas = false;
+  _cleanupFacebetterCanvas() {
+    if (this._createdFacebetterCanvas && this._facebetterCanvas) {
+      this._facebetterCanvas.remove();
+      this._facebetterCanvas = null;
+      this._createdFacebetterCanvas = false;
     }
   }
 
@@ -1414,6 +1538,206 @@ class BeautyEffectEngine {
 
 }
 
+const WASM_FILE = 'facebetter-core.wasm';
+const RESOURCE_FILE = 'resource.fbd';
+const MEMFS_RESOURCE_PATH = '/resource.fbd';
+
+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 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;
+}
+
+/**
+ * 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 fetchBinary(url, onChunk) {
+  if (typeof url === 'string' && url.startsWith('file:')) {
+    return readFileUrl(url, onChunk);
+  }
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new FacebetterError(
+      `Failed to download ${url} (${response.status})`,
+      'WASM_LOAD_ERROR'
+    );
+  }
+
+  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();
+    }),
+    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 './';
+}
+
+/**
+ * Resolve sidecar wasm / resource URLs.
+ * Prefer `assetBaseUrl`, then `facebetter-core/assets`, then the script directory.
+ */
+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;
+}
+
 /**
  * Browser-specific Image Utilities
  * Uses DOM APIs (canvas, ImageData, etc.)
@@ -1470,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;
   }
 
@@ -1493,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;
+        factory = wasmModule.default || wasmModule.createFaceBetterModule;
       }
-      
-      if (!FaceBetterModuleFactory) {
-        throw new Error('WASM module does not export createFaceBetterModule function');
-      }
-    } 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;
@@ -1576,15 +1877,15 @@ function getWasmBuffer() {
 }
 
 // Browser-specific GPU canvas management
-function ensureGPUPixelCanvas() {
+function ensureFacebetterCanvas() {
   if (typeof document === 'undefined') {
     return;
   }
   
-  let canvas = document.getElementById('gpupixel_canvas');
+  let canvas = document.getElementById('facebetter_canvas');
   if (!canvas) {
     canvas = document.createElement('canvas');
-    canvas.id = 'gpupixel_canvas';
+    canvas.id = 'facebetter_canvas';
     canvas.style.display = 'none';
     canvas.width = 1;
     canvas.height = 1;
@@ -1594,18 +1895,18 @@ function ensureGPUPixelCanvas() {
   }
 }
 
-function cleanupGPUPixelCanvas() {
+function cleanupFacebetterCanvas() {
   // Cleanup is handled by engine instance
 }
 
 // Create platform API
 const platformAPI = {
-  loadWasmModule: () => loadWasmModule(),
+  loadWasmModule: (options) => loadWasmModule(options),
   getWasmModule,
   getWasmBuffer,
   toImageData: toImageData,
-  ensureGPUPixelCanvas,
-  cleanupGPUPixelCanvas
+  ensureFacebetterCanvas,
+  cleanupFacebetterCanvas
 };
 
 // Export factory function
@@ -1623,17 +1924,26 @@ class ESMBeautyEffectEngine extends BeautyEffectEngine {
 }
 
 // Export constants with proper names
-const BeautyType = BeautyType$1;
-const BasicParam = BasicParam$1;
-const ReshapeParam = ReshapeParam$1;
-const MakeupParam = MakeupParam$1;
-const LipstickStyle = LipstickStyle$1;
+const WhiteningStyle = WhiteningStyle$1;
+const SmoothingStyle = SmoothingStyle$1;
+const Reshape = Reshape$1;
+const LipstickColor = LipstickColor$1;
 const BlushStyle = BlushStyle$1;
-const ChromaKeyParam = ChromaKeyParam$1;
-const BackgroundMode = BackgroundMode$1;
+const BlushColor = BlushColor$1;
+const ContourStyle = ContourStyle$1;
+const EyeShadowStyle = EyeShadowStyle$1;
+const EyeShadowColor = EyeShadowColor$1;
+const EyeLinerStyle = EyeLinerStyle$1;
+const EyeLinerColor = EyeLinerColor$1;
+const EyebrowStyle = EyebrowStyle$1;
+const EyebrowColor = EyebrowColor$1;
+const EyelashStyle = EyelashStyle$1;
+const EyelashColor = EyelashColor$1;
+const PupilColor = PupilColor$1;
+const ChromaKeyColor = ChromaKeyColor$1;
 const FrameType = FrameType$1;
 const MirrorMode = MirrorMode$1;
-const VirtualBackgroundOptions = VirtualBackgroundOptions$1;
+const EngineEventCode = EngineEventCode$1;
 
 // Default export
 var index = {
@@ -1644,5 +1954,5 @@ var index = {
   loadWasmModule
 };
 
-export { BackgroundMode, BasicParam, ESMBeautyEffectEngine as BeautyEffectEngine, BeautyType, BlushStyle, ChromaKeyParam, EngineConfig, FacebetterError, FrameType, LipstickStyle, MakeupParam, MirrorMode, ReshapeParam, VirtualBackgroundOptions, createBeautyEffectEngine, index as default, getWasmBuffer, getWasmModule, loadWasmModule };
+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