numbl 0.4.8 → 0.4.9

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

@@ -0,0 +1,354 @@
+/**
+ * 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 { RefScope } from "./refcount.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";
+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[];
+    /** Stack of in-progress output-capture buffers. While non-empty,
+     *  `output()` appends to the top buffer instead of emitting, so a
+     *  speculative JIT attempt's side effects can be committed on success
+     *  or discarded on bail (preventing duplicated output when the
+     *  interpreter re-runs the same code). */
+    private outputCaptureStack;
+    plotInstructions: PlotInstruction[];
+    variableValues: Record<string, RuntimeValue>;
+    holdState: boolean;
+    /** Figure-handle tracking for MATLAB-style `figure` allocation: `figure`
+     *  with no argument creates a new figure (`maxFigureHandle + 1`). */
+    currentFigureHandle: number;
+    maxFigureHandle: number;
+    /** Monotonic id source for graphics handles whose trace can be live-updated
+     *  via `set` / `update_trace` (e.g. lines returned by `line`). */
+    graphicsIdCounter: number;
+    /** Reverse channel for `uihtml` components (HTML → MATLAB). Maps a component
+     *  id (the `uihtml` instruction's `id`) to the callback handles registered
+     *  for it. When non-empty after a run, the host keeps this runtime alive so
+     *  iframe events can re-enter the interpreter and invoke these handles.
+     *  Handles are incref'd while stored (see registeruihtmlcallback). */
+    uihtmlCallbacks: Map<string, {
+        HTMLEventReceived?: RuntimeValue;
+        DataChanged?: RuntimeValue;
+    }>;
+    /** Hook invoked by `sendEventToHTMLSource(src, name, data)` to push an event
+     *  from MATLAB back to a uihtml component's page. `dataJson` is the data
+     *  already `jsonencode`d. Set from ExecOptions; the host forwards it to the
+     *  iframe. */
+    onHtmlSourceEvent?: (compId: string, name: string, dataJson: string) => void;
+    tiledLayoutState: {
+        rows: number;
+        cols: number;
+        mode: "fixed" | "flow" | "vertical" | "horizontal";
+        count: number;
+    } | null;
+    private cancelFlag;
+    $line: number;
+    $file: string | null;
+    $callStack: CallFrame[];
+    _cleanupScopes: RuntimeFunction[][];
+    pushCleanupScope(): void;
+    registerCleanup(fn: RuntimeFunction): void;
+    popAndRunCleanups(callFn: (fn: RuntimeFunction) => void): void;
+    COLON: symbol;
+    END: symbol;
+    RTV: {
+        num(value: number): import("../runtime/types.js").RuntimeNumber;
+        tensor(data: Float64Array | number[], shape: number[], imag?: Float64Array | number[]): RuntimeTensor;
+        tensorRaw(data: Float64Array, 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[] | Float64Array, imag?: number[] | Float64Array): RuntimeTensor;
+        string(value: string): RuntimeString;
+        stringArray(data: string[], shape: [number, number]): import("../runtime/types.js").RuntimeStringArray;
+        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>): 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;
+        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;
+    };
+    persistentStore: Map<string, Map<string, RuntimeValue>>;
+    $g: Record<string, RuntimeValue>;
+    /** Active per-statement transient scope. New refcounted values are
+     *  auto-adopted into this scope (rc 0→1) on construction so they
+     *  survive long enough to be bound somewhere; on scope drain at end
+     *  of statement, anything still held only by the scope is decref'd
+     *  to 0 and destroyed. Null when no statement is in flight. */
+    currentScope: RefScope | null;
+    /** When true, `decref` on a zero count throws (loud at the
+     *  underflow site rather than silently leaking). On by default — the
+     *  refcount-driven COW system relies on accurate refcounts to make
+     *  correct mutate-vs-copy decisions. */
+    strictRefcount: boolean;
+    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;
+    /** Callback invoked after cd() to update the implicit cwd search path. */
+    onCwdChange: ((newCwd: string) => 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;
+    hotLoops: Map<string, {
+        file: string;
+        line: number;
+        kind: "for" | "while";
+        iterations: number;
+        callCount: number;
+        totalTimeMs: number;
+    }>;
+    constructor(options: ExecOptions, initialVariableValues?: Record<string, RuntimeValue> | undefined);
+    /** Throw CancellationError if the cancel flag has been set. */
+    checkCancel(): void;
+    /** Run `fn` with a fresh `RefScope` as `this.currentScope`. On return,
+     *  every value adopted into the scope is decref'd. Used by `execStmt`
+     *  to bound the lifetime of expression transients to one statement. */
+    withScope<T>(fn: () => T): T;
+    /** Register the implicit default figure (handle 1) the first time a graphics
+     *  op runs without an explicit `figure`, so a later no-arg `figure` allocates
+     *  a new handle instead of reusing 1 (MATLAB semantics). */
+    ensureCurrentFigure(): void;
+    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;
+    /** Begin buffering output for a speculative execution attempt.
+     *  Pair with exactly one `commitOutputCapture()` or
+     *  `discardOutputCapture()`. */
+    beginOutputCapture(): void;
+    /** Emit the buffered output (to the parent capture frame if nested,
+     *  else to the real sink) — call when the attempt succeeded. */
+    commitOutputCapture(): void;
+    /** Drop the buffered output — call when the attempt bailed, so a
+     *  subsequent re-run is the only thing that emits. */
+    discardOutputCapture(): 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;
+    get displayResults(): boolean;
+    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;
+    /** Check if any class instance in the values has a given method. */
+    private _classHasMethod;
+    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;
+    /** Read the hold state, for `ishold()` queries. */
+    ishold(): RuntimeValue;
+    /** Current axis limits of the active axes, as MATLAB's `axis` query
+     *  returns them: `[xmin xmax ymin ymax]` (2-D) or with `zmin zmax`
+     *  appended (3-D). Reduces the accumulated plot instructions into a figure
+     *  state and reads the current axes' explicit/data-derived limits. */
+    currentAxisLimits(): number[];
+    drawnow(): void;
+    pause(seconds: unknown): void;
+    readInput(prompt: string): string;
+}
+export declare const rstr: (s: RuntimeString | RuntimeChar) => string;
+/** Empty MATLAB-style stack field: 0x1 struct with file/name/line fields. */
+export declare function emptyStackField(): RuntimeValue;
+/**
+ * Build a MATLAB-style stack struct array from a RuntimeError's callStack.
+ * Index 1 is the innermost frame (where the error was thrown).
+ */
+export declare function buildStackField(e: RuntimeError): RuntimeValue;

