numbl 0.4.19 → 0.4.22

package/dist-browser/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-browser/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-browser/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-browser/numbl-core/helpers/sparse-direct.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Sparse direct solvers on the CSC representation (real arithmetic):
+ * Kronecker product, structural triangularity checks, triangular solves,
+ * up-looking sparse Cholesky, left-looking sparse LU with partial pivoting
+ * (Gilbert-Peierls), permutations, fill-reducing orderings (minimum degree,
+ * reverse Cuthill-McKee), and the `A \ b` driver used by mldivide.
+ *
+ * Complex sparse matrices are not handled here; callers fall back to the
+ * dense path for them.
+ */
+import { type RuntimeSparseMatrix, type RuntimeTensor, type SparseTriInfo } from "../runtime/types.js";
+type Sp = RuntimeSparseMatrix;
+export declare const SINGULAR_WARNING = "Matrix is singular to working precision.";
+/** Convert a dense tensor to CSC (dropping zeros). */
+export declare function denseToSparse(t: RuntimeTensor): Sp;
+/** Build CSC from column-major dense data, dropping zeros. */
+export declare function denseDataToSparse(data: Float64Array, m: number, n: number): Sp;
+/** Sparse permutation matrix P with P(k, p[k]) = 1, so (P*A)(k,:) = A(p[k],:). */
+export declare function permutationMatrix(p: Int32Array | number[]): Sp;
+/** 1-based row vector from a 0-based permutation. */
+export declare function permVectorTensor(p: Int32Array): RuntimeTensor;
+export declare function invertPerm(p: Int32Array): Int32Array;
+/** C = A(p, q) for 0-based permutations p (rows) and q (columns). */
+export declare function sparsePermute(A: Sp, p: Int32Array, q: Int32Array): Sp;
+export declare function sparseKron(A: Sp, B: Sp): Sp;
+/**
+ * One O(nnz) pass over the pattern: is the matrix upper / lower triangular
+ * (explicitly stored zeros ignored), and where is each diagonal entry. The
+ * result is cached on the matrix object.
+ */
+export declare function triangularInfo(S: Sp): SparseTriInfo;
+/** True if every stored nonzero lies on or above the diagonal. */
+export declare function sparseIsUpper(S: Sp): boolean;
+/** True if every stored nonzero lies on or below the diagonal. */
+export declare function sparseIsLower(S: Sp): boolean;
+/** Exact numerical symmetry (A == A'), real sparse only. */
+export declare function sparseIsSymmetric(S: Sp): boolean;
+/** Solve R * X = B for upper-triangular R (n×n), B column-major n×nrhs.
+ *  Returns the solution in a fresh array and whether a zero pivot was hit. */
+export declare function sparseSolveUpper(R: Sp, B: Float64Array, nrhs: number): {
+    x: Float64Array;
+    singular: boolean;
+};
+/** Solve L * X = B for lower-triangular L (n×n). */
+export declare function sparseSolveLower(L: Sp, B: Float64Array, nrhs: number): {
+    x: Float64Array;
+    singular: boolean;
+};
+export interface CholResult {
+    /** Lower factor with L * L' = A (only when ok). */
+    L: Sp;
+    ok: boolean;
+    /** 0 on success, otherwise the 1-based column at which the pivot failed. */
+    p: number;
+}
+/**
+ * Cholesky factorization of a symmetric positive definite sparse matrix.
+ * Only the upper triangle of A is read; symmetry is not checked. On failure
+ * returns the leading (p-1)×(p-1) factor computed so far.
+ */
+export declare function sparseChol(A: Sp): CholResult;
+export interface LuResult {
+    /** Unit lower triangular, m × min(m,n), rows in pivot order. */
+    L: Sp;
+    /** Upper triangular, min(m,n) × n. */
+    U: Sp;
+    /** Row permutation: row k of P*A*Q is row p[k] of A. */
+    p: Int32Array;
+    /** Column permutation: column k of P*A*Q is column q[k] of A. */
+    q: Int32Array;
+    singular: boolean;
+}
+/**
+ * LU factorization P*A*Q = L*U of a real sparse matrix with threshold
+ * partial pivoting (tol = 1 is plain partial pivoting; smaller values prefer
+ * the diagonal entry when it is at least tol times the largest candidate).
+ */
+export declare function sparseLu(A: Sp, q: Int32Array | null, tol: number): LuResult;
+export declare function identityPerm(n: number): Int32Array;
+/**
+ * Minimum degree ordering on the pattern of A + A', computed on an explicit
+ * elimination graph. Returns a 0-based permutation p such that A(p,p) tends
+ * to have a sparser Cholesky factor. This is a plain minimum-degree
+ * ordering, not MATLAB's approximate minimum degree, so the permutation
+ * differs from MATLAB's `amd` while serving the same purpose.
+ */
+export declare function minimumDegreeOrdering(A: Sp): Int32Array;
+/**
+ * Reverse Cuthill-McKee ordering on the pattern of A + A'. Returns a 0-based
+ * permutation that tends to reduce the bandwidth of A(p,p).
+ */
+export declare function reverseCuthillMcKee(A: Sp): Int32Array;
+/** Column ordering for LU: minimum degree on the pattern of A'*A. */
+export declare function columnOrdering(A: Sp): Int32Array;
+/**
+ * Solve A * X = B for square real sparse A and dense B (n × nrhs,
+ * column-major). Returns null when the caller should use the dense path
+ * (non-square, complex, or nearly full A).
+ */
+export declare function sparseSolve(A: Sp, B: Float64Array, nrhs: number): Float64Array | null;
+/** Solve with precomputed LU factors: X = Q * U \ (L \ (P * B)). */
+export declare function luSolve(lu: LuResult, B: Float64Array, nrhs: number): Float64Array;
+/** Solve with LU factors of A for the transposed system A' * X = B. */
+export declare function luSolveTransposed(lu: LuResult, B: Float64Array, nrhs: number): Float64Array;
+/** Inverse of a square real sparse matrix, returned sparse. */
+export declare function sparseInverse(A: Sp): Sp;
+export {};

