ttmg-wasm-tool 1.0.2 → 1.0.4

package/README.md

@@ -1,11 +1,11 @@
-# @aspect/wasm-tool-node
+# ttmg-wasm-tool
 
 Native Node.js module for WASM preparation and splitting. Supports macOS and Windows.
 
 ## Installation
 
 ```bash
-npm install @aspect/wasm-tool-node
+npm install ttmg-wasm-tool
 ```
 
 This will automatically compile the native module during installation.
@@ -22,10 +22,8 @@ This will automatically compile the native module during installation.
 
 ### prepareWasm(wasmBuffer: Buffer): PrepareResult
 
-Prepare a WASM module by inserting `scwebgl.logCall` instrumentation at the beginning of each function.
-
 ```typescript
-import { prepareWasm } from '@aspect/wasm-tool-node';
+import { prepareWasm } from 'ttmg-wasm-tool';
 import { readFileSync, writeFileSync } from 'fs';
 
 const wasm = readFileSync('input.wasm');
@@ -98,50 +96,3 @@ interface SplitResult {
   subWasmBuffer?: Buffer;
 }
 ```
-
-## Split Rules
-
-The WASM splitting follows these rules:
-
-1. All import functions and element segment functions go to the main package
-2. Functions directly called from main package that don't exist create stub functions with `scwebgl.wait` calls
-3. Sub package contains all functions not in the main package
-4. Sub package functions get `scwebgl.logCall` instrumentation
-5. Non-import global variables are converted to imports for sharing between packages
-
-## Building from Source
-
-```bash
-# Install dependencies
-npm install
-
-# Build (Release)
-npm run build
-
-# Build (Debug)
-npm run build:debug
-
-# Clean build artifacts
-npm run clean
-
-# Rebuild
-npm run rebuild
-```
-
-## Pre-built Binaries
-
-To create pre-built binaries for distribution:
-
-```bash
-# Current platform
-npm run prebuild
-
-# Specific platforms
-npm run prebuild:win32
-npm run prebuild:darwin
-npm run prebuild:darwin-arm64
-```
-
-## License
-
-MIT

package/index.d.ts

@@ -40,6 +40,44 @@ export interface SplitResult {
   subWasmBuffer?: Buffer;
 }
 
+/**
+ * Result of splitWasmH5 operation for H5/web platform
+ * 
+ * This is the complete H5 WASM splitting result with wasm2js conversion done natively.
+ * The returned artifacts can be directly used by the H5 runtime.
+ * 
+ * Files:
+ *   - mainWasmBuffer → split_main_h5.wasm
+ *   - subElemJsonBuffer → sub_elem_range.json ({"funcName":[start,end],...})
+ *   - mergedJsBuffer → subjs.data (all function JS concatenated)
+ */
+export interface SplitH5Result {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** Total number of functions in original WASM */
+  totalFuncCount?: number;
+  /** Number of functions in main package */
+  mainFuncCount?: number;
+  /** Number of functions in sub package */
+  subFuncCount?: number;
+  /** Table size after split */
+  tableSize?: number;
+  /** Global variable list info */
+  globalVarList?: string;
+  /** Main package WASM buffer (split_main_h5.wasm) */
+  mainWasmBuffer?: Buffer;
+  /** Merged JS buffer (subjs.data) - all function JS concatenated, use subElemJson offsets to extract */
+  mergedJsBuffer?: Buffer;
+  /** Sub element range JSON buffer - {"funcName":[start,end],...} */
+  subElemJsonBuffer?: Buffer;
+  /** Sub element range JSON string - {"funcName":[start,end],...} */
+  subElemJson?: string;
+  /** Array of function names in the sub package */
+  functionNames?: string[];
+}
+
 /**
  * Prepare a WASM module by inserting logCall instrumentation
  * This inserts a call to scwebgl.logCall at the beginning of each function
@@ -97,3 +135,262 @@ export function prepareWasm(wasmBuffer: Buffer): PrepareResult;
  * ```
  */
 export function splitWasm(wasmBuffer: Buffer, funcIdList?: string): SplitResult;
