numbl 0.1.6 → 0.2.0

package/native/ops_napi.cpp

@@ -0,0 +1,320 @@
+/**
+ * N-API wrappers for the new tensor-ops layer (native/ops/).
+ *
+ * Each export is a thin shim: validate args, get raw pointers via Data(),
+ * call the C core, throw on negative return.  The output buffer is
+ * caller-allocated (passed in as the last argument).
+ *
+ * Categories exposed:
+ *   tensorOpRealBinary(op, n, a, b, out)
+ *   tensorOpRealScalarBinary(op, n, scalar, arr, scalarOnLeft, out)
+ *   tensorOpComplexBinary(op, n, aRe, aIm|null, bRe, bIm|null, outRe, outIm)
+ *   tensorOpComplexScalarBinary(op, n, sRe, sIm, arrRe, arrIm|null, scalarOnLeft, outRe, outIm)
+ *   tensorOpDumpCodes()  →  string (used only by drift-detection test)
+ */
+
+#include <napi.h>
+
+extern "C" {
+  #include "ops/numbl_ops.h"
+}
+
+namespace {
+
+inline void ThrowOnError(Napi::Env env, int code, const char* op_name) {
+  if (code != NUMBL_OK) {
+    std::string msg = std::string(op_name) + ": " + numbl_strerror(code);
+    Napi::Error::New(env, msg).ThrowAsJavaScriptException();
+  }
+}
+
+inline const double* AsF64(const Napi::Value& v) {
+  return v.As<Napi::Float64Array>().Data();
+}
+
+inline double* AsF64Mut(const Napi::Value& v) {
+  return v.As<Napi::Float64Array>().Data();
+}
+
+inline const double* AsF64OrNull(const Napi::Value& v) {
+  if (v.IsNull() || v.IsUndefined()) return nullptr;
+  return v.As<Napi::Float64Array>().Data();
+}
+
+}  // namespace
+
+Napi::Value TensorOpRealBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 5) {
+    Napi::TypeError::New(env,
+      "tensorOpRealBinary(op, n, a, b, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_binary_elemwise(
+      op, n, AsF64(info[2]), AsF64(info[3]), AsF64Mut(info[4]));
+  ThrowOnError(env, rc, "tensorOpRealBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealScalarBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpRealScalarBinary(op, n, scalar, arr, scalarOnLeft, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double scalar = info[2].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[4].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_real_scalar_binary_elemwise(
+      op, n, scalar, AsF64(info[3]), scalar_on_left, AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpRealScalarBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 8) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexBinary(op, n, aRe, aIm|null, bRe, bIm|null, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_binary_elemwise(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      AsF64Mut(info[6]), AsF64Mut(info[7]));
+  ThrowOnError(env, rc, "tensorOpComplexBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexScalarBinary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 9) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexScalarBinary(op, n, sRe, sIm, arrRe, arrIm|null, scalarOnLeft, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double s_re = info[2].As<Napi::Number>().DoubleValue();
+  double s_im = info[3].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[6].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_complex_scalar_binary_elemwise(
+      op, n, s_re, s_im,
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      scalar_on_left,
+      AsF64Mut(info[7]), AsF64Mut(info[8]));
+  ThrowOnError(env, rc, "tensorOpComplexScalarBinary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealUnary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env,
+      "tensorOpRealUnary(op, n, a, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_unary_elemwise(op, n, AsF64(info[2]), AsF64Mut(info[3]));
+  ThrowOnError(env, rc, "tensorOpRealUnary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexUnary(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexUnary(op, n, aRe, aIm|null, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_unary_elemwise(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64Mut(info[4]), AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpComplexUnary");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexAbs(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexAbs(n, aRe, aIm|null, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  size_t n = (size_t)info[0].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_abs(
+      n, AsF64(info[1]), AsF64OrNull(info[2]), AsF64Mut(info[3]));
+  ThrowOnError(env, rc, "tensorOpComplexAbs");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 5) {
+    Napi::TypeError::New(env,
+      "tensorOpRealComparison(op, n, a, b, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_comparison(
+      op, n, AsF64(info[2]), AsF64(info[3]), AsF64Mut(info[4]));
+  ThrowOnError(env, rc, "tensorOpRealComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealScalarComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpRealScalarComparison(op, n, scalar, arr, scalarOnLeft, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double scalar = info[2].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[4].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_real_scalar_comparison(
+      op, n, scalar, AsF64(info[3]), scalar_on_left, AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpRealScalarComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 7) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexComparison(op, n, aRe, aIm|null, bRe, bIm|null, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_complex_comparison(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      AsF64Mut(info[6]));
+  ThrowOnError(env, rc, "tensorOpComplexComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexScalarComparison(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 8) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexScalarComparison(op, n, sRe, sIm, arrRe, arrIm|null, scalarOnLeft, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double s_re = info[2].As<Napi::Number>().DoubleValue();
+  double s_im = info[3].As<Napi::Number>().DoubleValue();
+  int scalar_on_left = info[6].As<Napi::Boolean>().Value() ? 1 : 0;
+  int rc = numbl_complex_scalar_comparison(
+      op, n, s_re, s_im,
+      AsF64(info[4]), AsF64OrNull(info[5]),
+      scalar_on_left, AsF64Mut(info[7]));
+  ThrowOnError(env, rc, "tensorOpComplexScalarComparison");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpRealFlatReduce(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 4) {
+    Napi::TypeError::New(env,
+      "tensorOpRealFlatReduce(op, n, a, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  int rc = numbl_real_flat_reduce(op, n, AsF64(info[2]), AsF64Mut(info[3]));
+  ThrowOnError(env, rc, "tensorOpRealFlatReduce");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpComplexFlatReduce(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpComplexFlatReduce(op, n, aRe, aIm|null, outRe, outIm|null)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  size_t n = (size_t)info[1].As<Napi::Number>().Int64Value();
+  double* out_im = (info[5].IsNull() || info[5].IsUndefined())
+                       ? nullptr
+                       : AsF64Mut(info[5]);
+  int rc = numbl_complex_flat_reduce(
+      op, n,
+      AsF64(info[2]), AsF64OrNull(info[3]),
+      AsF64Mut(info[4]), out_im);
+  ThrowOnError(env, rc, "tensorOpComplexFlatReduce");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpBesselReal(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 6) {
+    Napi::TypeError::New(env,
+      "tensorOpBesselReal(op, nu, n, z, scale, out)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int op = info[0].As<Napi::Number>().Int32Value();
+  double nu = info[1].As<Napi::Number>().DoubleValue();
+  size_t n = (size_t)info[2].As<Napi::Number>().Int64Value();
+  int scale = info[4].As<Napi::Number>().Int32Value();
+  int rc = numbl_bessel_real(op, nu, n, AsF64(info[3]), scale, AsF64Mut(info[5]));
+  ThrowOnError(env, rc, "tensorOpBesselReal");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpBesselH(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 7) {
+    Napi::TypeError::New(env,
+      "tensorOpBesselH(kKind, nu, n, z, scale, outRe, outIm)")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+  int k_kind = info[0].As<Napi::Number>().Int32Value();
+  double nu = info[1].As<Napi::Number>().DoubleValue();
+  size_t n = (size_t)info[2].As<Napi::Number>().Int64Value();
+  int scale = info[4].As<Napi::Number>().Int32Value();
+  int rc = numbl_bessel_h(k_kind, nu, n, AsF64(info[3]), scale,
+                          AsF64Mut(info[5]), AsF64Mut(info[6]));
+  ThrowOnError(env, rc, "tensorOpBesselH");
+  return env.Undefined();
+}
+
+Napi::Value TensorOpDumpCodes(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  size_t need = numbl_dump_op_codes(nullptr, 0);
+  std::string buf(need, '\0');
+  numbl_dump_op_codes(&buf[0], need + 1);
+  return Napi::String::New(env, buf);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",
@@ -38,15 +38,15 @@
   ],
   "scripts": {
     "dev": "npm run bundle:stdlib && vite",
-    "build": "npm run build:web && npm run build:cli && npm run build:plot-viewer",
+    "build": "npm run build:web && npm run build:test-runner && npm run copy:test-scripts && npm run build:cli && npm run build:plot-viewer",
     "build:plot-viewer": "vite build --config vite.plot-viewer.config.ts",
+    "build:test-runner": "npm run bundle:stdlib && vite build --config vite.test-runner.config.ts",
+    "dev:test-runner": "npm run bundle:stdlib && vite --config vite.test-runner.config.ts",
+    "copy:test-scripts": "tsx scripts/copy-test-scripts.ts",
     "bundle:stdlib": "tsx scripts/bundle-stdlib.ts",
     "build:web": "npm run bundle:stdlib && tsc -b && vite build",
     "build:lib": "npm run bundle:stdlib && esbuild src/lib.ts --bundle --platform=neutral --format=esm --outfile=dist-lib/lib.js --loader:.wasm=file && tsc -p tsconfig.lib.json",
     "build:cli": "npm run bundle:stdlib && esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist-cli/cli.js --packages=external --loader:.wasm=file",
-    "build:server": "esbuild server/execution-service.ts --bundle --platform=node --format=esm --outfile=server/dist/execution-service.js --packages=external",
-    "server:dev": "node --env-file=server/.env node_modules/.bin/tsx server/execution-service.ts",
-    "server:start": "node --env-file=server/.env server/dist/execution-service.js",
     "install": "true",
     "build:addon": "node-gyp rebuild",
     "format": "prettier --write .",
@@ -60,10 +60,14 @@
     "test:coverage": "vitest run --coverage",
     "test:coverage:all": "bash scripts/coverage-all.sh",
     "test:scripts": "bash numbl_test_scripts/run_all.sh",
-    "test:jit": "tsx src/cli.ts run-tests numbl_test_scripts/jit --opt 1",
+    "test:browser": "playwright test",
+    "test:scripts:c-jit": "bash numbl_test_scripts/run_c_jit.sh",
+    "test:scripts:c-jit-fuse": "bash numbl_test_scripts/run_c_jit_fuse.sh",
+    "test:scripts:c-jit-parity": "bash numbl_test_scripts/run_c_jit_parity.sh",
     "build:wasm": "bash numbl_test_scripts/build_wasm.sh",
     "update-readme": "tsx scripts/update-readme-usage.ts",
     "check-readme": "tsx scripts/update-readme-usage.ts --check",
+    "bump": "tsx scripts/bump-version.ts",
     "prepublishOnly": "npm run build:lib && npm run build:cli && npm run build:plot-viewer",
     "prepare": "husky"
   },
@@ -83,8 +87,7 @@
     "@monaco-editor/react": "^4.7.0",
     "@mui/icons-material": "^7.3.7",
     "@mui/material": "^7.3.7",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^5.0.0",
+    "@playwright/test": "^1.59.1",
     "@types/node": "^24.10.1",
     "@types/pako": "^2.0.4",
     "@types/react": "^19.2.5",
@@ -95,14 +98,12 @@
     "@vitest/coverage-v8": "^4.0.18",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
-    "cors": "^2.8.5",
     "dexie": "^4.3.0",
     "esbuild": "^0.27.3",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
-    "express": "^4.21.2",
     "globals": "^16.5.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",

package/dist-lib/numbl-core/interpreter/jit/jitCodegen.d.ts

@@ -1,5 +0,0 @@
-/**
- * JIT IR -> JavaScript code generation.
- */
-import { type JitStmt } from "./jitTypes.js";
-export declare function generateJS(body: JitStmt[], params: string[], outputs: string[], nargout: number, localVars: Set<string>, fileName?: string): string;

package/dist-lib/numbl-core/interpreter/jit/jitHelpers.d.ts

@@ -1,14 +0,0 @@
-/**
- * Runtime helpers for JIT-compiled tensor and complex operations.
- * Passed as `$h` to generated functions.
- */
-export declare const jitHelpers: Record<string, unknown>;
-import type { IBuiltin } from "../builtins/index.js";
-/**
- * Build a per-runtime jitHelpers map for an execution that has .numbl.js
- * user functions. The result is a clone of the global jitHelpers extended
- * with `ib_<name>` entries (single-output fast path) for each js user
- * function and an overridden `ibcall` (multi-output) that consults the
- * js user function map first before falling back to the global registry.
- */
-export declare function buildPerRuntimeJitHelpers(jsUserFunctions: ReadonlyMap<string, IBuiltin>): Record<string, any>;

package/dist-lib/numbl-core/interpreter/jit/jitLower.d.ts

@@ -1,20 +0,0 @@
-/**
- * AST -> JIT IR lowering with type propagation.
- *
- * Returns null if any unsupported construct is encountered,
- * causing the entire function to fall back to interpretation.
- */
-import type { FunctionDef } from "../types.js";
-import type { Interpreter } from "../interpreter.js";
-import { type JitType, type JitStmt } from "./jitTypes.js";
-export interface LoweringResult {
-    body: JitStmt[];
-    outputNames: string[];
-    localVars: Set<string>;
-    hasTensorOps: boolean;
-    /** Generated JS code for called user functions: jitName → code */
-    generatedFns: Map<string, string>;
-    /** Type of the first output variable after lowering */
-    outputType: JitType | null;
-}
-export declare function lowerFunction(fn: FunctionDef, argTypes: JitType[], nargout: number, interp?: Interpreter, generatedFns?: Map<string, string>, loweringInProgress?: Set<string>): LoweringResult | null;

package/dist-lib/numbl-core/interpreter/jit/jitTypes.d.ts

@@ -1,168 +0,0 @@
-/**
- * JIT type system and IR node definitions.
- */
-import type { BinaryOperation, UnaryOperation } from "../../parser/types.js";
-export type SignCategory = "positive" | "nonneg" | "nonpositive" | "negative";
-export type JitType = {
-    kind: "number";
-    exact?: number;
-    sign?: SignCategory;
-} | {
-    kind: "boolean";
-    value?: boolean;
-} | {
-    kind: "complex_or_number";
-    pureImaginary?: boolean;
-} | {
-    kind: "tensor";
-    isComplex: boolean;
-    shape?: number[];
-    ndim?: number;
-    isLogical?: boolean;
-    nonneg?: boolean;
-} | {
-    kind: "string";
-    value?: string;
-} | {
-    kind: "char";
-    value?: string;
-} | {
-    kind: "struct";
-    fields?: Record<string, JitType>;
-} | {
-    kind: "class_instance";
-    className: string;
-    isHandleClass?: boolean;
-    fields?: Record<string, JitType>;
-} | {
-    kind: "sparse_matrix";
-    isComplex: boolean;
-    m?: number;
-    n?: number;
-} | {
-    kind: "cell";
-    shape?: number[];
-} | {
-    kind: "dictionary";
-} | {
-    kind: "unknown";
-};
-export declare function signFromNumber(v: number): SignCategory | undefined;
-export declare function isNonneg(t: JitType): boolean;
-export declare function flipSign(s?: SignCategory): SignCategory | undefined;
-export declare function unifySign(a?: SignCategory, b?: SignCategory): SignCategory | undefined;
-export declare function jitTypeKey(t: JitType): string;
-export declare function computeJitCacheKey(nargout: number, argTypes: JitType[]): string;
-/** Compute a unique JS function name for a JIT'd specialization. */
-export declare function computeJitFnName(identity: string, funcName: string): string;
-/** Widen/unify two types at control-flow join points. */
-export declare function unifyJitTypes(a: JitType, b: JitType): JitType;
-export declare function isScalarType(t: JitType): boolean;
-export declare function isNumericScalarType(t: JitType): boolean;
-export declare function isTensorType(t: JitType): boolean;
-export declare function isComplexType(t: JitType): boolean;
-/** Types that support arithmetic binary operations in the JIT. */
-export declare function isArithmeticType(t: JitType): boolean;
-export declare function shapeAfterReduction(shape: number[], dim?: number): {
-    scalar: true;
-} | {
-    scalar: false;
-    shape: number[];
-};
-export type JitExpr = {
-    tag: "NumberLiteral";
-    value: number;
-    jitType: JitType;
-} | {
-    tag: "ImagLiteral";
-    jitType: JitType;
-} | {
-    tag: "Var";
-    name: string;
-    jitType: JitType;
-} | {
-    tag: "Binary";
-    op: BinaryOperation;
-    left: JitExpr;
-    right: JitExpr;
-    jitType: JitType;
-} | {
-    tag: "Unary";
-    op: UnaryOperation;
-    operand: JitExpr;
-    jitType: JitType;
-} | {
-    tag: "StringLiteral";
-    value: string;
-    isChar: boolean;
-    jitType: JitType;
-} | {
-    tag: "Call";
-    name: string;
-    args: JitExpr[];
-    jitType: JitType;
-} | {
-    tag: "UserCall";
-    jitName: string;
-    name: string;
-    args: JitExpr[];
-    jitType: JitType;
-} | {
-    tag: "Index";
-    base: JitExpr;
-    indices: JitExpr[];
-    jitType: JitType;
-} | {
-    tag: "TensorLiteral";
-    rows: JitExpr[][];
-    nRows: number;
-    nCols: number;
-    jitType: JitType;
-};
-export type JitStmt = {
-    tag: "Assign";
-    name: string;
-    expr: JitExpr;
-} | {
-    tag: "If";
-    cond: JitExpr;
-    thenBody: JitStmt[];
-    elseifBlocks: {
-        cond: JitExpr;
-        body: JitStmt[];
-    }[];
-    elseBody: JitStmt[] | null;
-} | {
-    tag: "For";
-    varName: string;
-    start: JitExpr;
-    step: JitExpr | null;
-    end: JitExpr;
-    body: JitStmt[];
-} | {
-    tag: "While";
-    cond: JitExpr;
-    body: JitStmt[];
-} | {
-    tag: "Break";
-} | {
-    tag: "Continue";
-} | {
-    tag: "Return";
-} | {
-    tag: "ExprStmt";
-    expr: JitExpr;
-} | {
-    tag: "MultiAssign";
-    names: (string | null)[];
-    callName: string;
-    args: JitExpr[];
-    outputTypes: JitType[];
-} | {
-    tag: "SetLoc";
-    line: number;
-};
-export interface JitCacheEntry {
-    fn: (...args: unknown[]) => unknown;
-    source: string;
-}