wasm-bindgen-lite 0.3.1 → 0.3.3

package/src/cli/build.js

@@ -11,16 +11,47 @@ function exec(cmd, options = {}) {
   }
 }
 
-function runCargoBuild({ crateDir, release, simd }) {
+function resolveTargetDir(crateDir) {
+  try {
+    const raw = execSync('cargo metadata --format-version 1 --no-deps', {
+      cwd: crateDir,
+      stdio: ['ignore', 'pipe', 'inherit'],
+    }).toString()
+    const meta = JSON.parse(raw)
+    if (meta?.target_directory) return meta.target_directory
+  } catch {
+    console.warn(
+      'Warning: failed to read cargo metadata, defaulting to local target dir'
+    )
+  }
+  return join(crateDir, 'target')
+}
+
+function runCargoBuild({ crateDir, release, simd, targetDir, features }) {
   const args = ['build', '--target', 'wasm32-unknown-unknown']
   if (release) args.push('--release')
+  if (features) {
+    args.push('--features', features)
+  }
 
   const env = { ...process.env }
+
+  if (release) {
+    // Explicitly force opt-level 3 for fastest execution
+    env.CARGO_PROFILE_RELEASE_OPT_LEVEL = '3'
+    env.CARGO_PROFILE_RELEASE_PANIC = 'abort'
+    env.CARGO_PROFILE_RELEASE_CODEGEN_UNITS = '1'
+    env.CARGO_PROFILE_RELEASE_LTO = 'fat'
+  }
+
   if (simd) {
-    const base = process.env.RUSTFLAGS || ''
+    const base = env.RUSTFLAGS || ''
     const extra = '-C target-feature=+simd128'
     env.RUSTFLAGS = [base, extra].filter(Boolean).join(' ').trim()
   }
+  if (targetDir) {
+    env.CARGO_TARGET_DIR = targetDir
+  }
 
   exec(`cargo ${args.join(' ')}`, {
     cwd: crateDir,
@@ -28,18 +59,17 @@ function runCargoBuild({ crateDir, release, simd }) {
   })
 }
 
-function wasmPath({ crateDir, release, wasmFileStem }) {
+function wasmPath({ targetDir, release, wasmFileStem }) {
   const profile = release ? 'release' : 'debug'
   return join(
-    crateDir,
-    'target',
+    targetDir,
     'wasm32-unknown-unknown',
     profile,
     `${wasmFileStem}.wasm`
   )
 }
 
-function maybeRunWasmOpt(wasmFile, wasmOpt) {
+function maybeRunWasmOpt(wasmFile, wasmOpt, release) {
   if (wasmOpt.mode === 'off') return
   if (wasmOpt.mode === 'auto') {
     try {
@@ -49,7 +79,24 @@ function maybeRunWasmOpt(wasmFile, wasmOpt) {
     }
   }
 
-  const args = ['wasm-opt', ...wasmOpt.args, wasmFile, '-o', wasmFile]
+  const args = ['wasm-opt']
+
+  if (release) {
+    // Only strip metadata and debug info for fastest performance
+    args.push('--strip-debug')
+    args.push('--strip-producers')
+    args.push('--strip-target-features')
+    
+    // We EXPLICITLY avoid -O passes here to maintain absolute fastest speed
+    // unless the user provided specific args
+    if (wasmOpt.args.length > 0) {
+      args.push(...wasmOpt.args)
+    }
+  } else {
+    args.push(...wasmOpt.args)
+  }
+
+  args.push(wasmFile, '-o', wasmFile)
   exec(args.join(' '))
 }
 
@@ -62,6 +109,7 @@ export function buildArtifacts({
   release,
   wasmOpt,
 }) {
+  const targetDir = resolveTargetDir(crateDir)
   mkdirSync(outDir, { recursive: true })
   const wasmOutDir = join(outDir, 'wasm')
   mkdirSync(wasmOutDir, { recursive: true })
@@ -72,9 +120,13 @@ export function buildArtifacts({
     const label = isSimd ? 'SIMD' : 'baseline'
     console.log(`Building ${label} wasm...`)
 
-    runCargoBuild({ crateDir, release, simd: isSimd })
+    const simdFeatures = isSimd ? targets.simdFeatures : null
+    const baselineFeatures = !isSimd ? targets.baselineFeatures : null
+    const features = simdFeatures || baselineFeatures
+
+    runCargoBuild({ crateDir, release, simd: isSimd, targetDir, features })
 
-    const built = wasmPath({ crateDir, release, wasmFileStem })
+    const built = wasmPath({ targetDir, release, wasmFileStem })
     const dest = join(wasmOutDir, `${artifactBaseName}.${suffix}.wasm`)
 
     copyFileSync(built, dest)

package/src/cli/config.js

@@ -21,7 +21,7 @@ const DEFAULT_CONFIG = {
       inline: true,
       types: true,
     },
-    custom: null, // path to custom JS file to include and re-export
+    custom: null, // path to custom JS/TS file to include and re-export
   },
   exports: [
     {
@@ -138,6 +138,8 @@ export function loadConfigFromCli(cliOpts = {}) {
         typeof cliOpts.simd === 'boolean'
           ? cliOpts.simd
           : (fileConfig.targets?.simd ?? DEFAULT_CONFIG.targets.simd),
+      simdFeatures: fileConfig.targets?.simdFeatures ?? null,
+      baselineFeatures: fileConfig.targets?.baselineFeatures ?? null,
     },
 
     inline:
@@ -182,6 +184,12 @@ export function loadConfigFromCli(cliOpts = {}) {
       version:
         fileConfig.wasmDelivery?.version ?? fileConfig.version ?? 'latest',
     },
+
+    // SIMD variant configuration
+    simd: fileConfig.simd ?? null,
+
+    // Benchmark configuration
+    bench: fileConfig.bench ?? null,
   }
 
   return config

package/src/cli/emit.js

@@ -1,8 +1,11 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
+import { join, extname } from 'node:path'
+import { createRequire } from 'node:module'
 import { fileURLToPath } from 'node:url'
 
 const UTIL_PATH = fileURLToPath(new URL('../js/util.js', import.meta.url))
+const require = createRequire(import.meta.url)
+const TS_EXTS = new Set(['.ts', '.tsx', '.cts', '.mts'])
 
 export function buildWrapperIR(exportsList) {
   return exportsList.map((entry) => {
@@ -449,7 +452,10 @@ export function code() {
 }
 
 export function createLoaderTypes({ exportFrom }) {
-  return `export function init(imports?: WebAssembly.Imports): Promise<void>;
+  return `export interface InitOptions {
+  backend?: 'auto' | 'simd' | 'base';
+}
+export function init(imports?: WebAssembly.Imports, opts?: InitOptions): Promise<void>;
 export * from "${exportFrom}";
 `
 }
@@ -461,14 +467,17 @@ export function createLoader({ exportFrom, autoInit, getBytesSrc }) {
       : '\nregisterInit(init);'
 
   return `import { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
+import { instantiateWithBackend } from "./util.js";
 ${getBytesSrc}
 
 let _ready = null;
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { simdBytes, baseBytes } = await getWasmBytes();
-    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
+let _backend = null;
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto';
+  if (_ready && _backend === backend) return _ready;
+  _backend = backend;
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({ getSimdBytes, getBaseBytes, imports, backend });
     setInstance(instance);
   })());
 }
@@ -495,10 +504,14 @@ function createBrowserLoader({ name, autoInit, customJs, wasmDelivery }) {
 const simdUrl = ${simdUrl};
 const baseUrl = ${baseUrl};
 
-async function getWasmBytes() {
-  const [simdRes, baseRes] = await Promise.all([fetch(simdUrl), fetch(baseUrl)]);
-  const [simdBytes, baseBytes] = await Promise.all([simdRes.arrayBuffer(), baseRes.arrayBuffer()]);
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  const res = await fetch(simdUrl);
+  return res.arrayBuffer();
+}
+
+async function getBaseBytes() {
+  const res = await fetch(baseUrl);
+  return res.arrayBuffer();
 }
 `
   return createLoader({ exportFrom, autoInit, getBytesSrc })
@@ -513,9 +526,12 @@ import { fileURLToPath } from "node:url";
 const simdPath = fileURLToPath(new URL("./wasm/${name}.simd.wasm", import.meta.url));
 const basePath = fileURLToPath(new URL("./wasm/${name}.base.wasm", import.meta.url));
 
-async function getWasmBytes() {
-  const [simdBytes, baseBytes] = await Promise.all([readFile(simdPath), readFile(basePath)]);
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  return readFile(simdPath);
+}
+
+async function getBaseBytes() {
+  return readFile(basePath);
 }
 `
   return createLoader({ exportFrom, autoInit, getBytesSrc })
@@ -524,11 +540,15 @@ async function getWasmBytes() {
 function createInlineLoader({ name, autoInit, customJs }) {
   const exportFrom = customJs ? './custom.js' : './core.js'
   const getBytesSrc = `
-import { wasmBytes as simdBytes } from "./wasm-inline/${name}.simd.wasm.js";
-import { wasmBytes as baseBytes } from "./wasm-inline/${name}.base.wasm.js";
+import { wasmBytes as _simdBytes } from "./wasm-inline/${name}.simd.wasm.js";
+import { wasmBytes as _baseBytes } from "./wasm-inline/${name}.base.wasm.js";
 
-async function getWasmBytes() {
-  return { simdBytes, baseBytes };
+async function getSimdBytes() {
+  return _simdBytes;
+}
+
+async function getBaseBytes() {
+  return _baseBytes;
 }
 `
   return createLoader({ exportFrom, autoInit, getBytesSrc })
@@ -540,6 +560,38 @@ export const wasmBytes = new Uint8Array([${bytes.join(',')}]);
 `
 }
 
+function loadCustomModule(crateDir, customJs) {
+  const customPath = join(crateDir, customJs)
+  const source = readFileSync(customPath, 'utf8')
+  const ext = extname(customJs).toLowerCase()
+
+  if (!TS_EXTS.has(ext)) return source
+
+  let ts
+  try {
+    ts = require('typescript')
+  } catch {
+    throw new Error(
+      "Custom TypeScript runtime requires the 'typescript' package. Install it with `npm install typescript` in your project."
+    )
+  }
+
+  const { outputText } = ts.transpileModule(source, {
+    fileName: customPath,
+    compilerOptions: {
+      module: ts.ModuleKind.ESNext,
+      target: ts.ScriptTarget.ES2020,
+      jsx: ts.JsxEmit.ReactJSX,
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      sourceMap: false,
+    },
+    reportDiagnostics: false,
+  })
+
+  return outputText
+}
+
 function writeInlineModules({
   outDir,
   artifactBaseName,
@@ -580,11 +632,11 @@ export function emitRuntime({
   mkdirSync(outDir, { recursive: true })
 
   if (customJs) {
-    const customJsContent = readFileSync(join(crateDir, customJs), 'utf8')
+    const customJsContent = loadCustomModule(crateDir, customJs)
     writeFileSync(join(outDir, 'custom.js'), customJsContent)
 
     if (emitTypes) {
-      const customTsPath = customJs.replace(/\.js$/, '.d.ts')
+      const customTsPath = customJs.replace(/\.[^.]+$/, '.d.ts')
       if (existsSync(join(crateDir, customTsPath))) {
         writeFileSync(
           join(outDir, 'custom.d.ts'),

package/src/cli/index.js

@@ -3,6 +3,7 @@ import { loadConfigFromCli, summarizeConfig } from './config.js'
 import { buildArtifacts } from './build.js'
 import { emitRuntime } from './emit.js'
 import { updatePackageJson } from './pkg.js'
+import { runBench } from './bench.js'
 
 export async function runBuild(cliOpts) {
   const cfg = loadConfigFromCli(cliOpts)
@@ -56,12 +57,19 @@ export async function runClean(cliOpts) {
   }
 }
 
+export async function runBenchCmd(cliOpts) {
+  const cfg = loadConfigFromCli(cliOpts)
+  console.log('Configuration:', summarizeConfig(cfg))
+  await runBench(cfg, cliOpts)
+}
+
 export function printHelp() {
   const help = `
 wasm-bindgen-lite <command> [options]
 
 Commands:
   build         Build wasm artifacts and emit JS loaders (default release)
+  bench         Build variant matrix and run SIMD analysis
   clean         Remove the configured output directory
   help          Show this message
 
@@ -74,7 +82,27 @@ Options (for build):
   --simd | --no-simd     Build SIMD variant (default: simd on)
   --wasm-opt | --no-wasm-opt  Force enable/disable wasm-opt (default: auto detect)
   --wasm-opt-args "<args>"    Extra args, default "-Oz"
-  --no-update-package-json     Do not modify package.json exports (default: updates if package.json exists)
+  --no-update-package-json     Do not modify package.json exports
+
+Options (for bench):
+  --crate <path>         Crate root (default: .)
+  --config <path>        Path to config JSON
+  --clean                Clean output directory before building
+  --skip-build           Skip building, use existing variants
+
+SIMD Configuration (in wasm-bindgen-lite.config.json):
+  {
+    "simd": {
+      "features": {
+        "explicit-simd-encode": { "name": "encode" },
+        "explicit-simd-decode": { "name": "decode" }
+      },
+      "allFeature": "explicit-simd"
+    },
+    "bench": {
+      "outputDir": "bench_out"
+    }
+  }
 `
   console.log(help)
 }

package/src/js/browser-inline.js

@@ -1,17 +1,30 @@
-import { wasmBytes as simdBytes } from './wasm-inline/mod.simd.wasm.js'
-import { wasmBytes as baseBytes } from './wasm-inline/mod.base.wasm.js'
+import { wasmBytes as _simdBytes } from './wasm-inline/mod.simd.wasm.js'
+import { wasmBytes as _baseBytes } from './wasm-inline/mod.base.wasm.js'
 import { setInstance } from './core.js'
-import { instantiateWithFallback } from './util.js'
+import { instantiateWithBackend } from './util.js'
+
+async function getSimdBytes() {
+  return _simdBytes
+}
+
+async function getBaseBytes() {
+  return _baseBytes
+}
 
 let _ready = null
+let _backend = null
 
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { instance } = await instantiateWithFallback(
-      simdBytes,
-      baseBytes,
-      imports
-    )
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto'
+  if (_ready && _backend === backend) return _ready
+  _backend = backend
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({
+      getSimdBytes,
+      getBaseBytes,
+      imports,
+      backend,
+    })
     setInstance(instance)
   })())
 }

package/src/js/browser.js

@@ -1,28 +1,33 @@
 import { setInstance } from './core.js'
-import { instantiateWithFallback } from './util.js'
+import { instantiateWithBackend } from './util.js'
 
 const simdUrl = new URL('./wasm/mod.simd.wasm', import.meta.url)
 const baseUrl = new URL('./wasm/mod.base.wasm', import.meta.url)
 
-let _ready = null
+async function getSimdBytes() {
+  const res = await fetch(simdUrl)
+  return res.arrayBuffer()
+}
 
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const [simdRes, baseRes] = await Promise.all([
-      fetch(simdUrl),
-      fetch(baseUrl),
-    ])
+async function getBaseBytes() {
+  const res = await fetch(baseUrl)
+  return res.arrayBuffer()
+}
 
-    const [simdBytes, baseBytes] = await Promise.all([
-      simdRes.arrayBuffer(),
-      baseRes.arrayBuffer(),
-    ])
+let _ready = null
+let _backend = null
 
-    const { instance } = await instantiateWithFallback(
-      simdBytes,
-      baseBytes,
-      imports
-    )
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto'
+  if (_ready && _backend === backend) return _ready
+  _backend = backend
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({
+      getSimdBytes,
+      getBaseBytes,
+      imports,
+      backend,
+    })
     setInstance(instance)
   })())
 }

package/src/js/node-inline.js

@@ -1,17 +1,30 @@
-import { wasmBytes as simdBytes } from './wasm-inline/mod.simd.wasm.js'
-import { wasmBytes as baseBytes } from './wasm-inline/mod.base.wasm.js'
+import { wasmBytes as _simdBytes } from './wasm-inline/mod.simd.wasm.js'
+import { wasmBytes as _baseBytes } from './wasm-inline/mod.base.wasm.js'
 import { setInstance } from './core.js'
-import { instantiateWithFallback } from './util.js'
+import { instantiateWithBackend } from './util.js'
+
+async function getSimdBytes() {
+  return _simdBytes
+}
+
+async function getBaseBytes() {
+  return _baseBytes
+}
 
 let _ready = null
+let _backend = null
 
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { instance } = await instantiateWithFallback(
-      simdBytes,
-      baseBytes,
-      imports
-    )
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto'
+  if (_ready && _backend === backend) return _ready
+  _backend = backend
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({
+      getSimdBytes,
+      getBaseBytes,
+      imports,
+      backend,
+    })
     setInstance(instance)
   })())
 }

package/src/js/node.js

@@ -1,24 +1,33 @@
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { setInstance } from './core.js'
-import { instantiateWithFallback } from './util.js'
+import { instantiateWithBackend } from './util.js'
 
 const simdPath = fileURLToPath(new URL('./wasm/mod.simd.wasm', import.meta.url))
 const basePath = fileURLToPath(new URL('./wasm/mod.base.wasm', import.meta.url))
 
+async function getSimdBytes() {
+  return readFile(simdPath)
+}
+
+async function getBaseBytes() {
+  return readFile(basePath)
+}
+
 let _ready = null
+let _backend = null
 
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const [simdBytes, baseBytes] = await Promise.all([
-      readFile(simdPath),
-      readFile(basePath),
-    ])
-    const { instance } = await instantiateWithFallback(
-      simdBytes,
-      baseBytes,
-      imports
-    )
+export function init(imports = {}, opts = {}) {
+  const backend = opts.backend || 'auto'
+  if (_ready && _backend === backend) return _ready
+  _backend = backend
+  return (_ready = (async () => {
+    const { instance } = await instantiateWithBackend({
+      getSimdBytes,
+      getBaseBytes,
+      imports,
+      backend,
+    })
     setInstance(instance)
   })())
 }

package/src/js/util.js

@@ -12,3 +12,33 @@ export async function instantiateWithFallback(
     return { instance, backend: 'wasm' }
   }
 }
+
+export async function instantiateWithBackend({
+  getSimdBytes,
+  getBaseBytes,
+  imports,
+  backend = 'auto',
+}) {
+  if (backend === 'base') {
+    const baseBytes = await getBaseBytes()
+    const { instance } = await WebAssembly.instantiate(baseBytes, imports)
+    return { instance, backend: 'wasm' }
+  }
+
+  if (backend === 'simd') {
+    const simdBytes = await getSimdBytes()
+    const { instance } = await WebAssembly.instantiate(simdBytes, imports)
+    return { instance, backend: 'wasm-simd' }
+  }
+
+  // auto: try simd first, then fallback to baseline
+  try {
+    const simdBytes = await getSimdBytes()
+    const { instance } = await WebAssembly.instantiate(simdBytes, imports)
+    return { instance, backend: 'wasm-simd' }
+  } catch {
+    const baseBytes = await getBaseBytes()
+    const { instance } = await WebAssembly.instantiate(baseBytes, imports)
+    return { instance, backend: 'wasm' }
+  }
+}