numbl 0.1.0 → 0.1.2

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

@@ -0,0 +1,215 @@
+/**
+ * Utilities for parsing plot() arguments at runtime.
+ *
+ * Handles: plot(Y), plot(X,Y), plot(X1,Y1,...,Xn,Yn),
+ * plot(X1,Y1,LineSpec1,...), and Name-Value pairs like 'Color','r','LineWidth',2.
+ */
+import { type RuntimeValue } from "./types.js";
+export type { PlotTrace, Plot3Trace, SurfTrace, ImagescTrace, ContourTrace, BarTrace, Bar3Trace, ErrorBarTrace, BoxTrace, PieTrace, HeatmapTrace, } from "../../graphics/types.js";
+import type { PlotTrace, Plot3Trace, SurfTrace, ImagescTrace, ContourTrace, BarTrace, Bar3Trace, ErrorBarTrace, BoxTrace, PieTrace, HeatmapTrace } from "../../graphics/types.js";
+export interface ParsedLineSpec {
+    color?: string;
+    lineStyle?: string;
+    marker?: string;
+}
+export declare function parsePlotArgs(args: RuntimeValue[]): PlotTrace[];
+/**
+ * Parse plot3() arguments.
+ *
+ * Supported forms:
+ *   plot3(X, Y, Z)
+ *   plot3(X, Y, Z, LineSpec)
+ *   plot3(X1,Y1,Z1,...,Xn,Yn,Zn)
+ *   plot3(X1,Y1,Z1,LineSpec1,...,Xn,Yn,Zn,LineSpecn)
+ *   plot3(..., Name, Value)
+ */
+export declare function parsePlot3Args(args: RuntimeValue[]): Plot3Trace[];
+/**
+ * Parse surf() arguments.
+ *
+ * Supported forms:
+ *   surf(Z)           — Z is m×n, X = 1:n, Y = 1:m
+ *   surf(Z, C)        — Z is m×n, C is m×n color data
+ *   surf(X, Y, Z)     — X, Y, Z are m×n matrices (or X is 1×n / Y is m×1)
+ *   surf(X, Y, Z, C)  — with explicit color data
+ *   surf(..., Name, Value) — name-value pairs
+ */
+export declare function parseSurfArgs(args: RuntimeValue[]): SurfTrace;
+/**
+ * Parse scatter() arguments.
+ *
+ * Supported forms:
+ *   scatter(X, Y)
+ *   scatter(X, Y, sz)
+ *   scatter(X, Y, sz, c)
+ *   scatter(X, Y, ..., 'filled')
+ *   scatter(X, Y, ..., mkr)
+ *   scatter(X, Y, ..., Name, Value)
+ */
+export declare function parseScatterArgs(args: RuntimeValue[]): PlotTrace[];
+/**
+ * Parse imagesc() arguments.
+ *
+ * Supported forms:
+ *   imagesc(C)         — C is m×n matrix
+ *   imagesc(x, y, C)   — x and y are vectors defining axis limits
+ */
+export declare function parseImagescArgs(args: RuntimeValue[]): ImagescTrace;
+/**
+ * Parse contour()/contourf() arguments.
+ *
+ * Supported forms:
+ *   contour(Z)
+ *   contour(Z, N)
+ *   contour(X, Y, Z)
+ *   contour(X, Y, Z, N)
+ *   contour(..., Name, Value)
+ */
+export declare function parseContourArgs(args: RuntimeValue[], filled: boolean): ContourTrace;
+/**
+ * Parse mesh() arguments — same as surf but with different default rendering.
+ */
+export declare function parseMeshArgs(args: RuntimeValue[]): SurfTrace;
+/**
+ * Parse bar() arguments.
+ *
+ * Supported forms:
+ *   bar(Y)             — Y values with x = 1:length(Y)
+ *   bar(X, Y)          — explicit X positions
+ *   bar(..., width)     — relative bar width (scalar 0–1)
+ *   bar(..., color)     — single-char color spec
+ */
+export declare function parseBarArgs(args: RuntimeValue[]): BarTrace[];
+/**
+ * Parse barh() arguments — same forms as bar() but rendered horizontally.
+ *
+ * Supported forms:
+ *   barh(Y)             — Y values (bar lengths) with positions = 1:length(Y)
+ *   barh(X, Y)          — explicit positions X, bar lengths Y
+ *   barh(..., width)    — relative bar thickness (scalar 0–1)
+ *   barh(..., color)    — single-char color spec
+ */
+export declare function parseBarHArgs(args: RuntimeValue[]): BarTrace[];
+/**
+ * Parse bar3() / bar3h() arguments.
+ *
+ * Supported forms:
+ *   bar3(Z)             — Z values with y = 1:m, x = 1:n
+ *   bar3(Y, Z)          — explicit Y positions
+ *   bar3(..., width)    — relative bar width (scalar 0–1)
+ *   bar3(..., color)    — single-char color spec
+ */
+export declare function parseBar3Args(args: RuntimeValue[]): Bar3Trace;
+/**
+ * Parse stairs() arguments — same forms as plot() but with staircase-transformed coordinates.
+ *
+ * Supported forms:
+ *   stairs(Y)
+ *   stairs(X, Y)
+ *   stairs(..., LineSpec)
+ *   stairs(..., Name, Value)
+ */
+export declare function parseStairsArgs(args: RuntimeValue[]): PlotTrace[];
+/**
+ * Parse errorbar() arguments.
+ *
+ * Supported forms:
+ *   errorbar(y, err)                    — symmetric vertical
+ *   errorbar(x, y, err)                 — symmetric vertical with explicit x
+ *   errorbar(x, y, neg, pos)            — asymmetric vertical
+ *   errorbar(x, y, yneg, ypos, xneg, xpos) — both axes
+ *   errorbar(..., LineSpec)
+ */
+export declare function parseErrorBarArgs(args: RuntimeValue[]): ErrorBarTrace[];
+/**
+ * Parse area() arguments.
+ *
+ * Supported forms:
+ *   area(Y)              — fill under Y with x = 1:length(Y)
+ *   area(X, Y)           — explicit X
+ *   area(..., basevalue)  — scalar baseline (default 0)
+ *   area(..., Name, Value)
+ *
+ * Returns { traces, baseValue }.
+ */
+export declare function parseAreaArgs(args: RuntimeValue[]): {
+    traces: PlotTrace[];
+    baseValue: number;
+};
+/**
+ * Parse scatter3() arguments.
+ *
+ * Supported forms:
+ *   scatter3(X, Y, Z)
+ *   scatter3(X, Y, Z, S)
+ *   scatter3(X, Y, Z, S, C)
+ *   scatter3(..., 'filled')
+ *   scatter3(..., markertype)
+ */
+export declare function parseScatter3Args(args: RuntimeValue[]): Plot3Trace[];
+/**
+ * Parse histogram() arguments.
+ *
+ * Supported forms:
+ *   histogram(X)
+ *   histogram(X, nbins)
+ *   histogram(X, edges)
+ */
+export declare function parseHistogramArgs(args: RuntimeValue[]): BarTrace[];
+/**
+ * Parse histogram2() arguments.
+ *
+ * Supported forms:
+ *   histogram2(X, Y)
+ *   histogram2(X, Y, nbins)        — nbins is scalar or [nx, ny]
+ *   histogram2(X, Y, Xedges, Yedges)
+ */
+export declare function parseHistogram2Args(args: RuntimeValue[]): Bar3Trace;
+/**
+ * Parse boxchart() arguments.
+ *
+ * Supported forms:
+ *   boxchart(ydata)           — one box per column of ydata
+ *   boxchart(xgroupdata, ydata) — group ydata by unique values in xgroupdata
+ */
+export declare function parseBoxchartArgs(args: RuntimeValue[]): BoxTrace[];
+/**
+ * Parse swarmchart() arguments.
+ *
+ * Supported forms:
+ *   swarmchart(x, y)
+ *   swarmchart(x, y, sz)
+ *   swarmchart(x, y, sz, c)
+ *   swarmchart(..., 'filled')
+ *   swarmchart(..., markertype)
+ */
+export declare function parseSwarmchartArgs(args: RuntimeValue[]): PlotTrace[];
+/**
+ * Parse swarmchart3() arguments.
+ *
+ * Supported forms:
+ *   swarmchart3(x, y, z)
+ *   swarmchart3(x, y, z, sz)
+ *   swarmchart3(x, y, z, sz, c)
+ *   swarmchart3(..., 'filled')
+ *   swarmchart3(..., markertype)
+ */
+export declare function parseSwarmchart3Args(args: RuntimeValue[]): Plot3Trace[];
+/**
+ * Parse piechart() / donutchart() arguments.
+ *
+ * Supported forms:
+ *   piechart(data)
+ *   piechart(data, names)
+ *
+ * @param innerRadius 0 for pie, >0 for donut
+ */
+export declare function parsePiechartArgs(args: RuntimeValue[], innerRadius: number): PieTrace;
+/**
+ * Parse heatmap() arguments.
+ *
+ * Supported forms:
+ *   heatmap(cdata)                — matrix of values
+ *   heatmap(xvalues, yvalues, cdata) — with axis labels
+ */
+export declare function parseHeatmapArgs(args: RuntimeValue[]): HeatmapTrace;

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