package/dist-browser/numbl-core/helpers/warn.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MATLAB-style warnings from helper code that has no Runtime handle.
+ *
+ * The Runtime installs a sink that routes messages through its output
+ * channel ("Warning: <msg>"); before a Runtime exists, messages fall back
+ * to console.warn.
+ */
+export declare function setWarningSink(fn: (msg: string) => void): void;
+export declare function emitWarning(msg: string): void;

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

@@ -27,6 +27,7 @@ import "./cell-struct.js";
 import "./time-system.js";
 import "./datetime.js";
 import "./sparse.js";
+import "./sparse-solvers.js";
 import "./graph.js";
 import "./gallery.js";
 import "./special-math.js";
@@ -35,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-browser/numbl-core/interpreter/builtins/sparse-solvers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Sparse direct-solver builtins: fill-reducing orderings (symrcm, amd,
+ * colamd), random sparse matrices (sprand, sprandn, sprandsym), and the
+ * `decomposition` object that stores factors for repeated solves.
+ *
+ * The factorizations themselves live in helpers/sparse-direct.ts; chol, lu,
+ * kron, inv and the operators `\` and `/` dispatch to them from
+ * linear-algebra.ts and helpers/arithmetic.ts.
+ */
+import type { RuntimeValue } from "../../runtime/types.js";
+/**
+ * Hook for the mldivide / mrdivide operator builtins: `dA \ B` and `B / dA`
+ * with a decomposition object. Returns undefined when neither operand is a
+ * decomposition so the ordinary operator runs.
+ */
+export declare function tryDecompositionDivide(name: "mldivide" | "mrdivide", a: RuntimeValue, b: RuntimeValue): RuntimeValue | undefined;

package/dist-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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-browser/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;