+
+/**
+ * Split a WASM module for H5/web platform
+ * 
+ * This is specifically designed for the H5 WASM splitting workflow where:
+ * 1. Main WASM (split_main_h5.wasm) is used directly
+ * 2. Sub WASM is converted to JavaScript via wasm2js (merged_js)
+ * 3. sub_elem.json maps table indices to function names for the JS runtime
+ * 
+ * The sub package WASM needs to be processed with Binaryen's wasm2js tool
+ * to create the merged_js output.
+ * 
+ * @param wasmBuffer - The input WASM binary buffer
+ * @param funcIdList - Optional newline-separated list of function IDs to include in main package
+ * @returns SplitH5Result containing main WASM, sub WASM, and sub_elem.json
+ * 
+ * @example
+ * ```typescript
+ * import { splitWasmH5 } from '@aspect/wasm-tool-node';
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { execSync } from 'child_process';
+ * 
+ * const wasm = readFileSync('input.wasm');
+ * const result = splitWasmH5(wasm);
+ * 
+ * if (result.success) {
+ *   // Save main WASM
+ *   writeFileSync('split_main_h5.wasm', result.mainWasmBuffer!);
+ *   
+ *   // Save sub_elem.json
+ *   writeFileSync('split_main_h5.wasm.sub_elem.json', result.subElemJsonBuffer!);
+ *   
+ *   // Save sub WASM for wasm2js conversion
+ *   writeFileSync('sub.wasm', result.subWasmBuffer!);
+ *   
+ *   // Convert sub WASM to JS using Binaryen's wasm2js
+ *   // execSync('wasm2js sub.wasm -o merged_js');
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+export function splitWasmH5(wasmBuffer: Buffer, funcIdList?: string): SplitH5Result;
+
+/**
+ * Result of wasm2js operation
+ */
+export interface Wasm2JsResult {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** The generated JavaScript code */
+  jsCode?: string;
+  /** The generated JavaScript code as a Buffer */
+  jsBuffer?: Buffer;
+}
+
+/**
+ * Options for wasm2js conversion
+ */
+export interface Wasm2JsOptions {
+  /** Path to wasm2js binary (defaults to 'wasm2js' in PATH, only used if native not available) */
+  wasm2jsPath?: string;
+  /** Whether to optimize the output JS */
+  optimize?: boolean;
+  /** Enable mutable globals support (external binary only) */
+  enableMutableGlobals?: boolean;
+}
+
+/**
+ * Individual function JS output
+ */
+export interface FunctionJs {
+  /** Function name */
+  name: string;
+  /** Generated JavaScript code for this function */
+  js: string;
+}
+
+/**
+ * Result of wasm2jsFunctions operation
+ */
+export interface Wasm2JsFunctionsResult {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** The full module JavaScript code */
+  fullJs?: string;
+  /** Individual function JavaScript code */
+  functions?: FunctionJs[];
+}
+
+/**
+ * Check if native Binaryen wasm2js support is available
+ * 
+ * When native support is available, wasm2js operations are performed
+ * entirely within the native module without needing external binaries.
+ * 
+ * @returns True if native Binaryen support is compiled in
+ */
+export function hasBinaryenSupport(): boolean;
+
+/**
+ * Convert WASM to JavaScript using Binaryen's wasm2js
+ * 
+ * If the module was built with WITH_BINARYEN=ON, this uses the native
+ * implementation which is faster and doesn't require external binaries.
+ * Otherwise, it falls back to calling the wasm2js binary from PATH.
+ * 
+ * @param wasmBuffer - The input WASM binary buffer
+ * @param options - Options for wasm2js
+ * @returns Result containing the JavaScript code
+ * 
+ * @example
+ * ```typescript
+ * import { wasm2js, hasBinaryenSupport } from '@aspect/wasm-tool-node';
+ * import { readFileSync, writeFileSync } from 'fs';
+ * 
+ * console.log('Native Binaryen:', hasBinaryenSupport() ? 'Yes' : 'No');
+ * 
+ * const wasm = readFileSync('module.wasm');
+ * const result = wasm2js(wasm, { optimize: true });
+ * 
+ * if (result.success) {
+ *   writeFileSync('module.js', result.jsCode!);
+ * }
+ * ```
+ */
+export function wasm2js(wasmBuffer: Buffer, options?: Wasm2JsOptions): Wasm2JsResult;
+
+/**
+ * Convert WASM to JavaScript with individual function output
+ * 
+ * This allows extracting each function's JavaScript separately,
+ * which is useful for lazy loading or code splitting.
+ * 
+ * Note: This function requires native Binaryen support.
+ * Check hasBinaryenSupport() before calling.
+ * 
+ * @param wasmBuffer - The input WASM binary buffer
+ * @param options - Options for wasm2js
+ * @returns Result containing full JS and individual function JS
+ * 
+ * @example
+ * ```typescript
+ * import { wasm2jsFunctions, hasBinaryenSupport } from '@aspect/wasm-tool-node';
+ * import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+ * 
+ * if (!hasBinaryenSupport()) {
+ *   console.error('This feature requires native Binaryen support');
+ *   process.exit(1);
+ * }
+ * 
+ * const wasm = readFileSync('module.wasm');
+ * const result = wasm2jsFunctions(wasm);
+ * 
+ * if (result.success) {
+ *   mkdirSync('functions', { recursive: true });
+ *   result.functions!.forEach((f, i) => {
+ *     const filename = f.name || `func_${i}`;
+ *     writeFileSync(`functions/${filename}.js`, f.js);
+ *   });
+ * }
+ * ```
+ */
+export function wasm2jsFunctions(wasmBuffer: Buffer, options?: Wasm2JsOptions): Wasm2JsFunctionsResult;
+
+/**
+ * Complete result of splitWasmH5Full operation
+ * 
+ * Final H5 artifacts:
+ * - split_main_h5.wasm (mainWasmBuffer)
+ * - split_main_h5.wasm.sub_elem.json (subElemJsonBuffer)
+ * - sub.data / merged_js (subDataBuffer) - concatenated JS code
+ */
+export interface SplitH5FullResult {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Error message if operation failed */
+  error?: string;
+  /** Total number of functions in original WASM */
+  totalFuncCount?: number;
+  /** Number of functions in main package */
+  mainFuncCount?: number;
+  /** Number of functions in sub package */
+  subFuncCount?: number;
+  /** Table size after split */
+  tableSize?: number;
+  /** Global variable list info */
+  globalVarList?: string;
+  
+  // === Final H5 artifacts ===
+  
+  /** Main package WASM buffer (split_main_h5.wasm) */
+  mainWasmBuffer?: Buffer;
+  /** Sub element JSON buffer (split_main_h5.wasm.sub_elem.json) */
+  subElemJsonBuffer?: Buffer;
+  /** Sub element JSON string */
+  subElemJson?: string;
+  /** Sub package data buffer (sub.data / merged_js) - JS code from wasm2js */
+  subDataBuffer?: Buffer;
+  /** Sub package JS code string */
+  subDataJs?: string;
+  
+  // === Aliases for backward compatibility ===
+  
+  /** @deprecated Use subDataBuffer instead */
+  mergedJsBuffer?: Buffer;
+  /** @deprecated Use subDataJs instead */
+  mergedJs?: string;
+}
+
+/**
+ * Options for splitWasmH5Full
+ */
+export interface SplitH5FullOptions {
+  /** Newline-separated list of function IDs for main package */
+  funcIdList?: string;
+  /** Path to wasm2js binary */
+  wasm2jsPath?: string;
+  /** Whether to optimize the JS output */
+  optimize?: boolean;
+}
+
+/**
+ * Complete H5 WASM split workflow
+ * 
+ * This performs the complete H5 split workflow:
+ * 1. Split WASM into main and sub packages
+ * 2. Convert sub WASM to JavaScript using wasm2js
+ * 3. Return all artifacts as buffers
+ * 
+ * Requires Binaryen's wasm2js tool to be installed
+ * 
+ * @param wasmBuffer - The input WASM binary buffer
+ * @param options - Options for the split operation
+ * @returns Complete H5 split result with all artifacts
+ * 
+ * @example
+ * ```typescript
+ * import { splitWasmH5Full } from '@aspect/wasm-tool-node';
+ * import { readFileSync, writeFileSync } from 'fs';
+ * 
+ * const wasm = readFileSync('input.wasm');
+ * const result = splitWasmH5Full(wasm, {
+ *   wasm2jsPath: '/path/to/wasm2js',
+ *   optimize: true
+ * });
+ * 
+ * if (result.success) {
+ *   writeFileSync('split_main_h5.wasm', result.mainWasmBuffer!);
+ *   writeFileSync('split_main_h5.wasm.sub_elem.json', result.subElemJsonBuffer!);
+ *   writeFileSync('merged_js', result.mergedJsBuffer!);
+ * }
+ * ```
+ */
+export function splitWasmH5Full(wasmBuffer: Buffer, options?: SplitH5FullOptions): SplitH5FullResult;