@@ -0,0 +1,314 @@
+/**
+ * Simplified runtime providing the $rt interface for generated JS.
+ *
+ * This is a focused rewrite of runtime/runtime.ts (~3300 lines) that provides
+ * exactly the methods the codegen emits, without class support, namespace
+ * dispatch, WebGPU, subsref/subsasgn overloads, or property accessors.
+ *
+ * It reuses existing runtime value types, operations, indexing, and builtins.
+ *
+ * Operator functions are in runtimeOperators.ts, dispatch/registration in
+ * runtimeDispatch.ts, and helper types/utilities in runtimeHelpers.ts.
+ */
+import { type RuntimeValue, type RuntimeLogical, type RuntimeTensor, type RuntimeStruct, type RuntimeString, type RuntimeFunction, RuntimeError, type CallFrame } from "../runtime/index.js";
+import { RuntimeChar, RuntimeCell, type RuntimeComplexNumber } from "../runtime/types.js";
+import { type ItemType } from "../lowering/itemTypes.js";
+import type { PlotInstruction } from "../../graphics/types.js";
+import type { ExecOptions } from "../executeCode.js";
+import type { FileIOAdapter } from "../fileIOAdapter.js";
+import type { SystemAdapter } from "../systemAdapter.js";
+import { type CallSite } from "./runtimeHelpers.js";
+export declare class Runtime {
+    private options;
+    private initialVariableValues?;
+    outputLines: string[];
+    plotInstructions: PlotInstruction[];
+    variableValues: Record<string, RuntimeValue>;
+    holdState: boolean;
+    $line: number;
+    $file: string | null;
+    $callStack: CallFrame[];
+    COLON: symbol;
+    END: symbol;
+    RTV: {
+        num(value: number): import("../runtime/types.js").RuntimeNumber;
+        tensor(data: import("../runtime/types.js").FloatXArrayType | number[], shape: number[], imag?: import("../runtime/types.js").FloatXArrayType | number[]): RuntimeTensor;
+        tensorRaw(data: import("../runtime/types.js").FloatXArrayType, shape: number[]): RuntimeTensor;
+        scalar(value: number): import("../runtime/types.js").RuntimeNumber;
+        row(data: number[], imag?: number[]): RuntimeTensor;
+        col(data: number[], imag?: number[]): RuntimeTensor;
+        matrix(rows: number, cols: number, data: number[] | import("../runtime/types.js").FloatXArrayType, imag?: number[] | import("../runtime/types.js").FloatXArrayType): RuntimeTensor;
+        string(value: string): RuntimeString;
+        char(value: string): RuntimeChar;
+        logical(value: boolean): RuntimeLogical;
+        cell(data: RuntimeValue[], shape: number[]): RuntimeCell;
+        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>): import("../runtime/types.js").RuntimeClassInstance;
+        complex(re: number, im: number): RuntimeComplexNumber;
+        dummyHandle(): import("../runtime/types.js").RuntimeDummyHandle;
+        structArray(fieldNames: string[], elements: RuntimeStruct[]): import("../runtime/types.js").RuntimeStructArray;
+        sparseMatrix(m: number, n: number, ir: Int32Array, jc: Int32Array, pr: Float64Array, pi?: Float64Array): import("../runtime/types.js").RuntimeSparseMatrix;
+        dictionary(entries?: Map<string, {
+            key: RuntimeValue;
+            value: RuntimeValue;
+        }>, keyType?: string, valueType?: string): import("../runtime/types.js").RuntimeDictionary;
+    };
+    private persistentStore;
+    $g: Record<string, RuntimeValue>;
+    activeAccessors: Set<string>;
+    resolveClassMethod: ((className: string, methodName: string) => ((...args: any[]) => any) | null) | null;
+    getClassParent: ((className: string) => string | null) | null;
+    classMethodCache: Map<string, ((...args: any[]) => any) | null>;
+    /** Callback for addpath/rmpath — mutates search paths and rebuilds function index. */
+    onPathChange: ((action: "add" | "remove", dir: string, position: "begin" | "end") => void) | null;
+    /** Reference to the active search paths (set by executeCode). */
+    searchPaths: string[];
+    workspaceAccessors: Map<string, {
+        get: () => unknown;
+        set: (v: unknown) => void;
+    }>;
+    dynamicWorkspaceVars: Map<string, unknown>;
+    callerAccessorStack: (Record<string, [
+        () => unknown,
+        (v: unknown) => void
+    ]> | null)[];
+    private dynamicCallerVarStack;
+    fileIO?: FileIOAdapter;
+    system?: SystemAdapter;
+    builtins: Record<string, (nargout: number, args: unknown[]) => unknown>;
+    customBuiltins: Record<string, (nargout: number, args: unknown[]) => unknown>;
+    compileSpecialized: ((name: string, argTypes: ItemType[], callSite: CallSite) => ((...args: any[]) => any) | null) | null;
+    evalLocalCallback: ((code: string, initialVars: Record<string, RuntimeValue>, onOutput: (text: string) => void, fileName?: string) => {
+        returnValue: unknown;
+        variableValues: Record<string, RuntimeValue>;
+        searchPaths?: string[];
+        workspaceFiles?: import("../../numbl-core/workspace/index.js").WorkspaceFile[];
+    }) | null;
+    jitFunctionCode: Map<string, string>;
+    private dispatchUnknownCache;
+    dispatchUnknownCounts: Map<string, number>;
+    profilingEnabled: boolean;
+    private profileStack;
+    private profileAccum;
+    private profileCounts;
+    constructor(options: ExecOptions, initialVariableValues?: Record<string, RuntimeValue> | undefined);
+    private initBuiltins;
+    profileEnter(key: string): void;
+    profileLeave(): void;
+    getBuiltinProfile(): Record<string, {
+        fallback: {
+            totalTimeMs: number;
+            callCount: number;
+        };
+        interp: {
+            totalTimeMs: number;
+            callCount: number;
+        };
+        jit: {
+            totalTimeMs: number;
+            callCount: number;
+        };
+    }>;
+    getDispatchProfile(): Record<string, {
+        totalTimeMs: number;
+        callCount: number;
+    }>;
+    getJitCompileTimeMs(): number;
+    getDispatchUnknownCounts(): Record<string, number>;
+    output(text: string): void;
+    error(message: string): RuntimeError;
+    annotateError(e: unknown): void;
+    wrapError(e: unknown): RuntimeStruct;
+    pushCallFrame(name: string): void;
+    popCallFrame(): void;
+    toBool(v: unknown): boolean;
+    toNumber(v: unknown): number;
+    lg(v: boolean): RuntimeLogical;
+    /** Scalar power that returns complex for negative base with fractional exponent */
+    pow(a: number, b: number): number | RuntimeComplexNumber;
+    share(v: unknown): RuntimeValue;
+    displayResult(v: unknown): void;
+    displayAssign(name: string, v: unknown): void;
+    getConstant(name: string): RuntimeValue;
+    makeChar(raw: string): RuntimeChar;
+    makeString(raw: string): RuntimeString;
+    getInitialVariableValue(name: string): RuntimeValue | undefined;
+    setVariableValue(name: string, value: RuntimeValue | undefined): void;
+    /** Collect defined variable names from getters and apply argument filters. */
+    private filterVarNames;
+    /** Get shape of a runtime value as a number array. */
+    private static varShape;
+    /** Estimate bytes for a runtime value. */
+    private static varBytes;
+    /** Check if a runtime value is complex. */
+    private static varIsComplex;
+    /** Check if a runtime value is sparse. */
+    private static varIsSparse;
+    who(nargout: number, getters: Record<string, () => unknown>, args: unknown[]): unknown;
+    /** Build info record for a single variable. */
+    private static varInfo;
+    private static whosStruct;
+    whos(nargout: number, getters: Record<string, () => unknown>, args: unknown[]): unknown;
+    setWorkspaceAccessor(name: string, getter: () => unknown, setter: (v: unknown) => void): void;
+    getWorkspaceVariable(name: string): unknown | undefined;
+    setWorkspaceVariable(name: string, value: unknown): void;
+    pushCallerAccessors(accessors: Record<string, [() => unknown, (v: unknown) => void]> | null): void;
+    popCallerAccessors(): void;
+    getCallerVariable(name: string): unknown | undefined;
+    setCallerVariable(name: string, value: unknown): void;
+    evalLocal(code: unknown, accessors: Record<string, [() => unknown, (v: unknown) => void]>): unknown;
+    getPersistent(funcId: string, varName: string): RuntimeValue;
+    setPersistent(funcId: string, varName: string, value: RuntimeValue): void;
+    uplus(v: unknown): RuntimeValue;
+    uminus(v: unknown): unknown;
+    transpose(v: unknown): unknown;
+    ctranspose(v: unknown): unknown;
+    not(v: unknown): RuntimeLogical | RuntimeTensor;
+    private static readonly binopMethodMap;
+    binop(op: string, a: unknown, b: unknown): unknown;
+    range(start: unknown, step: unknown, end: unknown): unknown;
+    forIter(v: unknown): unknown[];
+    emptyTensor(): RuntimeTensor;
+    emptyStruct(): RuntimeStruct;
+    makeCell(elems: unknown[], shape: number[]): RuntimeCell;
+    /**
+     * Build a struct from trailing name-value pair arguments.
+     * @param nvArgs  The rest-parameter array of trailing name-value pairs
+     * @param defaults  An object mapping field names to default values
+     */
+    buildNameValueStruct(nvArgs: unknown[], defaults: Record<string, unknown>): RuntimeStruct;
+    horzcat(elems: unknown[]): unknown;
+    vertcat(rows: unknown[]): unknown;
+    switchMatch(control: unknown, caseVal: unknown): boolean;
+    getFuncHandle(name: string): RuntimeFunction;
+    makeUserFuncHandle(jsFn: (...args: unknown[]) => unknown, nargin?: number): RuntimeFunction;
+    isa(value: unknown, classNameArg: unknown): RuntimeLogical;
+    callSuperConstructor(target: unknown, superInstance: unknown): unknown;
+    createClassInstance(className: string, propertyNames: string[], defaults?: Record<string, unknown>, isHandleClass?: boolean): RuntimeValue;
+    /**
+     * Resolve a class method by name, using cache + JIT compilation.
+     * Returns the compiled method function or null if it doesn't exist.
+     */
+    cachedResolveClassMethod(className: string, methodName: string): ((...args: any[]) => any) | null;
+    /**
+     * Get the parent class name, using the compiler callback.
+     * Returns null if no parent or no callback registered.
+     */
+    getClassParentName(className: string): string | null;
+    /** Get the class name from a runtime value (for dynamic static method dispatch). */
+    getClassName(value: unknown): string;
+    dispatch(name: string, nargout: number, args: unknown[]): unknown;
+    methodDispatch(name: string, nargout: number, args: unknown[]): unknown;
+    callBuiltin(name: string, nargout: number, args: unknown[]): unknown;
+    callClassMethod(className: string, methodName: string, nargout: number, args: unknown[]): unknown;
+    /**
+     * JIT dispatch for function calls where argument types were unknown at
+     * compile time. Inspects runtime values to infer types, asks the compiler
+     * to JIT-compile a specialized version, then calls it. The compiler
+     * handles the full resolution chain (local → class method → workspace)
+     * internally using the callSite for context.
+     */
+    dispatchUnknown(name: string, nargout: number, args: unknown[], callSite: CallSite): unknown;
+    index(base: unknown, indices: unknown[], nargout?: number, skipSubsref?: boolean | string): unknown;
+    indexCell(base: unknown, indices: unknown[]): unknown;
+    /** Normalize a cell indexing result into an array for CSL spreading.
+     *  If the result is already an array (multi-element indexing), return it as-is.
+     *  If it's a single value (scalar indexing), wrap it in an array. */
+    asCsl(value: unknown): unknown[];
+    /** Like index() but returns an empty struct instead of throwing.
+     *  Used for chained lvalue assignment: V(i).field = rhs where V may be uninitialized. */
+    indexOrEmpty(base: unknown, indices: unknown[]): unknown;
+    /** Like indexOrEmpty() but uses built-in indexing (bypasses subsref) for
+     *  class instances.  For scalar class instances, V(1) returns V itself.
+     *  Used in V(i).field = rhs patterns where the () part should always use
+     *  built-in array indexing, not the class's overloaded subsref. */
+    builtinIndexOrEmpty(base: unknown, indices: unknown[]): unknown;
+    /** Like indexCell() but returns 0 instead of throwing.
+     *  Used for chained lvalue assignment: data{i}.field = rhs where data may be uninitialized. */
+    indexCellOrEmpty(base: unknown, indices: unknown[]): unknown;
+    indexStore(base: unknown, indices: unknown[], rhs: unknown, skipSubsasgn?: boolean): unknown;
+    /** Built-in index store for V(i).field = rhs patterns.
+     *  For class instances, the element was already modified via setMemberReturn
+     *  so we just return the new value.  For other types, delegate to indexStore. */
+    builtinIndexStore(base: unknown, indices: unknown[], value: unknown): unknown;
+    /** Check if a value is a class instance of the given class name.
+     *  Used by codegen for runtime skipSubsasgn checks on Unknown-type variables. */
+    isClassInstance(value: unknown, className: string): boolean;
+    indexCellStore(base: unknown, indices: unknown[], rhs: unknown): unknown;
+    multiOutputCellAssign(base: unknown, indices: unknown, results: unknown[]): unknown;
+    getMember(base: unknown, name: string): unknown;
+    getMemberDynamic(base: unknown, nameExpr: unknown): RuntimeValue;
+    getMemberOrEmpty(base: unknown, name: string): RuntimeValue;
+    setMember(_base: unknown, _name: string, _rhs: unknown): void;
+    setMemberReturn(base: unknown, name: string, rhs: unknown): unknown;
+    setMemberDynamicReturn(base: unknown, nameExpr: unknown, rhs: unknown): RuntimeValue;
+    subsrefCall(base: unknown, names: string[]): unknown;
+    subsasgnCall(base: unknown, names: string[], rhs: unknown): unknown;
+    memberChainAssign(base: unknown, names: string[], rhs: unknown): unknown;
+    narginchk(actualNargin: unknown, minArgs: unknown, maxArgs: unknown): void;
+    nargoutchk(actualNargout: unknown, minArgs: unknown, maxArgs: unknown): void;
+    plot_instr(instr: {
+        type: "set_figure_handle";
+        handle: unknown;
+    } | {
+        type: "plot";
+        x: unknown;
+        y: unknown;
+    } | {
+        type: "set_hold";
+        value: unknown;
+    } | {
+        type: "close";
+    } | {
+        type: "close_all";
+    } | {
+        type: "clf";
+    } | {
+        type: "set_subplot";
+        rows: unknown;
+        cols: unknown;
+        index: unknown;
+    } | {
+        type: "set_sgtitle";
+        text: unknown;
+    } | {
+        type: "set_grid";
+        value: unknown;
+    }): void;
+    ishold(): RuntimeValue;
+    plot_call(args: RuntimeValue[]): void;
+    plot3_call(args: RuntimeValue[]): void;
+    surf_call(args: RuntimeValue[]): void;
+    scatter_call(args: RuntimeValue[]): void;
+    imagesc_call(args: RuntimeValue[]): void;
+    contour_call(args: RuntimeValue[], filled: boolean): void;
+    mesh_call(args: RuntimeValue[]): void;
+    bar_call(args: RuntimeValue[]): void;
+    barh_call(args: RuntimeValue[]): void;
+    bar3_call(args: RuntimeValue[]): void;
+    bar3h_call(args: RuntimeValue[]): void;
+    stairs_call(args: RuntimeValue[]): void;
+    errorbar_call(args: RuntimeValue[]): void;
+    semilogx_call(args: RuntimeValue[]): void;
+    semilogy_call(args: RuntimeValue[]): void;
+    loglog_call(args: RuntimeValue[]): void;
+    area_call(args: RuntimeValue[]): void;
+    fplot_call(args: RuntimeValue[]): void;
+    fplot3_call(args: RuntimeValue[]): void;
+    scatter3_call(args: RuntimeValue[]): void;
+    histogram_call(args: RuntimeValue[]): void;
+    histogram2_call(args: RuntimeValue[]): void;
+    boxchart_call(args: RuntimeValue[]): void;
+    swarmchart_call(args: RuntimeValue[]): void;
+    swarmchart3_call(args: RuntimeValue[]): void;
+    piechart_call(args: RuntimeValue[]): void;
+    donutchart_call(args: RuntimeValue[]): void;
+    heatmap_call(args: RuntimeValue[]): void;
+    view_call(args: RuntimeValue[]): void;
+    legend_call(args: RuntimeValue[]): void;
+    drawnow(): void;
+    pause(seconds: unknown): void;
+    readInput(prompt: string): string;
+}
+export declare const rstr: (s: RuntimeString | RuntimeChar) => string;

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

