numbl 0.4.21 → 0.4.22

package/dist-lib/numbl-core/helpers/linsolve.d.ts

@@ -5,20 +5,10 @@
  * If A is non-square, uses QR / LQ factorisation (dgels / dgeqrf+solve):
  *   overdetermined  (m > n): least-squares solution minimising ||A*X - B||₂
  *   underdetermined (m < n): minimum-norm solution minimising ||X||₂
- *
- * Both the native LAPACK addon and the ts-lapack TypeScript fallback are
- * supported; the native addon is preferred when available.
- */
-/**
- * Dispatch linsolve to the native addon (preferred) or ts-lapack fallback.
- * Returns null only when neither bridge exposes `linsolve` (should not happen
- * in practice since ts-lapack always has it).
- */
-export declare function linsolveLapack(A: Float64Array, m: number, n: number, B: Float64Array, nrhs: number): Float64Array | null;
-/**
- * Dispatch complex linsolve to the native addon (preferred) or ts-lapack fallback.
- * The ts-lapack fallback throws — native addon is required for complex linsolve.
  */
+/** Real A \ B through the LAPACK bridge. */
+export declare function linsolveLapack(A: Float64Array, m: number, n: number, B: Float64Array, nrhs: number): Float64Array;
+/** Complex A \ B through the LAPACK bridge. */
 export declare function linsolveComplexLapack(ARe: Float64Array, AIm: Float64Array, m: number, n: number, BRe: Float64Array, BIm: Float64Array, nrhs: number): {
     re: Float64Array;
     im: Float64Array;

package/dist-lib/numbl-core/helpers/reduction-helpers.d.ts

@@ -34,9 +34,6 @@ export declare function logicalAlongDim(v: RuntimeTensor, dim: number, mode: "an
 /** Sum a sparse matrix along dim 1 (columns) or dim 2 (rows).
  *  Returns sparse for dim=1, dense tensor for dim=2. */
 export declare function sparseSum(v: RuntimeSparseMatrix, dim: number): RuntimeValue;
-/** any/all on sparse matrix along a dimension.
- *  Returns sparse for dim=1, dense for dim=2. */
-export declare function sparseAnyAll(v: RuntimeSparseMatrix, dim: number, mode: "any" | "all"): RuntimeValue;
 /** Type check for reductions that return Num without dim arg, Tensor with dim arg. */
 /** Strip trailing 'omitnan'/'includenan' from args. Returns cleaned args and flag. */
 export declare function parseNanFlag(args: RuntimeValue[]): {
@@ -62,5 +59,6 @@ export declare function sliceKernel(sliceFn: (slice: ArrayLike<number>) => numbe
 export declare function accumKernelOmitNaN(reduceFn: (acc: number, val: number) => number, initial: number, finalizeFn?: (acc: number, count: number) => number): ReductionKernel;
 /** Create a slice kernel that filters NaN before applying the function. */
 export declare function sliceKernelOmitNaN(sliceFn: (slice: ArrayLike<number>) => number): ReductionKernel;
-/** Helper: extract all numeric values from a RuntimeValue as a plain array. */
+/** The values of a numeric or logical scalar or array as a plain array (real
+ *  parts only). Errors for other types. */
 export declare function toNumArray(v: RuntimeValue, name: string): number[];

package/dist-lib/numbl-core/helpers/shape-utils.d.ts

@@ -5,3 +5,13 @@ import { type RuntimeValue } from "../runtime/index.js";
 import { type RuntimeTensor } from "../runtime/types.js";
 /** Promote a scalar (number, logical, complex) to a 1×1 tensor. Tensors pass through. */
 export declare function coerceToTensor(v: RuntimeValue, name: string): RuntimeTensor;
+/** Validate one dimension value: MATLAB rejects NaN, Inf, and non-integer
+ *  sizes; negative integers are silently clamped to 0. */
+export declare function validateDim(x: number): number;
+/** Extract a single scalar dimension. With multiple size args MATLAB requires
+ *  each to be a scalar — a 1×1 array counts, but a multi-element vector errors
+ *  with "Size inputs must be scalar." */
+export declare function toScalarDim(v: RuntimeValue): number;
+/** Parse shape arguments: zeros(2,3) or zeros([2,3]) -> [2, 3].
+ *  Negative dimensions are clamped to 0. */
+export declare function parseShapeArgs(args: RuntimeValue[]): number[];

package/dist-lib/numbl-core/interpreter/builtins/index.d.ts

@@ -36,6 +36,8 @@ import "./misc.js";
 import "./dictionary.js";
 import "./hash.js";
 import "./help-text.js";
-export { getIBuiltin, getIBuiltinHelp, getIBuiltinNargin, getAllIBuiltinNames, registerBuiltinHelp, inferJitType, } from "./types.js";
+export { getIBuiltin, getIBuiltinHelp, getIBuiltinNargin, getAllIBuiltinNames, registerBuiltinHelp, inferJitType, inferDispatchType, } from "./types.js";
 export type { IBuiltin, IBuiltinResolution, BuiltinHelp } from "./types.js";
 export { resetAppdataStore, convertJsonValue } from "./misc.js";
+import "../../runtime/specialBuiltins.js";
+import "../../plotting/builtins.js";

package/dist-lib/numbl-core/interpreter/builtins/time-system.d.ts

@@ -3,4 +3,3 @@
  * ismac, ispc, isunix.
  */
 export declare function getTicTime(): number;
-export declare function setTicTime(ms: number): void;

package/dist-lib/numbl-core/interpreter/builtins/types.d.ts

@@ -20,16 +20,16 @@ export interface IBuiltin {
 }
 export declare function getIBuiltin(name: string): IBuiltin | undefined;
 export declare function registerIBuiltin(b: IBuiltin): void;
-/** Register a dynamic IBuiltin (e.g. .js user functions), replacing any
- *  existing entry with the same name without error. */
-export declare function registerDynamicIBuiltin(b: IBuiltin): void;
-export declare function unregisterIBuiltin(name: string): void;
 export declare function getAllIBuiltinNames(): string[];
 export declare function getIBuiltinHelp(name: string): BuiltinHelp | undefined;
 export declare function registerBuiltinHelp(name: string, help: BuiltinHelp): void;
 /** Probe an IBuiltin to determine its nargin (number of input args).
  *  Tries resolve with 1, 2, 3 number-type args to find the accepted count. */
 export declare function getIBuiltinNargin(name: string): number | undefined;
+/** Builtin dispatch only looks at the kind and class of a struct or object
+ *  argument, never its field types, so it skips the walk over the fields
+ *  that the JIT's specialization needs. */
+export declare function inferDispatchType(value: unknown): JitType;
 export declare function inferJitType(value: unknown): JitType;
 export declare function mkc(re: number, im: number): number | RuntimeComplexNumber;
 export declare function makeTensor(data: Float64Array, imag: Float64Array | undefined, shape: number[]): RuntimeTensor;
@@ -83,9 +83,9 @@ interface UnaryElemwiseSpec {
     };
     /** Use applyUnaryElemwiseMaybeComplex instead of applyUnaryElemwise */
     maybeComplex?: boolean;
-    /** Opcode for the native unaryElemwise dispatch (see unary_elemwise.cpp).
-     * Used by the maybeComplex path so that e.g. sqrt/log can run in native C
-     * on the common all-in-domain case, then fall back for NaN entries only. */
+    /** OpUnary code for the tensor-ops dispatch. Used by the maybeComplex path
+     * so that e.g. sqrt/log can run in native C on the common all-in-domain
+     * case, then fall back for NaN entries only. */
     nativeOpCode?: number;
 }
 /** Generate cases for a unary element-wise builtin. Each accepted kind gets

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

@@ -72,6 +72,10 @@ export declare class Interpreter {
      *  post-loop liveness scan can't see reads after the enclosing block —
      *  the classifier must then keep every loop-assigned name live-out. */
     condBlockDepth: number;
+    /** @internal Number of enclosing `try` bodies being executed, across
+     *  calls. The C-JIT declines while it is non-zero: a runtime error in
+     *  compiled C exits the process, so it can't be caught. */
+    tryDepth: number;
     /** @internal */
     functionDefCache: Map<string, FunctionDef>;
     /** @internal Pre-built line break tables for offset→line lookup per file. */
@@ -103,11 +107,6 @@ export declare class Interpreter {
     /** Bridge for loading native shared libraries. Undefined in browser
      *  contexts. */
     nativeBridge?: import("../workspace/types.js").NativeBridge;
-    /** Telemetry: invoked after a registered executor's `run()` succeeds.
-     *  Used to track which optimizers fire in a session. The kind is the
-     *  LoweredStmt kind the executor handled ("top-level", "loop", "call",
-     *  ...). Hot path — keep the callback cheap. */
-    onExecutorFired?: (name: string, kind: string) => void;
     /** Verbose log sink (plumbed from ExecOptions.log). */
     log?: (message: string) => void;
     /** Executor registry. Holds the strategies (JS-JIT, C-kernel, ...)
@@ -207,6 +206,7 @@ export declare class Interpreter {
         propertyDefaults: Map<string, Expr>;
     };
     isHandleClass: (classInfo: ClassInfo) => boolean;
-    evalInLocalScope: (codeArg: unknown, fileName?: string) => unknown;
+    evalPropertyDefault: (className: string, propName: string, defaultExpr: Expr) => RuntimeValue;
+    evalInLocalScope: (codeArg: unknown, fileName?: string, nargout?: number) => unknown;
     processArgumentsBlocks: (fn: FunctionDef, args: unknown[]) => void;
 }

package/dist-lib/numbl-core/interpreter/interpreterFunctions.d.ts

@@ -49,12 +49,20 @@ export declare function findFunctionInWorkspaceFile(this: Interpreter, wsName: s
 export declare function findFunctionInClassFile(this: Interpreter, className: string, funcName: string, methodScope?: string): FunctionDef | null;
 export declare function findMethodInClass(this: Interpreter, classInfo: ClassInfo, methodName: string): FunctionDef | null;
 export declare function findExternalMethod(this: Interpreter, classInfo: ClassInfo, methodName: string): FunctionDef | null;
+/** Evaluate a property's default value expression. MATLAB reports an
+ *  invalid default as an error rather than leaving the property unset. */
+export declare function evalPropertyDefault(this: Interpreter, className: string, propName: string, defaultExpr: Expr): RuntimeValue;
 export declare function collectClassProperties(this: Interpreter, classInfo: ClassInfo): {
     propertyNames: string[];
     propertyDefaults: Map<string, Expr>;
 };
 export declare function isHandleClass(this: Interpreter, classInfo: ClassInfo): boolean;
-export declare function evalInLocalScope(this: Interpreter, codeArg: unknown, fileName?: string): unknown;
+/** Run MATLAB text in the current scope (eval, evalin, run, input,
+ *  str2num). With `nargout` > 0 the text must be one expression, whose
+ *  value(s) are returned; otherwise its statements run (displaying
+ *  unsuppressed results) and nothing is returned. `fileName` sets the file
+ *  context, e.g. for `run(script)`. */
+export declare function evalInLocalScope(this: Interpreter, codeArg: unknown, fileName?: string, nargout?: number): unknown;
 /**
  * Apply `arguments`-block defaults and build name-value struct parameters,
  * binding the results into the *current* function environment.

package/dist-lib/numbl-core/interpreter/interpreterSpecialBuiltins.d.ts

@@ -9,7 +9,7 @@ export interface InterpreterContext {
     setEnv: (env: Environment) => void;
     callerEnv: Environment | undefined;
     workspaceEnv: Environment | undefined;
-    evalInLocalScope: (codeArg: unknown, fileName?: string) => unknown;
+    evalInLocalScope: (codeArg: unknown, fileName?: string, nargout?: number) => unknown;
     callFunction: (name: string, args: unknown[], nargout: number) => unknown;
     rt: Runtime;
     /** Optimization mode: "0" = no JIT, "1" = JS-JIT, "2" = C-JIT. */
@@ -18,8 +18,8 @@ export interface InterpreterContext {
      *  or undefined if no workspace file provides that name.
      *  `kind` distinguishes a regular .m function from a .numbl.js
      *  user function (treated as a MEX-equivalent) or a class file.
-     *  `source` is the raw .m source for "function"/"class" kinds, or empty
-     *  for "jsfunction" (where the implementation is JS, not .m text). */
+     *  `source` is the raw .m source for "function"/"class" kinds, or the
+     *  help text registered by a "jsfunction" (empty if none). */
     lookupWorkspaceFile: (name: string) => {
         path: string;
         kind: "function" | "jsfunction" | "class";
@@ -29,6 +29,9 @@ export interface InterpreterContext {
      *  ones, in declaration order. Returns undefined if `className` is not a
      *  known class. Backs `properties(obj)`. */
     classPublicProperties: (className: string) => string[] | undefined;
+    /** Public method names of a class (including inherited, static and the
+     *  constructor), or undefined if not a known class. Backs `ismethod`. */
+    classPublicMethods: (className: string) => Set<string> | undefined;
 }
 export declare const FALL_THROUGH: unique symbol;
 export type InterpreterSpecialBuiltinHandler = (ctx: InterpreterContext, args: unknown[], nargout: number) => unknown | typeof FALL_THROUGH;

package/dist-lib/numbl-core/jit/builtins/defs/_shared.d.ts

@@ -2,7 +2,7 @@
  * Helpers shared across multiple builtin files.
  */
 import type { Span } from "../../parser/index.js";
-import { type Type, type NumericType } from "../../lowering/types.js";
+import { type Type } from "../../lowering/types.js";
 export declare function requireScalarRealDouble(t: Type, what: string, span?: Span): void;
 /** Like `requireScalarRealDouble` but accepts non-scalar real doubles
  *  (the elemwise path). Logical also accepted (stored as double in C). */
@@ -37,7 +37,3 @@ export declare function exactScalarAsComplex(t: Type): {
     re: number;
     im: number;
 } | undefined;
-/** True when this numeric is statically known to be complex (the static
- *  flag, not the runtime value). Centralizes the predicate so callers
- *  don't sprinkle `(t as NumericType).isComplex` checks. */
-export declare function isStaticComplex(t: Type): t is NumericType;

package/dist-lib/numbl-core/jit/builtins/defs/arithmetic/_elemwise.d.ts

@@ -59,8 +59,7 @@ export declare function broadcastFoldExact(a: NumericType, b: NumericType, outSh
  *  `complexFold` / `complexScalarExpr` / `complexRuntimeDeps` are
  *  optional; when set, a scalar+scalar op with at least one complex
  *  operand routes through them (and `transfer` returns a complex
- *  result). Phase 1 wires complex scalars; tensor+complex paths are
- *  rejected until Phase 3 lands the runtime helpers.
+ *  result).
  */
 export declare function defineElemwiseRealBinary(opts: {
     name: string;

package/dist-lib/numbl-core/jit/builtins/defs/logical/_unary_pred.d.ts

@@ -5,9 +5,9 @@ interface ComplexPredSpec {
      *  to `1.0` / `0.0`. */
     cScalarComplex: (re: string, im: string) => string;
     /** JS scalar expression: same shape as `cScalarComplex` but for
-     *  the js-aot path; operates on real-and-imag JS expressions. */
+     *  the JS path; operates on real-and-imag JS expressions. */
     jsScalarComplex: (re: string, im: string) => string;
-    /** JS fold / interpreter rule on a `{re, im}` value. */
+    /** JS fold rule on a `{re, im}` value. */
     jsFnComplex: (re: number, im: number) => boolean;
     /** Runtime tensor helper name (in `tensor_predicate_complex.h`). */
     tensorHelperComplex: string;
@@ -18,7 +18,7 @@ export interface UnaryPredOpts {
     cScalar: (arg: string) => string;
     /** JS scalar expression given the arg's JS text. */
     jsScalar: (arg: string) => string;
-    /** JS fold / interpreter rule. */
+    /** JS fold rule. */
     jsFn: (x: number) => boolean;
     /** Runtime tensor helper name (in `tensor_predicate.h`). */
     tensorHelper: string;

package/dist-lib/numbl-core/jit/builtins/defs/logical/fieldnames.d.ts

@@ -5,7 +5,7 @@
  * cell-element type being `char` (matches MATLAB and the
  * interpreter, which also emits chars).
  *
- * Interpreter-only for now; the AOT path would need to materialize
+ * Interpreter-only for now; the JIT would need to materialize
  * a heterogeneous-len cell of chars which is a different feature
  * class. The `emitC` / `emitJs` hooks exist so the registry-shape
  * invariant holds but they raise `UnsupportedConstruct` rather than

package/dist-lib/numbl-core/jit/builtins/defs/logical/strcmp.d.ts

@@ -7,7 +7,7 @@
  *     error; the inputs simply compare unequal.
  *   - Either arg non-text → `false`. Numbl gates the comparison
  *     behind `isText(a) && isText(b)`; non-text just yields `0`
- *     silently. We mirror that to keep cross-runner output identical.
+ *     silently. We mirror that.
  *   - Cell-of-text vectorization (`strcmp({'a','b'}, 'a')`) is in
  *     numbl but cells aren't yet a feature class in mtoc2 — that
  *     overload will fall out naturally when cells land.

package/dist-lib/numbl-core/jit/builtins/defs/math/_unary_real.d.ts

@@ -5,8 +5,7 @@ export interface UnaryRealMathOpts {
     name: string;
     /** C `<math.h>` function name for the scalar path (e.g. `"cos"`). */
     cFnReal: string;
-    /** JS-side scalar fn for compile-time fold (and for the interpreter's
-     *  `call` hook). */
+    /** JS-side scalar fn for compile-time fold. */
     jsFn: (x: number) => number;
     /** Optional JS expression form (textual) for `emitJs`'s scalar real
      *  path. Defaults to `Math.${name}(arg)` which works for most names
@@ -14,6 +13,10 @@ export interface UnaryRealMathOpts {
      *  Override for `fix` (`Math.trunc`) and `round`
      *  (custom half-away-from-zero form). */
     jsExpr?: (arg: string) => string;
+    /** Optional `mtoc2_`-prefixed helper from `tensor_unary_real_math.js`
+     *  for `emitJs`'s scalar real path. Activates that snippet and takes
+     *  precedence over `jsExpr`. */
+    jsFnReal?: string;
     /** Sign refinement on the result type. Called with the (validated)
      *  real-numeric input type. */
     signRule: (t: NumericType) => Sign;

package/dist-lib/numbl-core/jit/builtins/defs/math/realsqrt.d.ts

@@ -0,0 +1,6 @@
+/** `realsqrt(x)`: square root that stays real. Unlike `sqrt`, an input
+ *  of unknown sign stays on the real path; a negative element raises
+ *  MATLAB's error at run time instead of lifting to complex. An input
+ *  known to be negative (sign or exact value) declines, so the
+ *  interpreter raises the error. */
+export declare const realsqrt: import("../../registry.js").Builtin;

package/dist-lib/numbl-core/jit/builtins/defs/reduction/_shape.d.ts

@@ -103,11 +103,6 @@ export declare function reductionEmitJs(spec: {
     dimArgIndex: 1 | 2;
     outputElem: "double" | "logical";
 }): Builtin["emitJs"];
-export declare function reductionCall(spec: {
-    name: string;
-    dimArgIndex: 1 | 2;
-    outputElem: "double" | "logical";
-}): Builtin["call"];
 export declare function reductionEmit(spec: {
     name: string;
     dimArgIndex: 1 | 2;

package/dist-lib/numbl-core/jit/builtins/defs/shape/_construct.d.ts

@@ -25,10 +25,6 @@
  * time gives a proper span.
  */
 import type { Builtin, InlineSnippet } from "../../registry.js";
-/** Runtime dim validation for the interpreter-shim `call` path —
- *  mirrors the emitted `mtoc2_check_dim` and the interpreter's
- *  `validateDim`: reject non-finite / non-integer, clamp negative to 0. */
-export declare function checkDimRuntime(x: number): number;
 /** Runtime dim validator shared by both backends. Mirrors the
  *  interpreter's `validateDim` (interpreter/builtins/array-construction.ts):
  *  a non-finite or non-integer size is an error, a negative size clamps

package/dist-lib/numbl-core/jit/builtins/defs/shape/_triangular.d.ts

@@ -5,7 +5,7 @@
  *
  *   - argument validation (1..2 args, real-double tensor, k literal int)
  *   - `transfer` (exact-fold when input data fits)
- *   - hooks builders (emitC / emitJs / call) parameterized by the
+ *   - hooks builders (emitC / emitJs) parameterized by the
  *     family-specific predicate + runtime helper.
  *
  * Mirrors `triPart` in numbl's
@@ -13,8 +13,6 @@
  * both supported; sparse inputs and rank > 2 are deferred / rejected.
  */
 import type { Builtin } from "../../registry.js";
-import type { RuntimeTensor } from "../../../runtime/value.js";
-import { mtoc2_tensor_triu as jsTriu, mtoc2_tensor_tril as jsTril, mtoc2_tensor_triu_complex as jsTriuComplex, mtoc2_tensor_tril_complex as jsTrilComplex } from "../../runtime/snippets.gen.js";
 interface TriangularSpec {
     /** Source-level name (registry key). */
     name: string;
@@ -25,10 +23,6 @@ interface TriangularSpec {
     cHelperComplex: string;
     /** Keep predicate matching numbl's `triPart` (column-major i,j). */
     keep(i: number, j: number, k: number): boolean;
-    /** JS-side helper for real input. */
-    jsHelper: (a: RuntimeTensor, k: number) => unknown;
-    /** JS-side helper for complex input. */
-    jsHelperComplex: (a: RuntimeTensor, k: number) => unknown;
 }
 export declare function defineTriangular(spec: TriangularSpec): Builtin;
-export { jsTriu, jsTril, jsTriuComplex, jsTrilComplex };
+export {};

package/dist-lib/numbl-core/jit/builtins/defs/system/deal.d.ts

@@ -10,11 +10,10 @@
  * it's a runtime error. mtoc2 lifts the equality check into
  * `transfer` so the mismatch is a type-time error.
  *
- * The result types are the input types as-is. The c-aot backend
- * still has to emit `_copy(...)` for owned types to satisfy the
- * "freshly-owned at every consume site" invariant; the js-aot
- * backend uses `mtoc2_deep_clone` for the same reason; the
- * interpreter follows numbl and deep-clones owned values too.
+ * The result types are the input types as-is. The C backend still
+ * has to emit `_copy(...)` for owned types to satisfy the
+ * "freshly-owned at every consume site" invariant; the JS backend
+ * uses `mtoc2_deep_clone` for the same reason.
  */
 import type { Builtin } from "../../registry.js";
 export declare const deal: Builtin;

package/dist-lib/numbl-core/jit/builtins/defs/system/feval.d.ts

@@ -2,35 +2,13 @@
  * feval(handle_or_name, args...) — invoke a function handle (or a
  * function named by a char) with the given args.
  *
- * Implementation strategy:
- *
- *   The c-aot / js-aot backends cannot route through a builtin
- *   emitC / emitJs hook because invoking a user function requires
- *   specialization (the target's mangled C name is created at
- *   lowering time, with the actual arg types) — information a
- *   builtin emit hook doesn't have access to. So the lowerer
- *   intercepts `feval(...)` in `lowerFuncCall` and
- *   `lowerMultiAssign` and rewrites it to a direct call on the
- *   underlying handle / function name (see `tryLowerFevalCall` in
- *   `src/lowering/lowerFuncCall.ts`). Once the rewrite fires, the
- *   builtin's emit hooks are never reached.
- *
- *   The interpreter parallels this with a special-case in
- *   `callByName` (next to the existing `struct` / `cell`
- *   special-cases) — it consumes args[0] as a handle or char,
- *   dispatches via `callHandle` or recursively via `callByName`,
- *   and threads `nargout` through. Once that fires, this builtin's
- *   `call` hook is unreachable.
- *
- *   This file therefore exists primarily to:
- *     - keep `feval` in `allBuiltinNames()` for syntax highlighting
- *       and the `@feval` rejection path,
- *     - validate arity / argument shape via `transfer` as a safety
- *       net if a future codepath bypasses the lowerer / interpreter
- *       interception.
- *
- *   All four hooks raise `UnsupportedConstruct` with a message
- *   pointing the reader at where the real implementation lives.
+ * The lowerer intercepts `feval(...)` in `lowerFuncCall` and
+ * `lowerMultiAssign` and rewrites it to a direct call on the
+ * underlying handle / function name (see `tryLowerFevalCall`), since
+ * invoking a user function needs specialization that a builtin emit
+ * hook can't do. This def exists to keep `feval` in
+ * `allBuiltinNames()` and as a safety net: every hook raises
+ * `UnsupportedConstruct`.
  */
 import type { Builtin } from "../../registry.js";
 export declare const feval: Builtin;

package/dist-lib/numbl-core/jit/builtins/registry.d.ts

@@ -1,8 +1,7 @@
 /**
- * Builtin registry — the contract every mtoc2 builtin (and future
- * user `.mtoc2.js` function) implements.
+ * Builtin registry — the contract every JIT builtin implements.
  *
- * Each builtin can supply up to three mirrored hooks plus the
+ * Each builtin can supply two mirrored codegen hooks plus the
  * always-required `transfer`:
  *
  *   transfer(argTypes, nargout) — required. Given input types and
@@ -32,15 +31,9 @@
  *     outputs land in these locals via the framework's destructuring
  *     wrapper. Activates JS-side runtime snippets via `useRuntime`.
  *
- *   call({args, argTypes, nargout, ctx}) — optional. Direct JS
- *     function used by the interpreter and as a JIT bailout target.
- *     Returns one runtime value per output slot. The args shape
- *     mirrors the emit hooks' shape so dispatch on `argTypes` /
- *     `nargout` stays parallel across all three.
- *
- *   elementwise? — when true, every defined emit hook (and `call`)
- *     must also produce a correct scalar output when called with
- *     scalar argTypes and scalar argsC/argsJs/args. The framework
+ *   elementwise? — when true, every defined emit hook must also
+ *     produce a correct scalar output when called with
+ *     scalar argTypes and scalar argsC/argsJs. The framework
  *     uses this for same-shape tensor fusion (and, later, broadcast
  *     / reduction-inner / mask / stencil fusion). Absence = "do not
  *     fuse me; use the regular emit on the full tensor types."
@@ -50,8 +43,6 @@
  * computes the maximum compatible backend per call site.
  */
 import type { Type } from "../lowering/types.js";
-import type { RuntimeValue } from "../runtime/value.js";
-import type { RuntimeContext } from "../runtime/context.js";
 /** Common across every hook — the type-level call descriptor. */
 interface CommonArgs {
     /** Per-arg type (after lowering / inference). */
@@ -71,7 +62,7 @@ export interface EmitCArgs extends CommonArgs {
     outArgsC?: string[];
     /** Activate a runtime C snippet on the current translation unit.
      *  See `runtime.ts` for the registry and `InlineSnippet` for the
-     *  user-supplied form. */
+     *  inline form. */
     useRuntime(spec: string | InlineSnippet): void;
 }
 export interface EmitJsArgs extends CommonArgs {
@@ -90,14 +81,6 @@ export interface EmitJsArgs extends CommonArgs {
      *  (with a `jsCode` body) defines a one-off helper from a builtin. */
     useRuntime(spec: string | InlineSnippet): void;
 }
-export interface CallArgs extends CommonArgs {
-    /** Per-arg runtime values, evaluated by the interpreter at the
-     *  call site. */
-    args: RuntimeValue[];
-    /** Host bag — `helpers.write` for stdout, future hooks for plot /
-     *  error / time. */
-    ctx: RuntimeContext;
-}
 export interface Builtin {
     /** Source-level name (registry key). */
     name: string;
@@ -109,13 +92,18 @@ export interface Builtin {
     emitC?(args: EmitCArgs): string;
     /** Optional: JS codegen. */
     emitJs?(args: EmitJsArgs): string;
-    /** Optional: direct JS function — interpreter / JIT bailout. */
-    call?(args: CallArgs): RuntimeValue[];
     /** Elementwise = result is computed pointwise. */
     elementwise?: boolean;
+    /** Optional: elementwise for these argument types only, for a builtin
+     *  whose forms differ by arity (two-argument `max(a, b)` is pointwise,
+     *  one-argument `max(a)` is a reduction). Consulted when `elementwise`
+     *  is not set. */
+    isElementwiseCall?(argTypes: Type[]): boolean;
 }
-/** Inline-defined runtime snippet supplied by a user `.mtoc2.js`
- *  builtin's `emitC` / `emitJs`. Re-exported from `runtime.ts` — kept
+/** Whether a call of `b` with these argument types is computed pointwise. */
+export declare function isElementwiseCall(b: Builtin, argTypes: Type[]): boolean;
+/** Inline-defined runtime snippet supplied by an emitter via
+ *  `useRuntime({...})`. Re-exported from `runtime.ts` — kept
  *  here for doc-locality with the `Builtin` contract. */
 export interface InlineSnippet {
     name: string;
@@ -130,9 +118,6 @@ export declare function registerBuiltin(b: Builtin): void;
 export declare function getBuiltin(name: string): Builtin | undefined;
 /** Names of every registered builtin. Drives Monaco syntax highlighting. */
 export declare function allBuiltinNames(): readonly string[];
-export type Backend = "c" | "js" | "interpreter";
-export declare function builtinSupports(b: Builtin, backend: Backend): boolean;
 export declare function requireEmitC(b: Builtin): (args: EmitCArgs) => string;
 export declare function requireEmitJs(b: Builtin): (args: EmitJsArgs) => string;
-export declare function requireCall(b: Builtin): (args: CallArgs) => RuntimeValue[];
 export {};

package/dist-lib/numbl-core/jit/builtins/runtime/system/cdiv.d.ts

@@ -2,3 +2,7 @@ export function mtoc2_cdiv(a: any, b: any): {
     re: number;
     im: number;
 };
+export function mtoc2_cdiv_mixed(a: any, b: any): {
+    re: number;
+    im: number;
+};

package/dist-lib/numbl-core/jit/builtins/runtime/system/cscalar.d.ts

@@ -16,6 +16,10 @@ export function mtoc2_cmul(a: any, b: any): {
     re: number;
     im: number;
 };
+export function mtoc2_cmul_mixed(a: any, b: any): {
+    re: number;
+    im: number;
+};
 export function mtoc2_cneg(z: any): {
     re: number;
     im: number;