package/index.js

@@ -6,6 +6,8 @@
 
 const path = require('path');
 const os = require('os');
+const fs = require('fs');
+const { execSync, spawnSync } = require('child_process');
 
 // Determine the correct binary path based on platform
 function getBindingPath() {
@@ -98,7 +100,350 @@ function splitWasm(wasmBuffer, funcIdList) {
   return binding.splitWasm(wasmBuffer, funcIdList || '');
 }
 
+/**
+ * Split a WASM module for H5/web platform (complete workflow)
+ * 
+ * This function performs the complete H5 split workflow in native code:
+ * 1. Split WASM into main and sub packages
+ * 2. Convert sub WASM to JavaScript using native wasm2js
+ * 3. Concatenate all function JS into a single buffer
+ * 4. Generate sub_elem_range.json with function name to [start, end] offset mapping
+ * 
+ * Returns:
+ *   - mainWasmBuffer: split_main_h5.wasm
+ *   - mergedJsBuffer: subjs.data (all function JS concatenated)
+ *   - subElemJsonBuffer: sub_elem_range.json ({"funcName":[start,end],...})
+ * 
+ * @param {Buffer} wasmBuffer - The input WASM binary buffer
+ * @param {string} [funcIdList] - Optional newline-separated list of function IDs for main package
+ * @returns {import('./index').SplitH5Result} Result containing H5-specific split outputs
+ * 
+ * @example
+ * ```javascript
+ * const result = splitWasmH5(wasmBuffer);
+ * if (result.success) {
+ *   // Save files
+ *   fs.writeFileSync('split_main_h5.wasm', result.mainWasmBuffer);
+ *   fs.writeFileSync('sub_elem_range.json', result.subElemJsonBuffer);
+ *   fs.writeFileSync('subjs.data', result.mergedJsBuffer);
+ *   
+ *   // Runtime: extract specific function from merged buffer
+ *   const subElem = JSON.parse(result.subElemJson);
+ *   const [start, end] = subElem['f8'];
+ *   const funcJs = result.mergedJsBuffer.slice(start, end + 1).toString('utf8');
+ * }
+ * ```
+ */
+function splitWasmH5(wasmBuffer, funcIdList) {
+  if (!Buffer.isBuffer(wasmBuffer)) {
+    return {
+      success: false,
+      error: 'Input must be a Buffer'
+    };
+  }
+  
+  if (wasmBuffer.length === 0) {
+    return {
+      success: false,
+      error: 'Empty buffer provided'
+    };
+  }
+  
+  if (funcIdList !== undefined && typeof funcIdList !== 'string') {
+    return {
+      success: false,
+      error: 'funcIdList must be a string if provided'
+    };
+  }
+  
+  return binding.splitWasmH5(wasmBuffer, funcIdList || '');
+}
+
+/**
+ * Check if native Binaryen wasm2js support is available
+ * @returns {boolean} True if native wasm2js is available
+ */
+function hasBinaryenSupport() {
+  return binding.hasBinaryenSupport === true;
+}
+
+/**
+ * Convert WASM to JavaScript using Binaryen's wasm2js
+ * 
+ * If WITH_BINARYEN is enabled at build time, this uses the native implementation.
+ * Otherwise, it falls back to calling the wasm2js binary (must be in PATH).
+ * 
+ * @param {Buffer} wasmBuffer - The input WASM binary buffer
+ * @param {Object} [options] - Options for wasm2js
+ * @param {string} [options.wasm2jsPath] - Path to wasm2js binary (only used if native not available)
+ * @param {boolean} [options.optimize] - Whether to optimize the output JS
+ * @param {boolean} [options.enableMutableGlobals] - Enable mutable globals support (external binary only)
+ * @returns {{success: boolean, error?: string, jsCode?: string, jsBuffer?: Buffer}} Result containing JS code
+ */
+function wasm2js(wasmBuffer, options = {}) {
+  if (!Buffer.isBuffer(wasmBuffer)) {
+    return {
+      success: false,
+      error: 'Input must be a Buffer'
+    };
+  }
+  
+  if (wasmBuffer.length === 0) {
+    return {
+      success: false,
+      error: 'Empty buffer provided'
+    };
+  }
+  
+  // Try native implementation first
+  if (binding.hasBinaryenSupport && binding.wasm2jsNative) {
+    const result = binding.wasm2jsNative(wasmBuffer, options.optimize || false);
+    return result;
+  }
+  
+  // Fall back to external binary
+  return wasm2jsExternal(wasmBuffer, options);
+}
+
+/**
+ * Convert WASM to JavaScript using external wasm2js binary
+ * @private
+ */
+function wasm2jsExternal(wasmBuffer, options = {}) {
+  const wasm2jsPath = options.wasm2jsPath || 'wasm2js';
+  
+  // Create a temp file for the WASM input
+  const tmpDir = os.tmpdir();
+  const tmpWasmFile = path.join(tmpDir, `wasm2js_input_${Date.now()}_${Math.random().toString(36).slice(2)}.wasm`);
+  
+  try {
+    // Write WASM to temp file
+    fs.writeFileSync(tmpWasmFile, wasmBuffer);
+    
+    // Build wasm2js command
+    const args = [tmpWasmFile];
+    
+    // Enable mutable globals by default (our split WASM uses them)
+    if (options.enableMutableGlobals !== false) {
+      args.push('--enable-mutable-globals');
+    }
+    
+    if (options.optimize) {
+      args.push('-O');
+    }
+    
+    // Execute wasm2js
+    const result = spawnSync(wasm2jsPath, args, {
+      encoding: 'utf8',
+      maxBuffer: 100 * 1024 * 1024, // 100MB buffer for large JS output
+    });
+    
+    if (result.error) {
+      return {
+        success: false,
+        error: `Failed to execute wasm2js: ${result.error.message}. Make sure Binaryen's wasm2js is installed and in PATH.`
+      };
+    }
+    
+    if (result.status !== 0) {
+      return {
+        success: false,
+        error: `wasm2js failed with exit code ${result.status}: ${result.stderr || result.stdout}`
+      };
+    }
+    
+    return {
+      success: true,
+      jsCode: result.stdout,
+      jsBuffer: Buffer.from(result.stdout, 'utf8')
+    };
+  } finally {
+    // Clean up temp file
+    try {
+      fs.unlinkSync(tmpWasmFile);
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+/**
+ * Convert WASM to JavaScript with individual function output
+ * Only available when native Binaryen support is enabled
+ * 
+ * @param {Buffer} wasmBuffer - The input WASM binary buffer
+ * @param {Object} [options] - Options
+ * @param {boolean} [options.optimize] - Whether to optimize the output JS
+ * @returns {{success: boolean, error?: string, fullJs?: string, functions?: Array<{name: string, js: string}>}}
+ */
+function wasm2jsFunctions(wasmBuffer, options = {}) {
+  if (!Buffer.isBuffer(wasmBuffer)) {
+    return {
+      success: false,
+      error: 'Input must be a Buffer'
+    };
+  }
+  
+  if (wasmBuffer.length === 0) {
+    return {
+      success: false,
+      error: 'Empty buffer provided'
+    };
+  }
+  
+  if (!binding.hasBinaryenSupport || !binding.wasm2jsFunctions) {
+    return {
+      success: false,
+      error: 'wasm2jsFunctions requires native Binaryen support. Build with WITH_BINARYEN=ON'
+    };
+  }
+  
+  return binding.wasm2jsFunctions(wasmBuffer, options.optimize || false);
+}
+
+/**
+ * Complete H5 WASM split workflow - splits WASM and converts sub package to JS
+ * 
+ * This is the complete workflow for H5 WASM splitting:
+ * 1. Split WASM into main and sub WASM (intermediate)
+ * 2. Convert sub WASM to JavaScript using wasm2js (per-function)
+ * 3. Concatenate all function JS into a single buffer
+ * 4. Generate sub_elem.json with function name -> [start, end] offset mapping
+ * 
+ * Final H5 artifacts:
+ *   - split_main_h5.wasm (mainWasmBuffer)
+ *   - split_main_h5.wasm.sub_elem.json (subElemJsonBuffer) - format: {"f10000":[0,175],"f10001":[176,4638],...}
+ *   - merged_js (mergedJsBuffer) - all function JS concatenated
+ * 
+ * @param {Buffer} wasmBuffer - The input WASM binary buffer
+ * @param {Object} [options] - Options
+ * @param {string} [options.funcIdList] - Newline-separated list of function IDs for main package
+ * @param {string} [options.wasm2jsPath] - Path to wasm2js binary (fallback if no native support)
+ * @param {boolean} [options.optimize] - Whether to optimize the JS output
+ * @returns {import('./index').SplitH5FullResult} Complete H5 split result
+ */
+function splitWasmH5Full(wasmBuffer, options = {}) {
+  // First, perform the split (creates intermediate sub.wasm)
+  const h5Result = splitWasmH5(wasmBuffer, options.funcIdList);
+  
+  if (!h5Result.success) {
+    return {
+      success: false,
+      error: h5Result.error
+    };
+  }
+  
+  // Check if we have native Binaryen support for per-function extraction
+  if (!binding.hasBinaryenSupport || !binding.wasm2jsFunctions) {
+    // Fallback: use full wasm2js (won't have per-function offsets)
+    const jsResult = wasm2js(h5Result.subWasmBuffer, {
+      wasm2jsPath: options.wasm2jsPath,
+      optimize: options.optimize
+    });
+    
+    if (!jsResult.success) {
+      return {
+        success: false,
+        error: `WASM split succeeded but wasm2js conversion failed: ${jsResult.error}`,
+        mainWasmBuffer: h5Result.mainWasmBuffer,
+        totalFuncCount: h5Result.totalFuncCount,
+        mainFuncCount: h5Result.mainFuncCount,
+        subFuncCount: h5Result.subFuncCount,
+        tableSize: h5Result.tableSize,
+        globalVarList: h5Result.globalVarList
+      };
+    }
+    
+    // Return without per-function sub_elem.json (use original format)
+    const subDataBuffer = Buffer.from(jsResult.jsCode, 'utf8');
+    return {
+      success: true,
+      mainWasmBuffer: h5Result.mainWasmBuffer,
+      subElemJsonBuffer: h5Result.subElemJsonBuffer,
+      subElemJson: h5Result.subElemJson,
+      mergedJsBuffer: subDataBuffer,
+      mergedJs: jsResult.jsCode,
+      totalFuncCount: h5Result.totalFuncCount,
+      mainFuncCount: h5Result.mainFuncCount,
+      subFuncCount: h5Result.subFuncCount,
+      tableSize: h5Result.tableSize,
+      globalVarList: h5Result.globalVarList
+    };
+  }
+  
+  // Use native per-function wasm2js
+  const funcsResult = wasm2jsFunctions(h5Result.subWasmBuffer, { optimize: options.optimize });
+  
+  if (!funcsResult.success) {
+    return {
+      success: false,
+      error: `WASM split succeeded but wasm2js conversion failed: ${funcsResult.error}`,
+      mainWasmBuffer: h5Result.mainWasmBuffer,
+      totalFuncCount: h5Result.totalFuncCount,
+      mainFuncCount: h5Result.mainFuncCount,
+      subFuncCount: h5Result.subFuncCount,
+      tableSize: h5Result.tableSize,
+      globalVarList: h5Result.globalVarList
+    };
+  }
+  
+  // Parse the original sub_elem.json to get function names
+  const originalSubElem = JSON.parse(h5Result.subElemJson);
+  
+  // Concatenate all function JS and build offset mapping
+  // Format: {"f10000": [start, end], "f10001": [start, end], ...}
+  const subElemMapping = {};
+  const jsChunks = [];
+  let currentOffset = 0;
+  
+  funcsResult.functions.forEach((func, idx) => {
+    const jsBuffer = Buffer.from(func.js, 'utf8');
+    const startOffset = currentOffset;
+    const endOffset = currentOffset + jsBuffer.length - 1;
+    
+    // Use original function name from sub_elem if available, otherwise use index-based name
+    const funcName = originalSubElem[idx] || `f${idx}`;
+    // Remove $ prefix if present for cleaner keys
+    const cleanName = funcName.startsWith('$') ? funcName.slice(1) : funcName;
+    
+    subElemMapping[cleanName] = [startOffset, endOffset];
+    jsChunks.push(jsBuffer);
+    currentOffset = endOffset + 1;
+  });
+  
+  // Concatenate all JS buffers
+  const mergedJsBuffer = Buffer.concat(jsChunks);
+  
+  // Create new sub_elem.json with offset mapping
+  const subElemJson = JSON.stringify(subElemMapping);
+  const subElemJsonBuffer = Buffer.from(subElemJson, 'utf8');
+  
+  return {
+    success: true,
+    // Final H5 artifacts
+    mainWasmBuffer: h5Result.mainWasmBuffer,           // split_main_h5.wasm
+    subElemJsonBuffer: subElemJsonBuffer,              // split_main_h5.wasm.sub_elem.json (new format)
+    subElemJson: subElemJson,
+    mergedJsBuffer: mergedJsBuffer,                    // merged_js (concatenated function JS)
+    mergedJs: mergedJsBuffer.toString('utf8'),
+    // Metadata
+    totalFuncCount: h5Result.totalFuncCount,
+    mainFuncCount: h5Result.mainFuncCount,
+    subFuncCount: h5Result.subFuncCount,
+    tableSize: h5Result.tableSize,
+    globalVarList: h5Result.globalVarList,
+    // Additional info
+    functionCount: funcsResult.functions.length,
+    functionNames: Object.keys(subElemMapping)
+  };
+}
+
 module.exports = {
   prepareWasm,
-  splitWasm
+  splitWasm,
+  splitWasmH5,
+  wasm2js,
+  wasm2jsFunctions,
+  splitWasmH5Full,
+  hasBinaryenSupport
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ttmg-wasm-tool",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Native Node.js module for WASM preparation and splitting",
   "main": "index.js",
   "types": "index.d.ts",