@@ -0,0 +1,27 @@
+/**
+ * Runtime dispatch, registration, and higher-order functions.
+ *
+ * Standalone functions that take the Runtime instance as the first parameter.
+ * Handles function/class dispatch, arrayfun/cellfun/bsxfun, and subsref/subsasgn.
+ */
+import { type RuntimeValue, type RuntimeLogical, type RuntimeFunction } from "../runtime/index.js";
+import type { Runtime } from "./runtime.js";
+export declare function getFuncHandle(name: string): RuntimeFunction;
+export declare function makeUserFuncHandle(jsFn: (...args: unknown[]) => unknown, nargin?: number): RuntimeFunction;
+export declare function isa(rt: Runtime, value: unknown, classNameArg: unknown): RuntimeLogical;
+export declare function callSuperConstructor(target: unknown, superInstance: unknown): RuntimeValue;
+export declare function createClassInstance(_rt: Runtime, className: string, propertyNames: string[], defaults?: Record<string, unknown>, isHandleClass?: boolean): RuntimeValue;
+export declare function dispatch(rt: Runtime, name: string, nargout: number, args: unknown[], targetClassName?: string): unknown;
+/** Direct builtin call — skips local/workspace/registry lookup. */
+export declare function callBuiltin(rt: Runtime, name: string, nargout: number, args: unknown[]): unknown;
+/** Direct class method call — delegates to unified dispatch with targetClassName. */
+export declare function callClassMethod(rt: Runtime, className: string, methodName: string, nargout: number, args: unknown[]): unknown;
+export declare function methodDispatch(rt: Runtime, name: string, nargout: number, args: unknown[]): unknown;
+export declare function arrayfunImpl(rt: Runtime, nargout: number, args: unknown[]): unknown;
+export declare function cellfunImpl(rt: Runtime, nargout: number, args: unknown[]): unknown;
+export declare function structfunImpl(rt: Runtime, _nargout: number, args: unknown[]): unknown;
+export declare function bsxfunImpl(rt: Runtime, _nargout: number, args: unknown[]): unknown;
+/** Return the class name for a runtime value */
+export declare function numblClass(v: RuntimeValue): string;
+export declare function subsrefBuiltin(rt: Runtime, nargout: number, args: unknown[]): unknown;
+export declare function subsasgnBuiltin(rt: Runtime, _nargout: number, args: unknown[]): unknown;

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