package/dist-browser/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, 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, rt?: Runtime): 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-browser/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-browser/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, rt?: import("./refcount.js").RefcountRuntime): 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[], rt?: import("./refcount.js").RefcountRuntime): unknown;

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

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

@@ -0,0 +1,129 @@
+/**
+ * Plot-related operations for the runtime.
+ */
+import { type RuntimeValue } from "../runtime/index.js";
+import type { PlotInstruction } from "../../graphics/types.js";
+import type { ExecOptions } from "../executeCode.js";
+import type { Runtime } from "./runtime.js";
+export declare function plotInstr(plotInstructions: PlotInstruction[], instr: {
+    type: "set_figure_handle";
+    handle: unknown;
+} | {
+    type: "plot";
+    x: unknown;
+    y: unknown;
+} | {
+    type: "set_hold";
+    value: unknown;
+} | {
+    type: "set_title";
+    text: unknown;
+} | {
+    type: "set_xlabel";
+    text: unknown;
+} | {
+    type: "set_ylabel";
+    text: unknown;
+} | {
+    type: "set_shading";
+    shading: unknown;
+} | {
+    type: "close";
+} | {
+    type: "close_all";
+} | {
+    type: "clf";
+} | {
+    type: "cla";
+    reset: boolean;
+} | {
+    type: "set_subplot";
+    rows: unknown;
+    cols: unknown;
+    index: unknown;
+} | {
+    type: "set_sgtitle";
+    text: unknown;
+} | {
+    type: "set_grid";
+    value: unknown;
+} | {
+    type: "set_box";
+    value: unknown;
+} | {
+    type: "set_zlabel";
+    text: unknown;
+} | {
+    type: "set_colorbar";
+    value: unknown;
+    location?: unknown;
+} | {
+    type: "set_colormap";
+    name: unknown;
+    data?: number[][];
+} | {
+    type: "set_axis";
+    value: unknown;
+} | {
+    type: "set_caxis";
+    limits: [number, number];
+}): void;
+export declare function viewCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function plotCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+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;
+export declare function imagescCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function pcolorCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function contourCall(plotInstructions: PlotInstruction[], args: RuntimeValue[], filled: boolean): void;
+export declare function meshCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function scatterCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function barCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function barhCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function bar3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function bar3hCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function stairsCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function errorbarCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function semilogxCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function semilogyCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function areaCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function loglogCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+/**
+ * fplot(f), fplot(f, xinterval), fplot(funx, funy),
+ * fplot(funx, funy, tinterval), fplot(..., LineSpec)
+ */
+export declare function fplotCall(rt: Runtime, plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+/**
+ * fplot3(funx, funy, funz), fplot3(funx, funy, funz, tinterval),
+ * fplot3(..., LineSpec)
+ */
+export declare function fplot3Call(rt: Runtime, plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function scatter3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function histogramCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function histogram2Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function boxchartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function swarmchartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function swarmchart3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function piechartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function donutchartCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function heatmapCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function quiverCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function quiver3Call(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function legendCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): void;
+export declare function drawnow(plotInstructions: PlotInstruction[], options: ExecOptions): void;
+export declare function pause(seconds: unknown): void;
+/**
+ * streamline(X,Y,U,V,startX,startY) — compute and plot 2D streamlines.
+ * streamline(verts) — plot from pre-computed cell array of vertex matrices.
+ * Returns a dummy graphics handle.
+ */
+export declare function streamlineCall(plotInstructions: PlotInstruction[], args: RuntimeValue[]): RuntimeValue;
+/**
+ * stream2(X,Y,U,V,startX,startY) — compute 2D streamline vertices.
+ * Returns a cell array of Nx2 vertex matrices.
+ */
+export declare function stream2Call(args: RuntimeValue[]): RuntimeValue;

package/dist-browser/numbl-core/runtime/sentinels.d.ts

@@ -0,0 +1,4 @@
+/** Sentinel value representing the colon operator (:) in indexing. */
+export declare const COLON_SENTINEL: unique symbol;
+/** Sentinel value representing the `end` keyword in indexing. */
+export declare const END_SENTINEL: unique symbol;

package/dist-browser/numbl-core/runtime/specialBuiltinNames.d.ts

@@ -0,0 +1,2 @@
+/** Names of all special builtins. Standalone module to avoid circular imports. */
+export declare const SPECIAL_BUILTIN_NAMES: readonly string[];

package/dist-browser/numbl-core/runtime/specialBuiltins.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Special builtin functions that require direct runtime access.
+ *
+ * These builtins are registered as IBuiltins (via registerDynamicIBuiltin)
+ * that close over the Runtime instance, unifying them with the standard
+ * IBuiltin dispatch path.
+ */
+import type { Runtime } from "./runtime.js";
+export { SPECIAL_BUILTIN_NAMES } from "./specialBuiltinNames.js";
+/**
+ * Register all special builtins as IBuiltins closing over the runtime instance.
+ */
+export declare function registerSpecialBuiltins(rt: Runtime): void;

package/dist-browser/numbl-core/runtime/struct-access.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Struct and class instance field access.
+ */
+import { type RuntimeValue } from "./types.js";
+import { type RefcountRuntime } from "./refcount.js";
+export declare function applyHandleProperty(trace: Record<string, unknown>, traceType: string, field: string, value: RuntimeValue): {
+    key: string;
+    value: unknown;
+};
+export declare function getRTValueField(base: RuntimeValue, field: string): RuntimeValue;
+export declare function setRTValueField(base: RuntimeValue, field: string, value: RuntimeValue, rt?: RefcountRuntime): RuntimeValue;