numbl 0.4.5 → 0.4.7

package/dist-lib/numbl-core/executors/plugins.d.ts

@@ -10,6 +10,15 @@
  * registered executor.
  */
 import type { Registry } from "./registry.js";
+import type { Executor } from "./types.js";
+/** The three C-JIT executors, registered at Node bootstrap. */
+export interface CJitExecutors {
+    topLevel: Executor;
+    loop: Executor;
+    call: Executor;
+}
+/** Register the C-JIT executors. Called once at Node bootstrap. */
+export declare function registerCJitExecutors(execs: CJitExecutors): void;
 /** Optimization mode label.
  *
  *   - `"0"` — pure AST interpreter, no executors registered.

package/dist-lib/numbl-core/helpers/marching-cubes-tables.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Marching-cubes lookup tables (Paul Bourke / Lorensen-Cline).
+ *
+ * Vendored verbatim from mikolalysenko/isosurface (MIT). Generated from
+ * lib/marchingcubes.js; do not edit by hand.
+ */
+export declare const edgeTable: Uint32Array<ArrayBuffer>;
+export declare const triTable: number[][];
+export declare const cubeVerts: number[][];
+export declare const edgeIndex: number[][];

package/dist-lib/numbl-core/helpers/marching-cubes.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Marching cubes over a regular scalar grid, plus the MATLAB `isosurface`
+ * argument parsing. Backs the `isosurface` builtin.
+ *
+ * The 256-case lookup tables are vendored in `marching-cubes-tables.ts`
+ * (MIT, mikolalysenko/isosurface — Paul Bourke's classic table). The loop
+ * here adds the two things that library lacks for our use:
+ *   - vertices interpolated from arbitrary X/Y/Z coordinate arrays (so it is
+ *     correct for ndgrid, meshgrid, vector, and implicit grids), and
+ *   - cross-cell vertex sharing (keyed by grid-edge identity), which MATLAB
+ *     produces by default and which downstream code (e.g. triangle adjacency)
+ *     relies on.
+ */
+import type { RuntimeValue } from "../runtime/types.js";
+export interface IsoMesh {
+    /** Physical vertex coordinates, one `[x, y, z]` per vertex. */
+    vertices: number[][];
+    /** Triangles as 0-based vertex-index triples. */
+    faces: number[][];
+    /** Per-vertex scalar color data (present only when a colors array is given). */
+    colors?: number[];
+}
+type ScalarFn = (i: number, j: number, k: number) => number;
+type CoordFn = (i: number, j: number, k: number) => [number, number, number];
+/**
+ * Extract the isosurface of `getVal` at `iso` over an `m×n×p` grid.
+ * `getCoord` maps a grid corner to its physical position; `getColor` (if
+ * given) supplies a scalar field interpolated onto the surface vertices.
+ */
+export declare function marchingCubes(dims: [number, number, number], getVal: ScalarFn, getCoord: CoordFn, iso: number, opts?: {
+    share?: boolean;
+    getColor?: ScalarFn;
+}): IsoMesh;
+/**
+ * Parse `isosurface(...)` arguments and compute the mesh.
+ *
+ * Forms (by numeric-argument count, after stripping 'verbose'/'noshare'):
+ *   1: isosurface(V)               4: isosurface(X,Y,Z,V)
+ *   2: isosurface(V,iso)           5: isosurface(X,Y,Z,V,iso)
+ *   3: isosurface(V,iso,colors)    6: isosurface(X,Y,Z,V,iso,colors)
+ *
+ * When the isovalue is omitted it is chosen automatically (see autoIsovalue) —
+ * an approximation that does not match MATLAB's exact histogram heuristic.
+ */
+export declare function isosurfaceFromArgs(args: RuntimeValue[]): IsoMesh;
+export {};

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

@@ -1,4 +1,10 @@
 /**
  * Array construction builtins: zeros, ones, nan/NaN, eye, linspace, logspace.
  */
-export {};
+import type { RuntimeValue } from "../../runtime/types.js";
+import type { JitType } from "../../jitTypes.js";
+/** Drop a trailing class-name spec from the JIT arg types (used in `match`
+ *  so the size cases still apply when a class string is present). */
+export declare function stripClassNameTypes(argTypes: JitType[]): JitType[];
+/** Drop a trailing class-name spec from the runtime args (used in `apply`). */
+export declare function stripClassNameArgs(args: RuntimeValue[]): RuntimeValue[];

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

@@ -0,0 +1,7 @@
+/**
+ * gallery — families of test matrices.
+ *
+ * Currently implements the 'tridiag' family (sparse tridiagonal matrices),
+ * which is the variant exercised by library code such as M-M.E.S.S.
+ */
+export {};

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

@@ -0,0 +1,10 @@
+/**
+ * Interpreter IBuiltins for computational geometry functions: delaunay,
+ * delaunayn, convhull, convhulln, inpolygon.
+ *
+ * delaunay/delaunayn/convhull/convhulln are backed by the qhull WASM module,
+ * installed at startup (see geometry-bridge.ts and the qhull-node /
+ * qhull-browser loaders). The backend must be installed before these builtins
+ * run; otherwise they throw.
+ */
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * Undirected graph object (`graph`) and a subset of its methods.
+ *
+ * MATLAB's `graph` is a value class representing an undirected graph. Here a
+ * graph is a class_instance with className="graph" and three internal fields:
+ *   _n         number of nodes
+ *   _A         symmetric weighted adjacency as a RuntimeSparseMatrix
+ *   _weighted  whether the graph carries edge weights
+ *
+ * Supported constructors:
+ *   graph()                          empty graph
+ *   graph(A)                         adjacency matrix (A must be symmetric)
+ *   graph(A, 'omitselfloops')        drop the diagonal
+ *   graph(A, 'upper' | 'lower')      read one triangle of A
+ *   graph(s, t)                      edge list (unweighted)
+ *   graph(s, t, w)                   edge list (weighted)
+ *   graph(s, t, w, num)              edge list, num nodes
+ *
+ * Supported methods (called as functions, e.g. conncomp(G)):
+ *   conncomp(G) / [bins, sizes] = conncomp(G)   connected components
+ *   laplacian(G)                                 graph Laplacian (unweighted)
+ *   addedge(G, s, t [, w])                       add edges, returns a new graph
+ *   numnodes(G), numedges(G)                     counts
+ *   degree(G)                                    per-node degree (column vector)
+ *
+ * Note: laplacian ignores edge weights (uses the binary adjacency and the
+ * node-degree count), matching MATLAB.
+ */
+export {};

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

@@ -27,7 +27,10 @@ import "./cell-struct.js";
 import "./time-system.js";
 import "./datetime.js";
 import "./sparse.js";
+import "./graph.js";
+import "./gallery.js";
 import "./special-math.js";
+import "./geometry.js";
 import "./misc.js";
 import "./dictionary.js";
 import "./help-text.js";

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

@@ -34,6 +34,10 @@ export declare class Interpreter {
     workspaceEnv: Environment | undefined;
     /** @internal The caller's environment — for evalin/assignin('caller', ...) */
     callerEnv: Environment | undefined;
+    /** @internal Call-site variable names for the next user-function call, set
+     *  by `evalFuncCall` and consumed by `callUserFunction` to support
+     *  `inputname`. One-shot: cleared as soon as it is consumed. */
+    pendingInputNames: string[] | undefined;
     /** @internal Stack of [base, dimIndex, numIndices] for resolving `end` keyword in indexing. */
     endContextStack: Array<{
         base: unknown;
@@ -119,6 +123,7 @@ export declare class Interpreter {
     evalBinary: (expr: Extract<Expr, {
         type: "Binary";
     }>) => unknown;
+    evalCondition: (expr: Expr) => unknown;
     evalUnary: (expr: Extract<Expr, {
         type: "Unary";
     }>) => unknown;
@@ -156,6 +161,7 @@ export declare class Interpreter {
     switchMatch: (switchVal: unknown, caseVal: unknown) => boolean;
     isOutputExpr: (expr: Expr) => boolean;
     callFunction: (name: string, args: unknown[], nargout: number) => unknown;
+    declaredNargin: (name: string) => number | undefined;
     interpretTarget: (target: ResolvedTarget, args: unknown[], nargout: number) => unknown;
     interpretLocalFunction: (target: Extract<ResolvedTarget, {
         kind: "localFunction";

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

@@ -4,7 +4,7 @@
  */
 import type { Stmt, Expr, LValue } from "../parser/types.js";
 import type { RuntimeValue } from "../runtime/types.js";
-import { type ControlSignal } from "./types.js";
+import { Environment, type ControlSignal } from "./types.js";
 import type { Interpreter } from "./interpreter.js";
 export declare function execStmt(this: Interpreter, stmt: Stmt): ControlSignal | null;
 export declare function execStmts(this: Interpreter, stmts: Stmt[]): ControlSignal | null;
@@ -16,10 +16,34 @@ export declare function execStmts(this: Interpreter, stmts: Stmt[]): ControlSign
 export declare function execBlockStmts(this: Interpreter, stmts: Stmt[]): ControlSignal | null;
 export declare function evalExpr(this: Interpreter, expr: Expr): unknown;
 export declare function evalExprNargout(this: Interpreter, expr: Expr, nargout: number): unknown;
+/** Compute the call-site variable names for `inputname`, aligned to the
+ *  argument expressions. Entry i is the name of the variable passed as
+ *  argument i+1, or '' if that argument is not a plain workspace variable.
+ *
+ *  Per MATLAB: an argument that uses cell `{}` or dot `.` indexing produces
+ *  a comma-separated list, making the position of every following argument
+ *  dynamic — so that argument and all subsequent ones report ''. Plain
+ *  literals, expressions, and paren-indexing report '' only for themselves.
+ *
+ *  The returned array may be shorter than the flattened arg count (when an
+ *  argument expanded to a CSL); callers treat out-of-range indices as ''.
+ */
+export declare function computeInputNames(argExprs: Expr[], callerEnv: Environment): string[];
 export declare function evalArgs(this: Interpreter, argExprs: Expr[]): unknown[];
 export declare function evalBinary(this: Interpreter, expr: Extract<Expr, {
     type: "Binary";
 }>): unknown;
+/**
+ * Evaluate an `if`/`while`/`elseif` condition.
+ *
+ * MATLAB short-circuits the element-wise `&` and `|` operators when they
+ * appear at the top of a conditional expression and the left operand is
+ * scalar — e.g. `if nargin<4 | isempty(x)` must NOT evaluate `isempty(x)`
+ * when `nargin<4` (otherwise `x` may be undefined). Outside this context
+ * `&`/`|` evaluate both operands element-wise, so the special handling
+ * lives here rather than in `evalBinary`.
+ */
+export declare function evalCondition(this: Interpreter, expr: Expr): unknown;
 export declare function evalUnary(this: Interpreter, expr: Extract<Expr, {
     type: "Unary";
 }>): unknown;

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

@@ -8,6 +8,12 @@ import type { ClassInfo } from "../lowering/classInfo.js";
 import { Environment, type FunctionDef } from "./types.js";
 import type { Interpreter } from "./interpreter.js";
 export declare function callFunction(this: Interpreter, name: string, args: unknown[], nargout: number): unknown;
+/** Declared input count of the user function a `@name` handle points to,
+ *  resolved the same way a call to `name` would resolve. Returns undefined
+ *  when the target is a builtin or otherwise has no resolvable user-function
+ *  AST (caller falls back to probing / 0). Used to populate
+ *  `nargin(@name)`. */
+export declare function declaredNargin(this: Interpreter, name: string): number | undefined;
 export declare function interpretTarget(this: Interpreter, target: ResolvedTarget, args: unknown[], nargout: number): unknown;
 export declare function interpretJsUserFunction(this: Interpreter, target: Extract<ResolvedTarget, {
     kind: "jsUserFunction";

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

@@ -25,6 +25,10 @@ export interface InterpreterContext {
         kind: "function" | "jsfunction" | "class";
         source: string;
     } | undefined;
+    /** Public (GetAccess public) property names of a class, including inherited
+     *  ones, in declaration order. Returns undefined if `className` is not a
+     *  known class. Backs `properties(obj)`. */
+    classPublicProperties: (className: string) => 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/interpreter/types.d.ts

@@ -41,12 +41,25 @@ export declare class Environment {
     set persistentNames(v: Set<string>);
     /** Function ID for persistent variable storage */
     persistentFuncId: string | undefined;
+    /** Call-site variable names of this frame's arguments, for `inputname`.
+     *  Entry i is the name of the variable passed as argument i+1, or '' if
+     *  that argument was not a plain variable. Undefined when the call did
+     *  not originate from an interpreted call expression (e.g. feval, JIT).
+     *  Read directly off the executing frame — the interpreter has only
+     *  function-level scoping, so `this.env` is the frame while a body runs. */
+    inputArgNames: string[] | undefined;
     /** Back-reference to the runtime (needed for global/persistent access) */
     rt: Runtime | null;
     /** Set when a `@nestedFn` handle has been created that captures this env
      *  (or an ancestor). Tells the function-exit cleanup that clearing this
      *  env would strand the handle's closure, so locals must be left alive. */
     nestedHandleCreated: boolean;
+    /** For a nested-function frame: the names of this function's own formal
+     *  input/output arguments. These are always local — a write must never be
+     *  redirected to a same-named variable in the parent, even before the
+     *  output has been assigned. (MATLAB scopes a nested function's formal
+     *  arguments to that function; only other variables are shared.) */
+    nestedLocalNames: Set<string> | undefined;
     constructor(parent?: Environment | undefined);
     get(name: string): RuntimeValue | undefined;
     /** Set variable — for nested scopes, writes to parent if variable

package/dist-lib/numbl-core/jit/builtins/runtime/snippets.c.gen.d.ts

@@ -0,0 +1,4 @@
+/** C snippet bodies, keyed by basename (e.g. `disp_double.h`).
+ *  C-JIT only (`--opt 2`, Node). Registered at bootstrap via
+ *  `setCSnippets` so the browser bundle never pulls it in. */
+export declare const C_SNIPPETS: Record<string, string>;

package/dist-lib/numbl-core/jit/builtins/runtime/snippets.gen.d.ts

@@ -72,8 +72,6 @@ export * from "./tensor_ops/tensor_var.js";
 export * from "./tensor_ops/tensor_zeros_nd.js";
 export * from "./tensor_ops/tensor_zeros_square.js";
 export * from "./text/strcmp.js";
-/** C snippet bodies, keyed by basename (e.g. `disp_double.h`). */
-export declare const C_SNIPPETS: Record<string, string>;
 /** JS snippet bodies (with `export` keywords stripped), keyed by
  *  basename (e.g. `disp_double.js`). Inlined into emitted JS. The
  *  functions may reference host hooks (`$write`, …) as free

package/dist-lib/numbl-core/jit/codegen/runtime.d.ts

@@ -14,6 +14,8 @@
  * pulls dependencies in first.
  */
 import type { Builtin } from "../builtins/registry.js";
+/** Register the C runtime-snippet table. Called once at Node bootstrap. */
+export declare function setCSnippets(snippets: Record<string, string>): void;
 /** Minimal Workspace shape consulted at emit time. Importing the
  *  concrete Workspace class would create a cycle (workspace ↔ codegen);
  *  the structural type below captures exactly what codegen needs. */

package/dist-lib/numbl-core/lowering/classInfo.d.ts

@@ -18,9 +18,10 @@ export interface ClassInfo {
     methodNames: Set<string>;
     staticMethodNames: Set<string>;
     constructorName: string | null;
-    ast: Stmt & {
+    ast: (Stmt & {
         type: "ClassDef";
-    };
+    }) | null;
+    isOldStyle?: boolean;
     inferiorClasses: string[];
     externalMethodFiles: Map<string, {
         fileName: string;
@@ -34,3 +35,19 @@ export interface ClassInfo {
 export declare function extractClassInfo(classDef: Stmt & {
     type: "ClassDef";
 }, qualifiedName: string, fileName: string, source: string): ClassInfo;
+/**
+ * Build ClassInfo for an old-style (pre-classdef) `@ClassName` folder class.
+ * There is no classdef AST: the constructor is the `@Name/Name.m` plain
+ * function (which calls `obj = class(struct, 'Name')`), and every other `.m`
+ * in the folder is an external method dispatched on instances. Fields are
+ * dynamic (defined by the constructor's struct), so there are no declared
+ * property names.
+ */
+export declare function makeOldStyleClassInfo(qualifiedName: string, baseName: string, constructorFile: {
+    fileName: string;
+    source: string;
+}, methodFiles: {
+    name: string;
+    fileName: string;
+    source: string;
+}[]): ClassInfo;

package/dist-lib/numbl-core/native/geometry-bridge.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Geometry bridge — a module-level singleton that holds the Delaunay
+ * triangulation backend.
+ *
+ * Startup (CLI, browser worker, test-runner) loads the qhull WASM module
+ * (exact, robust to cospherical/coplanar input) and installs it here. The
+ * builtins require it: if no backend is set, delaunay/delaunayn throw.
+ *
+ * Usage (startup):
+ *   import { setDelaunayBackend } from './numbl-core/native/geometry-bridge.js';
+ *   const qhull = await loadQhull();
+ *   setDelaunayBackend((points, dim) => qhull.delaunay(points, dim).facets);
+ *
+ * Usage (builtin):
+ *   import { getDelaunayBackend } from '../native/geometry-bridge.js';
+ *   const backend = getDelaunayBackend();
+ *   if (!backend) throw ...;
+ *   const cells = backend(points, dim);
+ */
+/**
+ * Compute a Delaunay triangulation of `points` (an array of dim-dimensional
+ * tuples). Returns an array of simplices, each a list of `dim+1` 0-based input
+ * point indices.
+ */
+export type DelaunayBackend = (points: number[][], dim: number) => number[][];
+/**
+ * Compute the convex hull of `points` (an array of dim-dimensional tuples).
+ * Returns an array of simplicial facets, each a list of `dim` 0-based input
+ * point indices (edges in 2-D, triangles in 3-D).
+ */
+export type ConvexHullBackend = (points: number[][], dim: number) => number[][];
+/** Install (or clear, with null) the Delaunay backend. */
+export declare function setDelaunayBackend(fn: DelaunayBackend | null): void;
+/** Get the current Delaunay backend, or null if none is installed. */
+export declare function getDelaunayBackend(): DelaunayBackend | null;
+/** Install (or clear, with null) the convex-hull backend. */
+export declare function setConvexHullBackend(fn: ConvexHullBackend | null): void;
+/** Get the current convex-hull backend, or null if none is installed. */
+export declare function getConvexHullBackend(): ConvexHullBackend | null;

package/dist-lib/numbl-core/native/qhull-browser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Browser/worker loader for the qhull WASM Delaunay backend.
+ *
+ * The CLI installs the backend in cli.ts (reading the `.wasm` from disk). In
+ * the browser there is no filesystem, so we let Vite emit the `.wasm` as an
+ * asset (`?url`), fetch its bytes, and pass them to the emscripten module as
+ * `wasmBinary` — this avoids relying on the glue locating the binary next to
+ * itself at runtime.
+ *
+ * `ensureQhullBackend()` is idempotent and best-effort: on any failure it
+ * resolves anyway (so it never crashes the worker), but then no backend is
+ * installed and a later `delaunay`/`delaunayn` call throws (see geometry.ts).
+ */
+/** Load and install the qhull backend (once). Safe to await before every run. */
+export declare function ensureQhullBackend(): Promise<void>;

package/dist-lib/numbl-core/native/qhull-node.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Node loader for the qhull WASM Delaunay backend.
+ *
+ * In Node the emscripten module reads its `.wasm` from disk on its own, so no
+ * asset wiring is needed (unlike the browser; see qhull-browser.ts). This is
+ * used by the CLI, the vitest setup, and is re-exported from the library entry
+ * (lib.ts) so programmatic consumers can install the backend before calling
+ * `delaunay` / `delaunayn`.
+ *
+ * Idempotent: the first call starts loading and caches the promise.
+ */
+/** Load the qhull WASM module and install it as the Delaunay backend (once). */
+export declare function loadQhullNodeBackend(): Promise<void>;

package/dist-lib/numbl-core/parser/ArgumentsParser.d.ts

@@ -14,7 +14,12 @@ export declare class ArgumentsParser extends ControlFlowParser {
      */
     private parseArgDimensions;
     /**
-     * Parse validator list: {mustBeNumeric, mustBePositive}
+     * Parse validator list: {mustBeNumeric, mustBePositive}. Validators may be
+     * full function calls with arguments, e.g.
+     * `{mustBeMember(x,["a","b"]), mustBeInRange(x,0,7)}`. The validator bodies
+     * are not enforced at runtime, so we capture the top-level validator name
+     * tokens and skip past any nested `(...)`, `[...]`, `{...}` so parsing
+     * resumes correctly at the default value (`= expr`) or end of line.
      */
     private parseArgValidators;
     /**

package/dist-lib/numbl-core/runtime/constructors.d.ts

@@ -2,7 +2,7 @@
  * RuntimeValue constructor helpers (the RTV namespace).
  */
 import { ItemType } from "../lowering/itemTypes.js";
-import { type RuntimeNumber, RuntimeTensor, type RuntimeString, RuntimeChar, type RuntimeLogical, RuntimeCell, RuntimeStruct, RuntimeFunction, RuntimeClassInstance, RuntimeComplexNumber, RuntimeDummyHandle, RuntimeGraphicsHandle, RuntimeStructArray, RuntimeSparseMatrix, RuntimeDictionary, type RuntimeValue } from "./types.js";
+import { type RuntimeNumber, RuntimeTensor, type RuntimeString, RuntimeChar, type RuntimeLogical, RuntimeCell, RuntimeStruct, RuntimeFunction, RuntimeClassInstance, RuntimeClassInstanceArray, RuntimeComplexNumber, RuntimeDummyHandle, RuntimeGraphicsHandle, RuntimeStructArray, RuntimeSparseMatrix, RuntimeDictionary, type RuntimeValue } from "./types.js";
 export declare const RTV: {
     num(value: number): RuntimeNumber;
     tensor(data: Float64Array | number[], shape: number[], imag?: Float64Array | number[]): RuntimeTensor;
@@ -23,6 +23,7 @@ export declare const RTV: {
     struct(fields: Map<string, RuntimeValue> | Record<string, RuntimeValue>): RuntimeStruct;
     func(name: string, impl: "builtin" | "user", captures?: RuntimeValue[]): RuntimeFunction;
     classInstance(className: string, propertyNames: string[], isHandleClass?: boolean, defaults?: Map<string, RuntimeValue>): RuntimeClassInstance;
+    classInstanceArray(className: string, elements: RuntimeClassInstance[], shape?: [number, number]): RuntimeClassInstanceArray;
     complex(re: number, im: number): RuntimeComplexNumber;
     dummyHandle(): RuntimeDummyHandle;
     graphicsHandle(trace: Record<string, unknown>, traceType: string): RuntimeGraphicsHandle;

package/dist-lib/numbl-core/runtime/plotUtils.d.ts

@@ -77,6 +77,24 @@ export declare function parsePatchArgs(args: RuntimeValue[]): PatchTrace;
  *   fill(ax, ___)
  */
 export declare function parseFillArgs(args: RuntimeValue[]): PatchTrace[];
+/**
+ * Parse trimesh() arguments into a canonical PatchTrace.
+ *
+ * trimesh draws a triangular mesh and (per the MATLAB docs) returns a patch
+ * object, so it maps onto the PatchTrace model: the connectivity matrix T
+ * supplies the faces (one triangle per row, 1-based vertex indices) and the
+ * x/y[/z] vectors supply the vertices.
+ *
+ * Supported forms:
+ *   trimesh(T, x, y)              — 2-D triangular mesh
+ *   trimesh(T, x, y, z)           — 3-D triangular mesh
+ *   trimesh(T, x, y, z, c)        — c is per-vertex color data
+ *   trimesh(TO)                   — triangulation object (struct exposing
+ *                                   ConnectivityList + Points)
+ *   trimesh(___, Name, Value)     — patch properties
+ *   trimesh(ax, ___)              — leading axes handle (ignored)
+ */
+export declare function parseTriMeshArgs(args: RuntimeValue[]): PatchTrace;
 /**
  * Parse surf() arguments.
  *

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

@@ -12,7 +12,7 @@
  */
 import { type RuntimeValue, type RuntimeLogical, type RuntimeTensor, type RuntimeStruct, type RuntimeString, type RuntimeFunction, RuntimeError, type CallFrame } from "../runtime/index.js";
 import { RefScope } from "./refcount.js";
-import { RuntimeChar, RuntimeCell, type RuntimeComplexNumber, type RuntimeClassInstance } from "../runtime/types.js";
+import { RuntimeChar, RuntimeCell, RuntimeClassInstanceArray, type RuntimeComplexNumber, type RuntimeClassInstance } from "../runtime/types.js";
 import { type ItemType } from "../lowering/itemTypes.js";
 import type { PlotInstruction } from "../../graphics/types.js";
 import type { ExecOptions } from "../executeCode.js";
@@ -84,6 +84,7 @@ export declare class Runtime {
         struct(fields: Map<string, RuntimeValue> | Record<string, RuntimeValue>): RuntimeStruct;
         func(name: string, impl: "builtin" | "user", captures?: RuntimeValue[]): RuntimeFunction;
         classInstance(className: string, propertyNames: string[], isHandleClass?: boolean, defaults?: Map<string, RuntimeValue>): RuntimeClassInstance;
+        classInstanceArray(className: string, elements: RuntimeClassInstance[], shape?: [number, number]): RuntimeClassInstanceArray;
         complex(re: number, im: number): RuntimeComplexNumber;
         dummyHandle(): import("../runtime/types.js").RuntimeDummyHandle;
         graphicsHandle(trace: Record<string, unknown>, traceType: string): import("../runtime/types.js").RuntimeGraphicsHandle;

package/dist-lib/numbl-core/runtime/runtimeMemberAccess.d.ts

@@ -4,7 +4,7 @@
 import { type RuntimeValue } from "../runtime/index.js";
 import type { Runtime } from "./runtime.js";
 export declare function getMember(rt: Runtime, base: unknown, name: string): unknown;
-export declare function getMemberDynamic(base: unknown, nameExpr: unknown): RuntimeValue;
+export declare function getMemberDynamic(rt: Runtime, base: unknown, nameExpr: unknown): RuntimeValue;
 export declare function getMemberOrEmpty(base: unknown, name: string): RuntimeValue;
 export declare function setMemberReturn(rt: Runtime, base: unknown, name: string, rhs: unknown): unknown;
 export declare function setMemberDynamicReturn(rt: Runtime, base: unknown, nameExpr: unknown, rhs: unknown): RuntimeValue;

package/dist-lib/numbl-core/runtime/runtimePlot.d.ts

@@ -73,6 +73,7 @@ export declare function plotCall(plotInstructions: PlotInstruction[], args: Runt
 export declare function plot3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
 export declare function lineCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
 export declare function patchCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function trimeshCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
 export declare function fillCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
 export declare function surfCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
 export declare function surfaceCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;

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

@@ -1,2 +1,2 @@
 /** Numbl version, used for JIT disk cache invalidation. */
-export declare const NUMBL_VERSION = "0.4.5";
+export declare const NUMBL_VERSION = "0.4.7";