@@ -0,0 +1,31 @@
+/**
+ * Runtime helper types and standalone utility functions.
+ *
+ * Types and pure functions
+ * These have no dependency on the Runtime class.
+ */
+import { type RuntimeValue } from "../runtime/index.js";
+import { END_SENTINEL } from "./sentinels.js";
+export type DeferredRange = {
+    _deferredRange: true;
+    start: RuntimeValue | typeof END_SENTINEL;
+    step: RuntimeValue | typeof END_SENTINEL;
+    end: RuntimeValue | typeof END_SENTINEL;
+};
+export declare function isDeferredRange(v: unknown): v is DeferredRange;
+export type DeferredHorzcat = {
+    _deferredHorzcat: true;
+    elems: (RuntimeValue | typeof END_SENTINEL | DeferredRange)[];
+};
+export declare function isDeferredHorzcat(v: unknown): v is DeferredHorzcat;
+export declare function ensureRuntimeValue(v: unknown): RuntimeValue;
+export declare function switchValuesMatch(a: RuntimeValue, b: RuntimeValue): boolean;
+export declare function isNumericKind(v: RuntimeValue): boolean;
+export declare function elementWiseLogicalOp(a: RuntimeValue, b: RuntimeValue, op: (x: number, y: number) => number): RuntimeValue;
+/** Where a function call originates (passed from codegen into runtime). */
+export type CallSite = {
+    file: string;
+    className?: string;
+    methodName?: string;
+    targetClassName?: string;
+};

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

