numbl 0.0.13 → 0.0.15

package/README.md

@@ -8,6 +8,10 @@ Numbl is an open-source numerical computing environment that aims to be compatib
 
 You can try numbl directly in the browser at <https://numbl.org> — no installation required. All execution happens locally in your browser. Note that the browser version has limited functionality and is slower than the desktop/command-line version.
 
+## Embedding in web pages
+
+Numbl scripts can be embedded in HTML and Markdown pages (including GitHub Pages). See the [numbl-embed-example](https://magland.github.io/numbl-embed-example/) for usage info and a [live demo](https://magland.github.io/numbl-embed-example/example1).
+
 ## Installation
 
 ```bash
@@ -50,4 +54,4 @@ Apache 2.0.
 
 ## Acknowledgements
 
-See [ACKNOWLEDGEMENTS.md](ACKNOWLEDGEMENTS.md).
+See [acknowledgements.md](docs/acknowledgements.md).

package/dist-cli/cli.js

@@ -9,7 +9,7 @@ import {
   writeFileSync as writeFileSync3,
   appendFileSync as appendFileSync2
 } from "fs";
-import { delimiter, dirname as dirname3, join as join5, relative, resolve } from "path";
+import { delimiter, dirname as dirname3, join as join6, relative, resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire } from "module";
 import { execSync as execSync2 } from "child_process";
@@ -21437,7 +21437,11 @@ var ExpressionParser = class extends ParserBase {
       const nameSpan = this.spanFrom(nameToken.position, nameToken.end);
       this.pos++;
       this.pos++;
-      args.push({ type: "Char", value: `'${nameToken.lexeme}'`, span: nameSpan });
+      args.push({
+        type: "Char",
+        value: `'${nameToken.lexeme}'`,
+        span: nameSpan
+      });
       args.push(this.parseExpr());
     } else {
       args.push(this.parseExpr());
@@ -25093,6 +25097,125 @@ function registerMathFunctions() {
       return buildResult(snArr, cnArr, dnArr, uT.shape);
     })
   );
+  register(
+    "legendre",
+    builtinSingle((args) => {
+      if (args.length < 2 || args.length > 3) {
+        throw new RuntimeError("legendre requires 2 or 3 arguments");
+      }
+      const n = Math.round(toNumber(args[0]));
+      if (n < 0 || !isFinite(n)) {
+        throw new RuntimeError("Degree n must be a non-negative integer");
+      }
+      let normalization = "unnorm";
+      if (args.length === 3) {
+        const normArg = args[2];
+        if (isRuntimeChar(normArg)) {
+          normalization = normArg.value;
+        } else if (typeof normArg === "string") {
+          normalization = normArg;
+        } else {
+          throw new RuntimeError(
+            "Third argument must be a normalization string"
+          );
+        }
+        if (normalization !== "unnorm" && normalization !== "sch" && normalization !== "norm") {
+          throw new RuntimeError(
+            "Normalization must be 'unnorm', 'sch', or 'norm'"
+          );
+        }
+      }
+      const xArg = args[1];
+      let xValues;
+      let xShape;
+      if (isRuntimeNumber(xArg)) {
+        xValues = [xArg];
+        xShape = [1, 1];
+      } else if (isRuntimeLogical(xArg)) {
+        xValues = [xArg ? 1 : 0];
+        xShape = [1, 1];
+      } else if (isRuntimeTensor(xArg)) {
+        const t = xArg;
+        xValues = Array.from(t.data);
+        xShape = t.shape;
+      } else {
+        throw new RuntimeError("X must be a numeric value");
+      }
+      const numX = xValues.length;
+      const numOrders = n + 1;
+      const outSize = numOrders * numX;
+      const result = new FloatXArray(outSize);
+      for (let xi = 0; xi < numX; xi++) {
+        const x = xValues[xi];
+        const pmn = legendreAllOrders(n, x);
+        for (let m = 0; m <= n; m++) {
+          let val = pmn[m];
+          if (normalization === "sch") {
+            if (m > 0) {
+              const scale = Math.pow(-1, m) * Math.sqrt(2 * factorialVal(n - m) / factorialVal(n + m));
+              val = scale * val;
+            }
+          } else if (normalization === "norm") {
+            const scale = Math.pow(-1, m) * Math.sqrt(
+              (n + 0.5) * factorialVal(n - m) / factorialVal(n + m)
+            );
+            val = scale * val;
+          }
+          result[xi * numOrders + m] = val;
+        }
+      }
+      if (isRuntimeNumber(xArg) || isRuntimeLogical(xArg)) {
+        return RTV.tensor(result, [numOrders, 1]);
+      }
+      if (xShape.length === 2 && (xShape[0] === 1 || xShape[1] === 1)) {
+        return RTV.tensor(result, [numOrders, numX]);
+      }
+      return RTV.tensor(result, [numOrders, ...xShape]);
+    })
+  );
+}
+function factorialVal(n) {
+  if (n <= 1) return 1;
+  let r = 1;
+  for (let i = 2; i <= n; i++) r *= i;
+  return r;
+}
+function legendreAllOrders(n, x) {
+  const result = new Array(n + 1);
+  if (n === 0) {
+    result[0] = 1;
+    return result;
+  }
+  const sqrtFactor = Math.sqrt(1 - x * x);
+  for (let m = 0; m <= n; m++) {
+    let pmm = 1;
+    if (m > 0) {
+      let dblFact = 1;
+      for (let i = 1; i <= m; i++) {
+        dblFact *= 2 * i - 1;
+      }
+      pmm = Math.pow(-1, m) * dblFact * Math.pow(sqrtFactor, m);
+    }
+    if (m === n) {
+      result[m] = pmm;
+      continue;
+    }
+    const pmm1 = x * (2 * m + 1) * pmm;
+    if (m + 1 === n) {
+      result[m] = pmm1;
+      continue;
+    }
+    let pPrev2 = pmm;
+    let pPrev1 = pmm1;
+    let pCurr = 0;
+    for (let l = m + 2; l <= n; l++) {
+      pCurr = (x * (2 * l - 1) * pPrev1 - (l + m - 1) * pPrev2) / (l - m);
+      pPrev2 = pPrev1;
+      pPrev1 = pCurr;
+    }
+    result[m] = pCurr;
+  }
+  return result;
 }
 
 // src/numbl-core/builtins/shape-utils.ts
@@ -34118,6 +34241,22 @@ function registerGraphicsFunctions() {
     "close",
     builtinSingle(() => RTV.num(0))
   );
+  register(
+    "title",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "xlabel",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "ylabel",
+    builtinSingle(() => RTV.num(0))
+  );
+  register(
+    "shading",
+    builtinSingle(() => RTV.num(0))
+  );
   register(
     "drawnow",
     builtinSingle(() => RTV.num(0))
@@ -38191,6 +38330,19 @@ function plotInstr(plotInstructions, instr) {
       on = toString(mv) === "on";
     }
     plotInstructions.push({ type: "set_hold", value: on });
+  } else if (instr.type === "set_title") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_title", text });
+  } else if (instr.type === "set_xlabel") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_xlabel", text });
+  } else if (instr.type === "set_ylabel") {
+    const text = typeof instr.text === "string" ? instr.text : toString(ensureRuntimeValue(instr.text));
+    plotInstructions.push({ type: "set_ylabel", text });
+  } else if (instr.type === "set_shading") {
+    const raw = typeof instr.shading === "string" ? instr.shading : toString(ensureRuntimeValue(instr.shading));
+    const shading = raw.replace(/^'|'$/g, "");
+    plotInstructions.push({ type: "set_shading", shading });
   } else if (instr.type === "close") {
     plotInstructions.push({ type: "close" });
   } else if (instr.type === "close_all") {
@@ -39147,6 +39299,61 @@ function getEffectiveDir(fileName, searchPaths) {
   }
   return parts.length > 0 ? parts.join("/") + "/" : "";
 }
+function resolveViaImports(name, argTypes, callSite, index2, wildcardOnly) {
+  const imports = index2.fileImports.get(callSite.file);
+  if (!imports) return null;
+  for (const imp of imports) {
+    if (imp.wildcard !== wildcardOnly) continue;
+    if (imp.wildcard) {
+      const candidateName = `${imp.namespace}.${name}`;
+      if (index2.workspaceFunctions.has(candidateName)) {
+        return { kind: "workspaceFunction", name: candidateName, argTypes };
+      }
+      if (index2.workspaceClasses.has(candidateName)) {
+        return {
+          kind: "workspaceClassConstructor",
+          className: candidateName,
+          argTypes
+        };
+      }
+      if (index2.classStaticMethods.get(imp.namespace)?.has(name)) {
+        return {
+          kind: "classMethod",
+          className: imp.namespace,
+          methodName: name,
+          compileArgTypes: argTypes,
+          stripInstance: false
+        };
+      }
+    } else {
+      if (name !== imp.shortName) continue;
+      if (imp.staticMethod) {
+        return {
+          kind: "classMethod",
+          className: imp.staticMethod.className,
+          methodName: imp.staticMethod.methodName,
+          compileArgTypes: argTypes,
+          stripInstance: false
+        };
+      }
+      if (index2.workspaceFunctions.has(imp.qualifiedName)) {
+        return {
+          kind: "workspaceFunction",
+          name: imp.qualifiedName,
+          argTypes
+        };
+      }
+      if (index2.workspaceClasses.has(imp.qualifiedName)) {
+        return {
+          kind: "workspaceClassConstructor",
+          className: imp.qualifiedName,
+          argTypes
+        };
+      }
+    }
+  }
+  return null;
+}
 function resolveFunction(name, argTypes, callSite, index2) {
   if (callSite.targetClassName) {
     const className = callSite.targetClassName;
@@ -39161,6 +39368,10 @@ function resolveFunction(name, argTypes, callSite, index2) {
       stripInstance
     };
   }
+  {
+    const imported = resolveViaImports(name, argTypes, callSite, index2, false);
+    if (imported) return imported;
+  }
   if (callSite.className) {
     const className = callSite.className;
     const isClassMethod = index2.classInstanceMethods.get(className)?.has(name) || index2.classConstructors.get(className) === name || index2.classStaticMethods.get(className)?.has(name);
@@ -39209,6 +39420,10 @@ function resolveFunction(name, argTypes, callSite, index2) {
       }
     }
   }
+  {
+    const imported = resolveViaImports(name, argTypes, callSite, index2, true);
+    if (imported) return imported;
+  }
   if (callSite.file) {
     const dir = getEffectiveDir(callSite.file, index2.searchPaths);
     if (index2.privateFunctions.get(dir)?.has(name)) {
@@ -39263,6 +39478,9 @@ function resolveFunction(name, argTypes, callSite, index2) {
       argTypes
     };
   }
+  if (index2.jsUserFunctions.has(name)) {
+    return { kind: "builtin", name };
+  }
   if (index2.workspaceClasses.has(name)) {
     return {
       kind: "workspaceClassConstructor",
@@ -39328,12 +39546,17 @@ function resolveFuncCall(ctx, name, args, nargout, span) {
         { type: "userFunction", functionId: `private:${name}` }
       ]);
     case "workspaceFunction":
-      return makeFuncCallExpr(ctx, name, args, nargout, span, [
-        { type: "userFunction", functionId: name }
+      return makeFuncCallExpr(ctx, target.name, args, nargout, span, [
+        { type: "userFunction", functionId: target.name }
       ]);
     case "workspaceClassConstructor":
       return {
-        kind: { type: "ClassInstantiation", className: name, args, nargout },
+        kind: {
+          type: "ClassInstantiation",
+          className: target.className,
+          args,
+          nargout
+        },
         span
       };
     case "builtin":
@@ -40720,8 +40943,17 @@ var LoweringContext = class _LoweringContext {
    * Should be called once after registerWorkspaceFiles() and registerLocalFunctionAST().
    * Parses all workspace files eagerly to discover subfunctions.
    */
-  buildFunctionIndex() {
+  buildFunctionIndex(jsUserFunctionNames) {
     const builtins2 = new Set(getAllBuiltinNames());
+    const jsUserFunctions = /* @__PURE__ */ new Set();
+    if (jsUserFunctionNames) {
+      for (const name of jsUserFunctionNames) {
+        if (builtins2.has(name)) {
+          builtins2.delete(name);
+          jsUserFunctions.add(name);
+        }
+      }
+    }
     const mainLocalFunctions = new Set(this.localFunctionASTs.keys());
     const workspaceFunctions = new Set(this.registry.filesByFuncName.keys());
     const workspaceClasses = /* @__PURE__ */ new Set([
@@ -40832,11 +41064,55 @@ var LoweringContext = class _LoweringContext {
         classInferiorClasses.set(className, new Set(info.inferiorClasses));
       }
     }
+    const fileImports = /* @__PURE__ */ new Map();
+    const collectImportsFromBody = (body, fileName) => {
+      const entries = [];
+      for (const stmt of body) {
+        if (stmt.type !== "Import") continue;
+        if (stmt.wildcard) {
+          entries.push({ wildcard: true, namespace: stmt.path.join(".") });
+        } else {
+          const qualifiedName = stmt.path.join(".");
+          const shortName = stmt.path[stmt.path.length - 1];
+          const prefix = stmt.path.slice(0, -1).join(".");
+          const isStaticMethod = prefix.length > 0 && classStaticMethods.get(prefix)?.has(shortName);
+          entries.push({
+            wildcard: false,
+            qualifiedName,
+            shortName,
+            ...isStaticMethod ? { staticMethod: { className: prefix, methodName: shortName } } : {}
+          });
+        }
+      }
+      if (entries.length > 0) {
+        fileImports.set(fileName, entries);
+      }
+    };
+    try {
+      const mainAst = this.getCachedAST(this.mainFileName);
+      collectImportsFromBody(mainAst.body, this.mainFileName);
+    } catch {
+    }
+    for (const [, entry] of this.registry.filesByFuncName) {
+      const ast = this.getCachedAST(entry.fileName);
+      collectImportsFromBody(ast.body, entry.fileName);
+    }
+    for (const [, info] of this.registry.classesByName) {
+      const ast = this.getCachedAST(info.fileName);
+      collectImportsFromBody(ast.body, info.fileName);
+    }
+    for (const [, entries] of this.registry.privateFilesByDir) {
+      for (const [, entry] of entries) {
+        const ast = this.getCachedAST(entry.fileName);
+        collectImportsFromBody(ast.body, entry.fileName);
+      }
+    }
     const index2 = {
       builtins: builtins2,
       mainFileName: this.mainFileName,
       mainLocalFunctions,
       workspaceFunctions,
+      jsUserFunctions,
       workspaceClasses,
       workspaceFileSubfunctions,
       classFileSubfunctions,
@@ -40847,7 +41123,8 @@ var LoweringContext = class _LoweringContext {
       privateFileSubfunctions,
       classInferiorClasses,
       searchPaths: this.registry.searchPaths,
-      fileToFuncName: this.registry.fileToFuncName
+      fileToFuncName: this.registry.fileToFuncName,
+      fileImports
     };
     this.registry.functionIndex = index2;
     return index2;
@@ -41604,6 +41881,14 @@ function genFuncCall(cg, kind) {
     return `$rt.plot_instr({type: "set_hold", value: ${args[0]}})`;
   if (kind.name === "ishold") return `$rt.ishold()`;
   if (kind.name === "clf") return `$rt.plot_instr({type: "clf"})`;
+  if (kind.name === "title")
+    return `$rt.plot_instr({type: "set_title", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "xlabel")
+    return `$rt.plot_instr({type: "set_xlabel", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "ylabel")
+    return `$rt.plot_instr({type: "set_ylabel", text: ${args[0] ?? '""'}})`;
+  if (kind.name === "shading")
+    return `$rt.plot_instr({type: "set_shading", shading: ${args[0] ?? '"faceted"'}})`;
   if (kind.name === "close") {
     if (args.length > 0) {
       return `$rt.plot_instr({type: "close_all"})`;
@@ -41715,13 +42000,18 @@ function genFuncCall(cg, kind) {
         break;
       }
       case "builtin": {
-        const nativeMath = tryNativeMathCodegen(
-          kind.name,
-          kind.nargout,
-          kind.args,
-          args
+        const isJsUserFunc = cg.loweringCtx.functionIndex.jsUserFunctions.has(
+          kind.name
         );
-        if (nativeMath !== null) return nativeMath;
+        if (!isJsUserFunc) {
+          const nativeMath = tryNativeMathCodegen(
+            kind.name,
+            kind.nargout,
+            kind.args,
+            args
+          );
+          if (nativeMath !== null) return nativeMath;
+        }
         if (hasUnknown) {
           return emitDispatchUnknown(
             cg,
@@ -43327,8 +43617,61 @@ var defaultCheck = (_argTypes, nargout) => ({
     kind: "Unknown"
   })
 });
-function loadJsUserFunctions(jsFiles) {
+function buildWasmMap(wasmFiles) {
+  const map = /* @__PURE__ */ new Map();
+  for (const f of wasmFiles) {
+    if (!f.data) continue;
+    const base = f.name.split("/").pop().replace(/\.wasm$/, "");
+    map.set(base, f.data);
+  }
+  return map;
+}
+function parseWasmDirective(source) {
+  const match = source.match(/^\s*\/\/\s*wasm:\s*(\S+)/);
+  return match ? match[1] : null;
+}
+function instantiateWasm(wasmData) {
+  const wasmModule = new WebAssembly.Module(wasmData);
+  const moduleImports = WebAssembly.Module.imports(wasmModule);
+  const importObject = {};
+  const neededModules = new Set(moduleImports.map((i) => i.module));
+  if (neededModules.has("wasi_snapshot_preview1")) {
+    importObject.wasi_snapshot_preview1 = {
+      fd_write: () => 0,
+      fd_read: () => 0,
+      fd_close: () => 0,
+      fd_seek: () => 0,
+      fd_fdstat_get: () => 0,
+      proc_exit: () => {
+      },
+      environ_sizes_get: () => 0,
+      environ_get: () => 0,
+      clock_time_get: () => 0,
+      args_sizes_get: () => 0,
+      args_get: () => 0
+    };
+  }
+  if (neededModules.has("env")) {
+    importObject.env = {
+      emscripten_notify_memory_growth: () => {
+      }
+    };
+  }
+  return new WebAssembly.Instance(wasmModule, importObject);
+}
+function loadJsUserFunctions(jsFiles, wasmFiles) {
   const result = /* @__PURE__ */ new Map();
+  const wasmMap = wasmFiles ? buildWasmMap(wasmFiles) : /* @__PURE__ */ new Map();
+  const wasmInstanceCache = /* @__PURE__ */ new Map();
+  function getWasmInstance(name) {
+    const cached = wasmInstanceCache.get(name);
+    if (cached) return cached;
+    const data = wasmMap.get(name);
+    if (!data) return null;
+    const instance = instantiateWasm(data);
+    wasmInstanceCache.set(name, instance);
+    return instance;
+  }
   for (const file of jsFiles) {
     const funcName = funcNameFromFile(file.name);
     try {
@@ -43342,14 +43685,18 @@ function loadJsUserFunctions(jsFiles) {
           apply: branch.apply
         });
       };
+      const wasmName = parseWasmDirective(file.source) ?? funcName;
+      const wasmInstance = getWasmInstance(wasmName);
       const factory = new Function(
         "RTV",
         "RuntimeError",
         "FloatXArray",
+        "IType",
         "register",
+        "wasm",
         file.source
       );
-      factory(RTV, RuntimeError, FloatXArray, registerFn);
+      factory(RTV, RuntimeError, FloatXArray, IType, registerFn, wasmInstance);
       if (branches.length === 0) {
         throw new Error(
           `JS user function '${funcName}' (${file.name}) must call register() at least once`
@@ -43445,10 +43792,13 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   const ctx = new LoweringContext(source, mainFileName);
   const mWorkspaceFiles = [];
   const jsWorkspaceFiles = [];
+  const wasmWorkspaceFiles = [];
   if (workspaceFiles) {
     for (const f of workspaceFiles) {
       if (f.name.endsWith(".js")) {
         jsWorkspaceFiles.push(f);
+      } else if (f.name.endsWith(".wasm")) {
+        wasmWorkspaceFiles.push(f);
       } else {
         mWorkspaceFiles.push(f);
       }
@@ -43465,7 +43815,10 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   }
   ctx.registry.searchPaths = [...searchPaths ?? [], SHIM_SEARCH_PATH];
   _t0 = performance.now();
-  const jsUserFunctions = loadJsUserFunctions(jsWorkspaceFiles);
+  const jsUserFunctions = loadJsUserFunctions(
+    jsWorkspaceFiles,
+    wasmWorkspaceFiles
+  );
   const _loadJsUserFunctionsMs = performance.now() - _t0;
   _t0 = performance.now();
   ctx.fileASTCache.set(mainFileName, ast);
@@ -43491,12 +43844,15 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
     ctx.registerWorkspaceFiles(mWorkspaceFiles);
   }
   const jsUserFuncNames = [...jsUserFunctions.keys()];
+  const savedBuiltins = /* @__PURE__ */ new Map();
   for (const name of jsUserFuncNames) {
+    const existing = getBuiltin(name);
+    if (existing) savedBuiltins.set(name, existing);
     register(name, jsUserFunctions.get(name));
   }
   const _registrationMs = performance.now() - _t0;
   _t0 = performance.now();
-  const functionIndex = ctx.buildFunctionIndex();
+  const functionIndex = ctx.buildFunctionIndex(jsUserFuncNames);
   const _buildFunctionIndexMs = performance.now() - _t0;
   ctx.isTopLevel = true;
   const initialVarIRVars = [];
@@ -43575,7 +43931,12 @@ function generateMainScriptCode(source, mainFileName = "script.m", workspaceFile
   codegen.emit(`return $ret;`);
   const _codegenMs = performance.now() - _t0;
   for (const name of jsUserFuncNames) {
-    unregister(name);
+    const original = savedBuiltins.get(name);
+    if (original) {
+      register(name, original);
+    } else {
+      unregister(name);
+    }
   }
   return {
     jsCode: codegen.getCode(),
@@ -44455,6 +44816,14 @@ async function runRepl(initialWorkspaceFiles, onDrawnow, initialSearchPaths) {
 
 // src/cli-fileio.ts
 import { openSync, closeSync, readSync, writeSync, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
+function expandTilde(filepath) {
+  if (filepath.startsWith("~/")) {
+    return join5(homedir4(), filepath.slice(2));
+  }
+  return filepath;
+}
 function permissionToFlags(permission) {
   switch (permission) {
     case "r":
@@ -44481,7 +44850,7 @@ var NodeFileIOAdapter = class {
   fopen(filename, permission) {
     try {
       const flags = permissionToFlags(permission);
-      const fd = openSync(filename, flags);
+      const fd = openSync(expandTilde(filename), flags);
       const fid = this.nextFid++;
       this.openFiles.set(fid, {
         fd,
@@ -44527,7 +44896,7 @@ var NodeFileIOAdapter = class {
     return this.readLine(entry, true);
   }
   fileread(filename) {
-    return readFileSync5(filename, "utf-8");
+    return readFileSync5(expandTilde(filename), "utf-8");
   }
   feof(fid) {
     const entry = this.getEntry(fid);
@@ -44609,8 +44978,8 @@ var NodeFileIOAdapter = class {
 // src/cli.ts
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = dirname3(__filename);
-var packageDir2 = join5(__dirname, "..");
-var addonPath = join5(packageDir2, "build", "Release", "lapack_addon.node");
+var packageDir2 = join6(__dirname, "..");
+var addonPath = join6(packageDir2, "build", "Release", "lapack_addon.node");
 var nativeAddonLoaded = false;
 try {
   const req = createRequire(import.meta.url);
@@ -44625,7 +44994,7 @@ function scanMFiles(dirPath, excludeFile) {
   try {
     const entries = readdirSync2(dirPath);
     for (const entry of entries) {
-      const fullPath = join5(dirPath, entry);
+      const fullPath = join6(dirPath, entry);
       if (excludeFile && fullPath === excludeFile) {
         continue;
       }
@@ -44640,6 +45009,13 @@ function scanMFiles(dirPath, excludeFile) {
           name: fullPath,
           source
         });
+      } else if (stat.isFile() && entry.endsWith(".wasm")) {
+        const data = readFileSync6(fullPath);
+        files.push({
+          name: fullPath,
+          source: "",
+          data: new Uint8Array(data)
+        });
       }
     }
   } catch {
@@ -44657,7 +45033,7 @@ function findTestFiles(dir) {
     }
     entries.sort();
     for (const entry of entries) {
-      const fullPath = join5(current, entry);
+      const fullPath = join6(current, entry);
       let stat;
       try {
         stat = statSync2(fullPath);
@@ -44665,7 +45041,7 @@ function findTestFiles(dir) {
         continue;
       }
       if (stat.isDirectory()) {
-        if (!entry.startsWith("@") && !entry.startsWith("+")) {
+        if (!entry.startsWith("@") && !entry.startsWith("+") && entry !== "wasm") {
           walk(fullPath);
         }
       } else if (stat.isFile() && entry.endsWith(".m")) {
@@ -45110,7 +45486,7 @@ function finalizeDumpFile(dumpFile, mainFileName, jsCode) {
   writeFileSync3(dumpFile, header + jsCode + "\n" + jitContent);
 }
 async function cmdBuildAddon() {
-  const bindingGyp = join5(packageDir2, "binding.gyp");
+  const bindingGyp = join6(packageDir2, "binding.gyp");
   if (!existsSync4(bindingGyp)) {
     console.error(
       "Error: binding.gyp not found in package directory: " + packageDir2
@@ -45317,7 +45693,7 @@ async function main() {
       await cmdEval(rest);
       break;
     case "run-tests": {
-      const dir = rest.length > 0 ? rest[0] : join5(packageDir2, "numbl_test_scripts");
+      const dir = rest.length > 0 ? rest[0] : join6(packageDir2, "numbl_test_scripts");
       await runTests(dir);
       break;
     }