wasm-bindgen-lite 0.1.0 → 0.3.0

package/Cargo.toml

@@ -21,3 +21,4 @@ codegen-units = 1
 panic = "abort"
 strip = true
 
+

package/LICENSE

@@ -19,3 +19,4 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-bindgen-lite",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "CLI tool to build Rust crates into minimal, SIMD-optimized WASM packages with JS loaders",
   "repository": {
@@ -29,7 +29,8 @@
   },
   "scripts": {
     "build": "node bin/wasm-bindgen-lite.js build --crate . --out dist --no-update-package-json",
-    "test": "cargo test && node scripts/test.js",
+    "test": "npm run test:unit && cargo test && node scripts/test.js",
+    "test:unit": "node --test test/*.test.js",
     "test:examples": "./scripts/test-examples.sh",
     "lint": "npm run lint:js && npm run lint:rust",
     "lint:js": "eslint . && prettier --check .",

package/scripts/build.js

@@ -58,7 +58,7 @@ try {
   run(
     `wasm-opt -Oz ${join(DIST, 'wasm/mod.simd.wasm')} -o ${join(DIST, 'wasm/mod.simd.wasm')}`
   )
-} catch (e) {
+} catch {
   console.warn('wasm-opt not found, skipping optimization.')
 }
 

package/scripts/test-examples.sh

@@ -23,3 +23,4 @@ for dir in examples/*; do
     cd ../..
   fi
 done
+

package/src/cli/build.js

@@ -2,6 +2,15 @@ import { execSync } from 'node:child_process'
 import { copyFileSync, mkdirSync } from 'node:fs'
 import { join } from 'node:path'
 
+function exec(cmd, options = {}) {
+  try {
+    execSync(cmd, { stdio: 'inherit', ...options })
+  } catch {
+    console.error(`\nError: Command failed: ${cmd}`)
+    process.exit(1)
+  }
+}
+
 function runCargoBuild({ crateDir, release, simd }) {
   const args = ['build', '--target', 'wasm32-unknown-unknown']
   if (release) args.push('--release')
@@ -13,9 +22,8 @@ function runCargoBuild({ crateDir, release, simd }) {
     env.RUSTFLAGS = [base, extra].filter(Boolean).join(' ').trim()
   }
 
-  execSync(`cargo ${args.join(' ')}`, {
+  exec(`cargo ${args.join(' ')}`, {
     cwd: crateDir,
-    stdio: 'inherit',
     env,
   })
 }
@@ -42,7 +50,7 @@ function maybeRunWasmOpt(wasmFile, wasmOpt) {
   }
 
   const args = ['wasm-opt', ...wasmOpt.args, wasmFile, '-o', wasmFile]
-  execSync(args.join(' '), { stdio: 'inherit' })
+  exec(args.join(' '))
 }
 
 export function buildArtifacts({
@@ -58,26 +66,24 @@ export function buildArtifacts({
   const wasmOutDir = join(outDir, 'wasm')
   mkdirSync(wasmOutDir, { recursive: true })
 
-  let baselinePath = null
-  let simdPath = null
+  const paths = { baselinePath: null, simdPath: null, wasmOutDir }
 
-  if (targets.baseline) {
-    console.log('Building baseline wasm...')
-    runCargoBuild({ crateDir, release, simd: false })
-    const built = wasmPath({ crateDir, release, wasmFileStem })
-    baselinePath = join(wasmOutDir, `${artifactBaseName}.base.wasm`)
-    copyFileSync(built, baselinePath)
-    maybeRunWasmOpt(baselinePath, wasmOpt)
-  }
+  const build = (isSimd, suffix) => {
+    const label = isSimd ? 'SIMD' : 'baseline'
+    console.log(`Building ${label} wasm...`)
+
+    runCargoBuild({ crateDir, release, simd: isSimd })
 
-  if (targets.simd) {
-    console.log('Building SIMD wasm...')
-    runCargoBuild({ crateDir, release, simd: true })
     const built = wasmPath({ crateDir, release, wasmFileStem })
-    simdPath = join(wasmOutDir, `${artifactBaseName}.simd.wasm`)
-    copyFileSync(built, simdPath)
-    maybeRunWasmOpt(simdPath, wasmOpt)
+    const dest = join(wasmOutDir, `${artifactBaseName}.${suffix}.wasm`)
+
+    copyFileSync(built, dest)
+    maybeRunWasmOpt(dest, wasmOpt)
+    return dest
   }
 
-  return { baselinePath, simdPath, wasmOutDir }
+  if (targets.baseline) paths.baselinePath = build(false, 'base')
+  if (targets.simd) paths.simdPath = build(true, 'simd')
+
+  return paths
 }

package/src/cli/config.js

@@ -19,6 +19,7 @@ const DEFAULT_CONFIG = {
       node: true,
       browser: true,
       inline: true,
+      types: true,
     },
     custom: null, // path to custom JS file to include and re-export
   },
@@ -63,13 +64,14 @@ function readCrateName(crateDir) {
 }
 
 function normalizeEmit(value) {
-  if (!value) return { node: true, browser: true, inline: true }
+  if (!value) return { node: true, browser: true, inline: true, types: true }
   if (Array.isArray(value)) {
     const set = new Set(value)
     return {
       node: set.has('node'),
       browser: set.has('browser'),
       inline: set.has('inline'),
+      types: set.has('types') || !set.has('no-types'), // default to true if not specified
     }
   }
   if (typeof value === 'object') {
@@ -77,9 +79,10 @@ function normalizeEmit(value) {
       node: value.node !== false,
       browser: value.browser !== false,
       inline: value.inline !== false,
+      types: value.types !== false,
     }
   }
-  return { node: true, browser: true, inline: true }
+  return { node: true, browser: true, inline: true, types: true }
 }
 
 function normalizeWasmOpt(input) {
@@ -104,90 +107,81 @@ export function loadConfigFromCli(cliOpts = {}) {
   }
 
   const crateName = readCrateName(crateDir)
-  const artifactBaseName =
-    cliOpts.artifactBaseName ??
-    fileConfig.artifactBaseName ??
-    DEFAULT_CONFIG.artifactBaseName
-
-  const outDir = resolve(
-    crateDir,
-    cliOpts.out ?? fileConfig.outDir ?? DEFAULT_CONFIG.outDir
-  )
-
-  const release =
-    typeof cliOpts.release === 'boolean'
-      ? cliOpts.release
-      : (fileConfig.release ?? DEFAULT_CONFIG.release)
-
-  const targets = {
-    baseline:
-      cliOpts.baseline ??
-      fileConfig.targets?.baseline ??
-      DEFAULT_CONFIG.targets.baseline,
-    simd:
-      typeof cliOpts.simd === 'boolean'
-        ? cliOpts.simd
-        : (fileConfig.targets?.simd ?? DEFAULT_CONFIG.targets.simd),
-  }
-
-  const inline =
-    typeof cliOpts.inline === 'boolean'
-      ? cliOpts.inline
-      : (fileConfig.inline ?? DEFAULT_CONFIG.inline)
-
-  const wasmOpt = normalizeWasmOpt(
-    cliOpts.wasmOptMode
-      ? { mode: cliOpts.wasmOptMode, args: cliOpts.wasmOptArgs }
-      : (fileConfig.wasmOpt ?? DEFAULT_CONFIG.wasmOpt)
-  )
-
-  const jsEmit = normalizeEmit(fileConfig.js?.emit ?? DEFAULT_CONFIG.js.emit)
-  const jsCustom = fileConfig.js?.custom ?? DEFAULT_CONFIG.js.custom
-
-  const exportsList =
-    fileConfig.exports &&
-    Array.isArray(fileConfig.exports) &&
-    fileConfig.exports.length
-      ? fileConfig.exports
-      : DEFAULT_CONFIG.exports
-
-  const autoInit =
-    fileConfig.autoInit === 'lazy' ||
-    fileConfig.autoInit === 'eager' ||
-    fileConfig.autoInit === 'off'
-      ? fileConfig.autoInit
-      : DEFAULT_CONFIG.autoInit
-
-  const streamCfg = {
-    enable: fileConfig.stream?.enable ?? DEFAULT_CONFIG.stream.enable,
-    export:
-      fileConfig.stream?.export ??
-      exportsList[0]?.name ??
-      DEFAULT_CONFIG.stream.export,
-    delimiter: fileConfig.stream?.delimiter ?? DEFAULT_CONFIG.stream.delimiter,
-  }
-
-  const wasmDelivery = {
-    type: fileConfig.wasmDelivery?.type ?? DEFAULT_CONFIG.wasmDelivery.type,
-    package: fileConfig.wasmDelivery?.package ?? fileConfig.name ?? crateName,
-    version: fileConfig.wasmDelivery?.version ?? fileConfig.version ?? 'latest',
-  }
 
+  // Merge defaults, file config, and CLI options
   const config = {
     crateDir,
     crateName,
     wasmFileStem: crateName.replace(/-/g, '_'),
-    artifactBaseName,
-    outDir,
-    release,
-    inline,
-    targets,
-    wasmOpt,
-    js: { emit: jsEmit, custom: jsCustom },
-    exports: exportsList,
-    autoInit,
-    stream: streamCfg,
-    wasmDelivery,
+
+    artifactBaseName:
+      cliOpts.artifactBaseName ??
+      fileConfig.artifactBaseName ??
+      DEFAULT_CONFIG.artifactBaseName,
+
+    outDir: resolve(
+      crateDir,
+      cliOpts.out ?? fileConfig.outDir ?? DEFAULT_CONFIG.outDir
+    ),
+
+    release:
+      typeof cliOpts.release === 'boolean'
+        ? cliOpts.release
+        : (fileConfig.release ?? DEFAULT_CONFIG.release),
+
+    targets: {
+      baseline:
+        cliOpts.baseline ??
+        fileConfig.targets?.baseline ??
+        DEFAULT_CONFIG.targets.baseline,
+      simd:
+        typeof cliOpts.simd === 'boolean'
+          ? cliOpts.simd
+          : (fileConfig.targets?.simd ?? DEFAULT_CONFIG.targets.simd),
+    },
+
+    inline:
+      typeof cliOpts.inline === 'boolean'
+        ? cliOpts.inline
+        : (fileConfig.inline ?? DEFAULT_CONFIG.inline),
+
+    wasmOpt: normalizeWasmOpt(
+      cliOpts.wasmOptMode
+        ? { mode: cliOpts.wasmOptMode, args: cliOpts.wasmOptArgs }
+        : (fileConfig.wasmOpt ?? DEFAULT_CONFIG.wasmOpt)
+    ),
+
+    js: {
+      emit: normalizeEmit(fileConfig.js?.emit ?? DEFAULT_CONFIG.js.emit),
+      custom: fileConfig.js?.custom ?? DEFAULT_CONFIG.js.custom,
+    },
+
+    exports:
+      fileConfig.exports && Array.isArray(fileConfig.exports)
+        ? fileConfig.exports
+        : DEFAULT_CONFIG.exports,
+
+    autoInit: ['lazy', 'eager', 'off'].includes(fileConfig.autoInit)
+      ? fileConfig.autoInit
+      : DEFAULT_CONFIG.autoInit,
+
+    stream: {
+      enable: fileConfig.stream?.enable ?? DEFAULT_CONFIG.stream.enable,
+      export:
+        fileConfig.stream?.export ??
+        fileConfig.exports?.[0]?.name ??
+        DEFAULT_CONFIG.stream.export,
+      delimiter:
+        fileConfig.stream?.delimiter ?? DEFAULT_CONFIG.stream.delimiter,
+      blockSize: fileConfig.stream?.blockSize ?? null,
+    },
+
+    wasmDelivery: {
+      type: fileConfig.wasmDelivery?.type ?? DEFAULT_CONFIG.wasmDelivery.type,
+      package: fileConfig.wasmDelivery?.package ?? fileConfig.name ?? crateName,
+      version:
+        fileConfig.wasmDelivery?.version ?? fileConfig.version ?? 'latest',
+    },
   }
 
   return config

package/src/cli/emit.js

@@ -1,272 +1,469 @@
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 const UTIL_PATH = fileURLToPath(new URL('../js/util.js', import.meta.url))
 
-function createCore({ exportsList, autoInit, stream }) {
-  const needsEnsure = autoInit === 'lazy'
-  const toBytesHelper = `function toBytes(input) {
-  if (input instanceof Uint8Array) return input;
-  if (ArrayBuffer.isView(input)) {
-    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-  }
-  if (input instanceof ArrayBuffer) return new Uint8Array(input);
-  throw new TypeError("Expected a TypedArray or ArrayBuffer");
-}
-`
-  const scalarSizeHelper = `function scalarSize(type) {
-  switch (type) {
-    case "f64": return 8;
-    case "f32":
-    case "i32":
-    case "u32": return 4;
-    case "i16":
-    case "u16": return 2;
-    case "i8":
-    case "u8": return 1;
-    case "u32_array":
-    case "i32_array":
-    case "f32_array": return 1024 * 1024; // Default large buffer for arrays, or we can improve this
-    default: return 0;
-  }
-}
-`
-  const decodeHelper = `function decodeReturn(view, type) {
-  switch (type) {
-    case "f32": return view.getFloat32(0, true);
-    case "f64": return view.getFloat64(0, true);
-    case "i32": return view.getInt32(0, true);
-    case "u32": return view.getUint32(0, true);
-    case "i16": return view.getInt16(0, true);
-    case "u16": return view.getUint16(0, true);
-    case "i8": return view.getInt8(0);
-    case "u8": return view.getUint8(0);
-    case "u32_array": return new Uint32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
-    case "i32_array": return new Int32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
-    case "f32_array": return new Float32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
-    default: return null;
-  }
+export function buildWrapperIR(exportsList) {
+  return exportsList.map((entry) => {
+    const { abi, name, return: retType, reuseBuffer, outSize } = entry
+    const returnType = retType || 'bytes'
+    const fnName = name || abi
+    const outSizeExpr =
+      returnType !== 'bytes'
+        ? `(scalarSize('${returnType}') || 4)`
+        : outSize
+          ? outSize.replace(/\blen\b/g, 'len')
+          : 'Math.max(len, 4)'
+
+    return {
+      abi,
+      fnName,
+      returnType,
+      reuseBuffer: !!reuseBuffer,
+      outSizeExpr,
+    }
+  })
 }
-`
-
-  const wrappers = exportsList
-    .map(({ abi, name, return: retType, reuseBuffer }) => {
-      const returnType = retType || 'bytes'
-      const fnName = name || abi
-      const outSizeExpr =
-        returnType === 'bytes'
-          ? 'Math.max(len, 4)'
-          : `(scalarSize('${returnType}') || 4)`
-
-      const stateVars = reuseBuffer
-        ? `let _${fnName}_in = { ptr: 0, len: 0 };
-let _${fnName}_out = { ptr: 0, len: 0 };`
-        : ''
-
-      const allocIn = reuseBuffer
-        ? `if (_${fnName}_in.len < len) {
-    if (_${fnName}_in.ptr) free(_${fnName}_in.ptr, _${fnName}_in.len);
-    _${fnName}_in.ptr = alloc(len);
-    _${fnName}_in.len = len;
-  }
-  const inPtr = _${fnName}_in.ptr;`
-        : `const inPtr = alloc(len);`
-
-      const allocOut = reuseBuffer
-        ? `if (_${fnName}_out.len < outLen) {
-    if (_${fnName}_out.ptr) free(_${fnName}_out.ptr, _${fnName}_out.len);
-    _${fnName}_out.ptr = alloc(outLen);
-    _${fnName}_out.len = outLen;
-  }
-  const outPtr = _${fnName}_out.ptr;`
-        : `const outPtr = alloc(outLen);`
-
-      const freeIn = reuseBuffer ? '' : `free(inPtr, len);`
-      const freeOut = reuseBuffer ? '' : `free(outPtr, outLen);`
-
-      const body = `
-  if (!_inst) throw new Error("WASM instance not initialized");
-  const view = toBytes(input);
-  const len = view.byteLength;
-  ${allocIn}
-  memoryU8().set(view, inPtr);
-  const outLen = ${outSizeExpr};
-  ${allocOut}
-  const written = _inst.exports.${abi}(
-    inPtr, len,
-    outPtr, outLen
-  );
-  if (written < 0) {
-    ${reuseBuffer ? '' : `free(inPtr, len); free(outPtr, outLen);`}
-    throw new Error("${abi} failed: " + written);
-  }
-  ${
-    returnType === 'bytes'
-      ? `const result = memoryU8().slice(outPtr, outPtr + written);`
-      : `const retView = new DataView(memoryU8().buffer, outPtr, written);
-  const ret = decodeReturn(retView, "${returnType}");`
-  }
-  ${freeIn}
-  ${freeOut}
-  ${returnType === 'bytes' ? 'return result;' : 'return ret;'}`
-
-      const wrapper = needsEnsure
-        ? `async function ${fnName}(input) { await ensureReady(); ${body} }`
-        : `function ${fnName}(input) { ${body} }`
 
-      return `${stateVars}\n${wrapper}\nexport { ${fnName} };`
+export function createCore({ exportsList, autoInit, stream }) {
+  const needsEnsure = autoInit === 'lazy'
+  const wrappersIR = buildWrapperIR(exportsList)
+  const b = code()
+
+  b.line('let _inst = null;')
+  b.line('let _memU8 = null;')
+  b.line('let _initFn = null;')
+  b.blank()
+
+  b.line('function refreshViews() {')
+  b.indent(() => {
+    b.line('_memU8 = new Uint8Array(_inst.exports.memory.buffer);')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('export function setInstance(instance) {')
+  b.indent(() => {
+    b.line('_inst = instance;')
+    b.line('refreshViews();')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('export function wasmExports() {')
+  b.indent(() => {
+    b.line('return _inst.exports;')
+  })
+  b.line('}')
+  b.blank()
+
+  if (needsEnsure) {
+    b.line('let _ready = null;')
+    b.line('export function registerInit(fn) { _initFn = fn; }')
+    b.blank()
+    b.line('async function ensureReady() {')
+    b.indent(() => {
+      b.line('if (_ready) return _ready;')
+      b.line('if (!_initFn) throw new Error("init not registered");')
+      b.line('_ready = _initFn();')
+      b.line('return _ready;')
     })
-    .join('\n\n')
-
-  const streamHelper = stream?.enable
-    ? `
-const __exports = { ${exportsList.map(({ name, abi }) => `${name || abi}: ${name || abi}`).join(', ')} };
-
-export function createTransformStream(fnName = "${stream.export}") {
-  const fn = __exports[fnName];
-  if (!fn) throw new Error("Unknown export for streaming: " + fnName);
-  
-  ${
-    stream.delimiter !== null
-      ? `let buffer = new Uint8Array(0);
-  const delimiter = ${stream.delimiter};`
-      : ''
+    b.line('}')
+  } else {
+    b.line('export function registerInit(fn) { _initFn = fn; }')
   }
+  b.blank()
 
-  return new TransformStream({
-    async transform(chunk, controller) {
-      const bytes = toBytes(chunk);
-      const processed = ${needsEnsure ? 'await fn(bytes)' : 'fn(bytes)'};
-      
-      ${
-        stream.delimiter !== null
-          ? `// Split and buffer
-      const combined = new Uint8Array(buffer.length + processed.length);
-      combined.set(buffer, 0);
-      combined.set(processed, buffer.length);
-
-      let start = 0;
-      for (let i = 0; i < combined.length; i += 1) {
-        if (combined[i] === delimiter) {
-          controller.enqueue(combined.subarray(start, i));
-          start = i + 1;
-        }
+  b.line('export function memoryU8() {')
+  b.indent(() => {
+    b.line(
+      'if (_memU8 && _memU8.buffer !== _inst.exports.memory.buffer) refreshViews();'
+    )
+    b.line('return _memU8;')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('export function alloc(len) {')
+  b.indent(() => {
+    b.line('return _inst.exports.alloc_bytes(len) >>> 0;')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('export function free(ptr, len) {')
+  b.indent(() => {
+    b.line('_inst.exports.free_bytes(ptr >>> 0, len >>> 0);')
+  })
+  b.line('}')
+  b.blank()
+
+  // Runtime Helpers
+  b.line('function toBytes(input) {')
+  b.indent(() => {
+    b.line('if (input instanceof Uint8Array) return input;')
+    b.line(
+      'if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);'
+    )
+    b.line('if (input instanceof ArrayBuffer) return new Uint8Array(input);')
+    b.line('throw new TypeError("Expected a TypedArray or ArrayBuffer");')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('function scalarSize(type) {')
+  b.indent(() => {
+    b.line('switch (type) {')
+    b.line('  case "f64": return 8;')
+    b.line('  case "f32":')
+    b.line('  case "i32":')
+    b.line('  case "u32": return 4;')
+    b.line('  case "i16":')
+    b.line('  case "u16": return 2;')
+    b.line('  case "i8":')
+    b.line('  case "u8": return 1;')
+    b.line('  case "u32_array":')
+    b.line('  case "i32_array":')
+    b.line('  case "f32_array": return 1024 * 1024;')
+    b.line('  default: return 0;')
+    b.line('}')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('function decodeReturn(view, type) {')
+  b.indent(() => {
+    b.line('switch (type) {')
+    b.line('  case "f32": return view.getFloat32(0, true);')
+    b.line('  case "f64": return view.getFloat64(0, true);')
+    b.line('  case "i32": return view.getInt32(0, true);')
+    b.line('  case "u32": return view.getUint32(0, true);')
+    b.line('  case "i16": return view.getInt16(0, true);')
+    b.line('  case "u16": return view.getUint16(0, true);')
+    b.line('  case "i8": return view.getInt8(0);')
+    b.line('  case "u8": return view.getUint8(0);')
+    b.line(
+      '  case "u32_array": return new Uint32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));'
+    )
+    b.line(
+      '  case "i32_array": return new Int32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));'
+    )
+    b.line(
+      '  case "f32_array": return new Float32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));'
+    )
+    b.line('  default: return null;')
+    b.line('}')
+  })
+  b.line('}')
+  b.blank()
+
+  b.line('function callWasm(abi, input, outLen, reuse) {')
+  b.indent(() => {
+    b.line('if (!_inst) throw new Error("WASM instance not initialized");')
+    b.line('const view = toBytes(input);')
+    b.line('const len = view.byteLength;')
+    b.blank()
+    b.line('let inPtr, outPtr;')
+    b.line('if (reuse) {')
+    b.indent(() => {
+      b.line('if (reuse.in.len < len) {')
+      b.indent(() => {
+        b.line('if (reuse.in.ptr) free(reuse.in.ptr, reuse.in.len);')
+        b.line('reuse.in.ptr = alloc(len);')
+        b.line('reuse.in.len = len;')
+      })
+      b.line('}')
+      b.line('if (reuse.out.len < outLen) {')
+      b.indent(() => {
+        b.line('if (reuse.out.ptr) free(reuse.out.ptr, reuse.out.len);')
+        b.line('reuse.out.ptr = alloc(outLen);')
+        b.line('reuse.out.len = outLen;')
+      })
+      b.line('}')
+      b.line('inPtr = reuse.in.ptr;')
+      b.line('outPtr = reuse.out.ptr;')
+    })
+    b.line('} else {')
+    b.indent(() => {
+      b.line('inPtr = alloc(len);')
+      b.line('outPtr = alloc(outLen);')
+    })
+    b.line('}')
+    b.blank()
+    b.line('memoryU8().set(view, inPtr);')
+    b.line('const written = _inst.exports[abi](inPtr, len, outPtr, outLen);')
+    b.line('if (written < 0) {')
+    b.indent(() => {
+      b.line('if (!reuse) { free(inPtr, len); free(outPtr, outLen); }')
+      b.line('throw new Error(abi + " failed: " + written);')
+    })
+    b.line('}')
+    b.blank()
+    b.line('return { inPtr, outPtr, len, outLen, written };')
+  })
+  b.line('}')
+  b.blank()
+
+  // Wrappers
+  wrappersIR.forEach((w) => {
+    if (w.reuseBuffer) {
+      b.line(
+        `const _${w.fnName}_reuse = { in: { ptr: 0, len: 0 }, out: { ptr: 0, len: 0 } };`
+      )
+    }
+    const asyncPrefix = needsEnsure ? 'async ' : ''
+    b.line(`${asyncPrefix}function ${w.fnName}(input) {`)
+    b.indent(() => {
+      if (needsEnsure) b.line('await ensureReady();')
+      b.line('const view = toBytes(input);')
+      b.line('const len = view.byteLength;')
+      b.line(`const outLen = ${w.outSizeExpr};`)
+      b.line(
+        `const { outPtr, written, inPtr } = callWasm("${w.abi}", view, outLen, ${w.reuseBuffer ? `_${w.fnName}_reuse` : 'null'});`
+      )
+      b.blank()
+      if (w.returnType === 'bytes') {
+        b.line('const result = memoryU8().slice(outPtr, outPtr + written);')
+      } else {
+        b.line(
+          'const retView = new DataView(memoryU8().buffer, outPtr, written);'
+        )
+        b.line(`const result = decodeReturn(retView, "${w.returnType}");`)
       }
-      buffer = combined.slice(start);`
-          : 'controller.enqueue(processed);'
+      b.blank()
+      if (!w.reuseBuffer) {
+        b.line('free(inPtr, len);')
+        b.line('free(outPtr, outLen);')
       }
-    }${
-      stream.delimiter !== null
-        ? `,
-    flush(controller) {
-      if (buffer.length) controller.enqueue(buffer);
-    }`
-        : ''
-    }
-  });
-}
-`
-    : ''
-
-  const ensure = needsEnsure
-    ? `
-let _ready = null;
-export function registerInit(fn) {
-  _initFn = fn;
-}
-
-async function ensureReady() {
-  if (_ready) return _ready;
-  if (!_initFn) throw new Error("init not registered");
-  _ready = _initFn();
-  return _ready;
-}
-`
-    : `
-export function registerInit(fn) {
-  _initFn = fn;
-}
-`
+      b.line('return result;')
+    })
+    b.line('}')
+    b.line(`export { ${w.fnName} };`)
+    b.blank()
+  })
+
+  // Streaming
+  if (stream?.enable) {
+    b.line('const __exports = {')
+    b.indent(() => {
+      exportsList.forEach((e) => {
+        b.line(
+          `${e.name || e.abi}: { fn: ${e.name || e.abi}, blockSize: ${e.blockSize || 'null'} },`
+        )
+      })
+    })
+    b.line('};')
+    b.blank()
 
-  return `let _inst = null;
-let _memU8 = null;
-let _initFn = null;
+    b.line(
+      'export function createChunkTransform(processFn, { blockSize = null, delimiter = null } = {}) {'
+    )
+    b.indent(() => {
+      b.line('let buffer = new Uint8Array(0);')
+      b.line('return new TransformStream({')
+      b.indent(() => {
+        b.line('async transform(chunk, controller) {')
+        b.indent(() => {
+          b.line('const bytes = toBytes(chunk);')
+          b.line('let input = bytes;')
+          b.blank()
+          b.line(
+            'if (buffer.length > 0 || blockSize !== null || delimiter !== null) {'
+          )
+          b.indent(() => {
+            b.line(
+              'const combined = new Uint8Array(buffer.length + bytes.length);'
+            )
+            b.line('combined.set(buffer, 0);')
+            b.line('combined.set(bytes, buffer.length);')
+            b.line('input = combined;')
+          })
+          b.line('}')
+          b.blank()
+          b.line('if (delimiter !== null) {')
+          b.indent(() => {
+            b.line('let start = 0;')
+            b.line('for (let i = 0; i < input.length; i++) {')
+            b.indent(() => {
+              b.line('if (input[i] === delimiter) {')
+              b.indent(() => {
+                b.line(
+                  'controller.enqueue(await processFn(input.subarray(start, i)));'
+                )
+                b.line('start = i + 1;')
+              })
+              b.line('}')
+            })
+            b.line('}')
+            b.line('buffer = input.slice(start);')
+          })
+          b.line('} else if (blockSize !== null) {')
+          b.indent(() => {
+            b.line(
+              'const processLen = input.length - (input.length % blockSize);'
+            )
+            b.line('if (processLen > 0) {')
+            b.indent(() => {
+              b.line(
+                'controller.enqueue(await processFn(input.subarray(0, processLen)));'
+              )
+              b.line('buffer = input.slice(processLen);')
+            })
+            b.line('} else {')
+            b.indent(() => {
+              b.line('buffer = input;')
+            })
+            b.line('}')
+          })
+          b.line('} else {')
+          b.indent(() => {
+            b.line('controller.enqueue(await processFn(input));')
+            b.line('buffer = new Uint8Array(0);')
+          })
+          b.line('}')
+        })
+        b.line('},')
+        b.line('async flush(controller) {')
+        b.indent(() => {
+          b.line('if (buffer.length > 0) {')
+          b.indent(() => {
+            b.line('controller.enqueue(await processFn(buffer));')
+            b.line('buffer = new Uint8Array(0);')
+          })
+          b.line('}')
+        })
+        b.line('}')
+      })
+      b.line('});')
+    })
+    b.line('}')
+    b.blank()
 
-function refreshViews() {
-  _memU8 = new Uint8Array(_inst.exports.memory.buffer);
-}
+    b.line(
+      `export function createTransformStream(fnName = "${stream.export}") {`
+    )
+    b.indent(() => {
+      b.line('const entry = __exports[fnName];')
+      b.line(
+        'if (!entry) throw new Error("Unknown export for streaming: " + fnName);'
+      )
+      b.line('const { fn, blockSize: entryBlockSize } = entry;')
+      b.line(
+        `const blockSize = entryBlockSize ?? ${stream.blockSize !== null ? stream.blockSize : 'null'};`
+      )
+      b.line(
+        `const delimiter = ${stream.delimiter !== null ? stream.delimiter : 'null'};`
+      )
+      b.line('return createChunkTransform(fn, { blockSize, delimiter });')
+    })
+    b.line('}')
+  }
 
-export function setInstance(instance) {
-  _inst = instance;
-  refreshViews();
+  return b.toString()
 }
 
-export function wasmExports() {
-  return _inst.exports;
-}
+export function createCoreTypes({ exportsList, autoInit, stream }) {
+  const needsEnsure = autoInit === 'lazy'
+  const wrappersIR = buildWrapperIR(exportsList)
+  const b = code()
+
+  b.line('export type WasmInput = Uint8Array | ArrayBufferView | ArrayBuffer;')
+  b.blank()
+
+  b.line('export function setInstance(instance: WebAssembly.Instance): void;')
+  b.line('export function wasmExports(): WebAssembly.Exports;')
+  b.line('export function memoryU8(): Uint8Array;')
+  b.line('export function alloc(len: number): number;')
+  b.line('export function free(ptr: number, len: number): void;')
+  b.blank()
+
+  wrappersIR.forEach((w) => {
+    let tsRetType
+    switch (w.returnType) {
+      case 'f32':
+      case 'f64':
+      case 'i32':
+      case 'u32':
+      case 'i16':
+      case 'u16':
+      case 'i8':
+      case 'u8':
+        tsRetType = 'number'
+        break
+      case 'u32_array':
+        tsRetType = 'Uint32Array'
+        break
+      case 'i32_array':
+        tsRetType = 'Int32Array'
+        break
+      case 'f32_array':
+        tsRetType = 'Float32Array'
+        break
+      case 'bytes':
+      default:
+        tsRetType = 'Uint8Array'
+    }
 
-${ensure}
+    const ret = needsEnsure ? `Promise<${tsRetType}>` : tsRetType
+    b.line(`export function ${w.fnName}(input: WasmInput): ${ret};`)
+  })
 
-export function memoryU8() {
-  if (_memU8 && _memU8.buffer !== _inst.exports.memory.buffer) refreshViews();
-  return _memU8;
-}
+  if (stream?.enable) {
+    b.blank()
+    b.line(
+      'export function createTransformStream(fnName?: string): TransformStream<WasmInput, Uint8Array>;'
+    )
+  }
 
-export function alloc(len) {
-  return _inst.exports.alloc_bytes(len) >>> 0;
+  return b.toString()
 }
 
-export function free(ptr, len) {
-  _inst.exports.free_bytes(ptr >>> 0, len >>> 0);
+export function code() {
+  const lines = []
+  let indent = 0
+  const api = {
+    line(s = '') {
+      lines.push('  '.repeat(indent) + s)
+      return api
+    },
+    blank() {
+      lines.push('')
+      return api
+    },
+    indent(fn) {
+      indent++
+      fn()
+      indent--
+      return api
+    },
+    toString() {
+      return lines.join('\n')
+    },
+  }
+  return api
 }
 
-${wrappers}
-${scalarSizeHelper}
-${decodeHelper}
-${toBytesHelper}
-${streamHelper}
+export function createLoaderTypes({ exportFrom }) {
+  return `export function init(imports?: WebAssembly.Imports): Promise<void>;
+export * from "${exportFrom}";
 `
 }
 
-function createBrowserLoader({ name, autoInit, customJs, wasmDelivery }) {
+export function createLoader({ exportFrom, autoInit, getBytesSrc }) {
   const eager =
     autoInit === 'eager'
       ? '\nregisterInit(init);\ninit();'
       : '\nregisterInit(init);'
-  const exportFrom = customJs ? './custom.js' : './core.js'
-
-  let simdUrl, baseUrl
-  if (wasmDelivery.type === 'jsdelivr') {
-    const pkg = wasmDelivery.package
-    const ver = wasmDelivery.version
-    simdUrl = `https://cdn.jsdelivr.net/npm/${pkg}@${ver}/dist/wasm/${name}.simd.wasm`
-    baseUrl = `https://cdn.jsdelivr.net/npm/${pkg}@${ver}/dist/wasm/${name}.base.wasm`
-  } else {
-    simdUrl = `new URL("./wasm/${name}.simd.wasm", import.meta.url)`
-    baseUrl = `new URL("./wasm/${name}.base.wasm", import.meta.url)`
-  }
 
   return `import { setInstance, registerInit } from "./core.js";
 import { instantiateWithFallback } from "./util.js";
-
-const simdUrl = ${wasmDelivery.type === 'jsdelivr' ? `"${simdUrl}"` : simdUrl};
-const baseUrl = ${wasmDelivery.type === 'jsdelivr' ? `"${baseUrl}"` : baseUrl};
+${getBytesSrc}
 
 let _ready = null;
-
 export function init(imports = {}) {
   return (_ready ??= (async () => {
-    const [simdRes, baseRes] = await Promise.all([
-      fetch(simdUrl),
-      fetch(baseUrl)
-    ]);
-
-    const [simdBytes, baseBytes] = await Promise.all([
-      simdRes.arrayBuffer(),
-      baseRes.arrayBuffer()
-    ]);
-
+    const { simdBytes, baseBytes } = await getWasmBytes();
     const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
     setInstance(instance);
   })());
@@ -276,59 +473,61 @@ export * from "${exportFrom}";
 `
 }
 
+function createBrowserLoader({ name, autoInit, customJs, wasmDelivery }) {
+  const exportFrom = customJs ? './custom.js' : './core.js'
+
+  let simdUrl, baseUrl
+  if (wasmDelivery.type === 'jsdelivr') {
+    const pkg = wasmDelivery.package
+    const ver = wasmDelivery.version
+    simdUrl = `"https://cdn.jsdelivr.net/npm/${pkg}@${ver}/dist/wasm/${name}.simd.wasm"`
+    baseUrl = `"https://cdn.jsdelivr.net/npm/${pkg}@${ver}/dist/wasm/${name}.base.wasm"`
+  } else {
+    simdUrl = `new URL("./wasm/${name}.simd.wasm", import.meta.url)`
+    baseUrl = `new URL("./wasm/${name}.base.wasm", import.meta.url)`
+  }
+
+  const getBytesSrc = `
+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 };
+}
+`
+  return createLoader({ exportFrom, autoInit, getBytesSrc })
+}
+
 function createNodeLoader({ name, autoInit, customJs }) {
-  const eager =
-    autoInit === 'eager'
-      ? '\nregisterInit(init);\ninit();'
-      : '\nregisterInit(init);'
   const exportFrom = customJs ? './custom.js' : './core.js'
-  return `import { readFile } from "node:fs/promises";
+  const getBytesSrc = `
+import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
 
 const simdPath = fileURLToPath(new URL("./wasm/${name}.simd.wasm", import.meta.url));
 const basePath = fileURLToPath(new URL("./wasm/${name}.base.wasm", import.meta.url));
 
-let _ready = 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);
-    setInstance(instance);
-  })());
+async function getWasmBytes() {
+  const [simdBytes, baseBytes] = await Promise.all([readFile(simdPath), readFile(basePath)]);
+  return { simdBytes, baseBytes };
 }
-${eager}
-export * from "${exportFrom}";
 `
+  return createLoader({ exportFrom, autoInit, getBytesSrc })
 }
 
 function createInlineLoader({ name, autoInit, customJs }) {
-  const eager =
-    autoInit === 'eager'
-      ? '\nregisterInit(init);\ninit();'
-      : '\nregisterInit(init);'
   const exportFrom = customJs ? './custom.js' : './core.js'
-  return `import { wasmBytes as simdBytes } from "./wasm-inline/${name}.simd.wasm.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 { setInstance, registerInit } from "./core.js";
-import { instantiateWithFallback } from "./util.js";
-
-let _ready = null;
 
-export function init(imports = {}) {
-  return (_ready ??= (async () => {
-    const { instance } = await instantiateWithFallback(simdBytes, baseBytes, imports);
-    setInstance(instance);
-  })());
+async function getWasmBytes() {
+  return { simdBytes, baseBytes };
 }
-${eager}
-export * from "${exportFrom}";
 `
+  return createLoader({ exportFrom, autoInit, getBytesSrc })
 }
 
 function createInlineModule(bytes) {
@@ -365,6 +564,7 @@ export function emitRuntime({
   emitNode,
   emitBrowser,
   emitInline,
+  emitTypes,
   wasmPaths,
   exportsList,
   autoInit,
@@ -377,14 +577,36 @@ export function emitRuntime({
   if (customJs) {
     const customJsContent = readFileSync(join(process.cwd(), customJs), 'utf8')
     writeFileSync(join(outDir, 'custom.js'), customJsContent)
+
+    if (emitTypes) {
+      const customTsPath = customJs.replace(/\.js$/, '.d.ts')
+      if (existsSync(join(process.cwd(), customTsPath))) {
+        writeFileSync(
+          join(outDir, 'custom.d.ts'),
+          readFileSync(join(process.cwd(), customTsPath), 'utf8')
+        )
+      }
+    }
   }
 
   writeFileSync(
     join(outDir, 'core.js'),
     createCore({ exportsList, autoInit, stream })
   )
+  if (emitTypes) {
+    writeFileSync(
+      join(outDir, 'core.d.ts'),
+      createCoreTypes({ exportsList, autoInit, stream })
+    )
+  }
   writeFileSync(join(outDir, 'util.js'), readFileSync(UTIL_PATH, 'utf8'))
 
+  const loaderTypes = emitTypes
+    ? createLoaderTypes({
+        exportFrom: customJs ? './custom.js' : './core.js',
+      })
+    : null
+
   if (emitBrowser) {
     writeFileSync(
       join(outDir, 'browser.js'),
@@ -395,6 +617,7 @@ export function emitRuntime({
         wasmDelivery,
       })
     )
+    if (emitTypes) writeFileSync(join(outDir, 'browser.d.ts'), loaderTypes)
   }
 
   if (emitNode) {
@@ -402,6 +625,7 @@ export function emitRuntime({
       join(outDir, 'node.js'),
       createNodeLoader({ name: artifactBaseName, autoInit, customJs })
     )
+    if (emitTypes) writeFileSync(join(outDir, 'node.d.ts'), loaderTypes)
   }
 
   if (emitInline && wasmPaths.baselinePath) {
@@ -409,10 +633,13 @@ export function emitRuntime({
       join(outDir, 'browser-inline.js'),
       createInlineLoader({ name: artifactBaseName, autoInit, customJs })
     )
+    if (emitTypes)
+      writeFileSync(join(outDir, 'browser-inline.d.ts'), loaderTypes)
     writeFileSync(
       join(outDir, 'node-inline.js'),
       createInlineLoader({ name: artifactBaseName, autoInit, customJs })
     )
+    if (emitTypes) writeFileSync(join(outDir, 'node-inline.d.ts'), loaderTypes)
     writeInlineModules({
       outDir,
       artifactBaseName,

package/src/cli/index.js

@@ -24,6 +24,7 @@ export async function runBuild(cliOpts) {
     emitNode: cfg.js.emit.node,
     emitBrowser: cfg.js.emit.browser,
     emitInline: cfg.inline && cfg.js.emit.inline,
+    emitTypes: cfg.js.emit.types,
     wasmPaths,
     exportsList: cfg.exports,
     autoInit: cfg.autoInit,
@@ -36,7 +37,6 @@ export async function runBuild(cliOpts) {
     updatePackageJson({
       crateDir: cfg.crateDir,
       outDir: cfg.outDir,
-      artifactBaseName: cfg.artifactBaseName,
       js: cfg.js,
       inline: cfg.inline,
     })

package/src/cli/pkg.js

@@ -1,13 +1,7 @@
 import { readFileSync, writeFileSync, existsSync } from 'node:fs'
 import { join, relative } from 'node:path'
 
-export function updatePackageJson({
-  crateDir,
-  outDir,
-  artifactBaseName,
-  js,
-  inline,
-}) {
+export function updatePackageJson({ crateDir, outDir, js, inline }) {
   const pkgPath = join(crateDir, 'package.json')
   if (!existsSync(pkgPath)) return
 
@@ -17,6 +11,9 @@ export function updatePackageJson({
   if (!pkg.exports) pkg.exports = {}
 
   const mainExports = {}
+  if (js.emit.types) {
+    mainExports.types = `${relOutDir}/node.d.ts`
+  }
   if (js.emit.browser) {
     mainExports.browser = `${relOutDir}/browser.js`
   }
@@ -31,6 +28,9 @@ export function updatePackageJson({
 
   if (inline && js.emit.inline) {
     const inlineExports = {}
+    if (js.emit.types) {
+      inlineExports.types = `${relOutDir}/node-inline.d.ts`
+    }
     if (js.emit.browser) {
       inlineExports.browser = `${relOutDir}/browser-inline.js`
     }
@@ -44,9 +44,16 @@ export function updatePackageJson({
     }
   }
 
-  // Also update main/module/types if they are missing?
-  // For now let's just focus on exports as it's the modern way.
+  if (js.emit.types) {
+    pkg.types = `${relOutDir}/node.d.ts`
+  }
+  if (js.emit.node) {
+    pkg.main = `${relOutDir}/node.js`
+  }
+  if (js.emit.browser) {
+    pkg.module = `${relOutDir}/browser.js`
+  }
 
   writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
-  console.log('Updated package.json exports')
+  console.log('Updated package.json exports and fields')
 }

package/src/js/util.js

@@ -6,7 +6,7 @@ export async function instantiateWithFallback(
   try {
     const { instance } = await WebAssembly.instantiate(trySimdBytes, imports)
     return { instance, backend: 'wasm-simd' }
-  } catch (e) {
+  } catch {
     // If SIMD fails (not supported), try baseline
     const { instance } = await WebAssembly.instantiate(baseBytes, imports)
     return { instance, backend: 'wasm' }