@@ -0,0 +1,28 @@
+/**
+ * Runtime indexing operations.
+ *
+ * This module contains all indexing-related functionality for the runtime,
+ * including array indexing, cell indexing, and indexed assignment operations.
+ */
+import type { Runtime } from "./runtime.js";
+/**
+ * Index into a runtime value or call a function with arguments.
+ */
+export declare function index(rt: Runtime, base: unknown, indices: unknown[], nargout?: number, skipSubsref?: boolean | string): unknown;
+/**
+ * Cell indexing with support for comma-separated lists (CSL).
+ */
+export declare function indexCell(rt: Runtime, base: unknown, indices: unknown[]): unknown;
+/**
+ * Indexed assignment with support for struct arrays, cell deletion, and scalar expansion.
+ */
+export declare function indexStore(rt: Runtime, base: unknown, indices: unknown[], rhs: unknown, skipSubsasgn?: boolean): unknown;
+/**
+ * Cell-indexed assignment (curly braces).
+ */
+export declare function indexCellStore(base: unknown, indices: unknown[], rhs: unknown): unknown;
+/**
+ * Multi-output assignment to cell elements: [c{idx}] = func()
+ * Distributes individual results to individual cell positions.
+ */
+export declare function multiOutputCellAssign(base: unknown, indices: unknown, results: unknown[]): unknown;

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

@@ -0,0 +1,26 @@
+/**
+ * Member access operations for the runtime.
+ */
+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 getMemberOrEmpty(base: unknown, name: string): RuntimeValue;
+export declare function setMemberReturn(rt: Runtime, base: unknown, name: string, rhs: unknown): unknown;
+export declare function setMemberDynamicReturn(base: unknown, nameExpr: unknown, rhs: unknown): RuntimeValue;
+/**
+ * Call a user-defined subsref method on a class instance.
+ * Constructs S = struct('type', '.', 'subs', name) for each name in the chain.
+ */
+export declare function subsrefCall(rt: Runtime, base: unknown, names: string[]): unknown;
+/**
+ * Call a user-defined subsasgn method on a class instance.
+ * Constructs S = struct('type', '.', 'subs', name) for each name in the chain.
+ */
+export declare function subsasgnCall(rt: Runtime, base: unknown, names: string[], rhs: unknown): unknown;
+/**
+ * Runtime dispatch for member chain assignment when the type is unknown
+ * at compile time. If the base is a class instance with overloaded
+ * subsasgn, routes through subsasgnCall; otherwise uses normal chain.
+ */
+export declare function memberChainAssign(rt: Runtime, base: unknown, names: string[], rhs: unknown): unknown;

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

@@ -0,0 +1,24 @@
+/**
+ * Runtime operator and construction functions.
+ *
+ * Standalone functions for operators, range/iteration, and data construction.
+ * None of these depend on the Runtime class instance.
+ */
+import { type RuntimeValue, type RuntimeLogical, type RuntimeTensor, type RuntimeStruct, type RuntimeCell } from "../runtime/index.js";
+import { END_SENTINEL } from "./sentinels.js";
+import { type DeferredHorzcat } from "./runtimeHelpers.js";
+export declare function uplus(v: unknown): RuntimeValue;
+export declare function uminus(v: unknown): unknown;
+export declare function transpose(v: unknown): unknown;
+export declare function ctranspose(v: unknown): unknown;
+export declare function not(v: unknown): RuntimeLogical | RuntimeTensor;
+export declare function binop(op: string, a: unknown, b: unknown): unknown;
+export declare function range(start: unknown, step: unknown, end: unknown): unknown;
+export declare function forIter(v: unknown): unknown[];
+export declare function emptyTensor(): RuntimeTensor;
+export declare function emptyStruct(): RuntimeStruct;
+export declare function makeCell(elems: unknown[], shape: number[]): RuntimeCell;
+export declare function opHorzcat(elems: unknown[]): unknown;
+export declare function resolveHorzcat(dh: DeferredHorzcat, resolve: (v: RuntimeValue | typeof END_SENTINEL) => number): RuntimeValue;
+export declare function opVertcat(rows: unknown[]): unknown;
+export declare function switchMatch(control: unknown, caseVal: unknown): boolean;