numbl 0.4.21 → 0.4.22

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

@@ -1,336 +0,0 @@
-/**
- * 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, PatchTrace, SurfTrace, ImagescTrace, PcolorTrace, ContourTrace, BarTrace, Bar3Trace, ErrorBarTrace, BoxTrace, PieTrace, HeatmapTrace, QuiverTrace, Quiver3Trace, } from "../../graphics/types.js";
-import type { PlotTrace, Plot3Trace, PatchTrace, SurfTrace, ImagescTrace, PcolorTrace, ContourTrace, BarTrace, Bar3Trace, ErrorBarTrace, BoxTrace, PieTrace, HeatmapTrace, QuiverTrace, Quiver3Trace } from "../../graphics/types.js";
-export declare function resolveColor(v: RuntimeValue | string): [number, number, number] | undefined;
-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[];
-/** Result of parsing line() arguments: a set of 2-D or 3-D traces. */
-export type ParsedLine = {
-    kind: "2d";
-    traces: PlotTrace[];
-} | {
-    kind: "3d";
-    traces: Plot3Trace[];
-};
-/**
- * Parse line() arguments.
- *
- * Supported forms:
- *   line                                  — line from (0,0) to (1,1)
- *   line(x, y)                            — 2-D line(s)
- *   line(x, y, z)                         — 3-D line(s)
- *   line(___, Name, Value)               — Color/LineStyle/LineWidth/Marker/...
- *   line('XData', x, 'YData', y, ...)    — low-level form (black line)
- *   line(ax, ___)                        — leading axes handle (ignored)
- *
- * Like plot/plot3, vector inputs make a single line and matrix inputs make one
- * line per column.
- */
-export declare function parseLineArgs(args: RuntimeValue[]): ParsedLine;
-/** Apply a single patch property (lower-cased key) to the trace. Shared by the
- *  Name-Value, struct, and `set`/handle paths. */
-export declare function applyPatchProp(trace: PatchTrace, key: string, val: RuntimeValue): void;
-/**
- * Parse patch() arguments into a canonical PatchTrace.
- *
- * Supported forms:
- *   patch(X, Y, C)                              — 2-D polygons, color C
- *   patch(X, Y, Z, C)                           — 3-D polygons
- *   patch('XData', X, 'YData', Y[, 'ZData', Z]) — coords as name-value
- *   patch('Faces', F, 'Vertices', V)            — faces/vertices model
- *   patch(S)                                    — struct of patch properties
- *   patch(___, Name, Value)                     — patch properties
- *   patch(ax, ___)                              — leading axes handle (ignored)
- */
-export declare function parsePatchArgs(args: RuntimeValue[]): PatchTrace;
-/**
- * Parse fill() arguments into one patch trace per (X,Y,C) group. fill is the
- * 2-D coordinate form of patch repeated over groups, so it reuses the patch
- * vertex/color/property helpers — the only fill-specific logic is splitting
- * the argument list into X,Y,C triplets.
- *
- * Supported forms:
- *   fill(X, Y, C)
- *   fill(X1, Y1, C1, ..., Xn, Yn, Cn)
- *   fill(___, Name, Value)
- *   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.
- *
- * 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 pcolor() arguments.
- *
- * Supported forms:
- *   pcolor(C)         — C is m×n, X = 1:n, Y = 1:m
- *   pcolor(X, Y, C)   — X, Y, C are m×n matrices (or X is 1×n / Y is m×1)
- *   pcolor(..., Name, Value) — name-value pairs (EdgeColor, FaceAlpha)
- */
-export declare function parsePcolorArgs(args: RuntimeValue[]): PcolorTrace;
-/**
- * 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;
-/** Result of computing contour geometry: the MATLAB contour matrix `C`
- *  (column-major `2 × n` data) plus the level list actually used. */
-export interface ContourMatrix {
-    /** Column-major `2 × n` data for a `RTV.tensor(data, [2, n])`. */
-    data: number[];
-    n: number;
-    levelList: number[];
-}
-/** Compute the MATLAB contour matrix for a parsed contour trace via marching
- *  squares. Each marching-squares segment is emitted as its own two-vertex
- *  contour line (header `[level; 2]` followed by the two `[x; y]` vertices) —
- *  a valid contour matrix whose geometry matches MATLAB's connected polylines
- *  segment-for-segment. */
-export declare function computeContourMatrix(trace: ContourTrace): ContourMatrix;
-/**
- * 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;
-/**
- * Parse quiver() arguments.
- *
- * Supported forms:
- *   quiver(U, V)
- *   quiver(X, Y, U, V)
- *   quiver(..., scale)        — scale: nonnegative number or 'off'
- *   quiver(..., LineSpec)
- *   quiver(..., LineSpec, 'filled')
- *   quiver(..., Name, Value)  — Color, LineStyle, LineWidth, ShowArrowHead, etc.
- *
- * X, Y, U, V can be vectors or matrices. If U,V are matrices and X,Y are
- * vectors, X and Y are expanded to a meshgrid.
- */
-export declare function parseQuiverArgs(args: RuntimeValue[]): QuiverTrace[];
-/**
- * Parse quiver3() arguments.
- *
- * Supported forms:
- *   quiver3(Z, U, V, W)
- *   quiver3(X, Y, Z, U, V, W)
- *   quiver3(..., scale)         — scale: nonnegative number or 'off'
- *   quiver3(..., LineSpec)
- *   quiver3(..., LineSpec, 'filled')
- *   quiver3(..., Name, Value)   — Color, LineStyle, LineWidth, ShowArrowHead, …
- */
-export declare function parseQuiver3Args(args: RuntimeValue[]): Quiver3Trace;

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

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

package/dist-graphics/graphics/surfColormap.d.ts

@@ -1,2 +0,0 @@
-/** Parula-inspired colormap for surface plots */
-export declare function colormapLookup(t: number): [number, number, number];

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

@@ -1,76 +0,0 @@
-/**
- * Dispatch context — passed to every executor call.
- *
- * Provides env access, type-info queries, sub-dispatch into the
- * registry, and runtime callbacks. Memoizes type-info lookups for the
- * lifetime of a single dispatch so repeated `typeOf(name)` calls from
- * different executors don't re-infer.
- */
-import type { Interpreter } from "../interpreter/interpreter.js";
-import type { Stmt } from "../parser/types.js";
-import type { ControlSignal } from "../interpreter/types.js";
-import type { Registry } from "./registry.js";
-import { type JitType } from "../jitTypes.js";
-export declare class DispatchContext {
-    readonly interp: Interpreter;
-    readonly registry: Registry;
-    /** When true, only no-bail executors are eligible. Set when the
-     *  caller's compiled artifact has emitted observable side effects
-     *  that mustn't repeat. */
-    readonly requireNoBail: boolean;
-    /** Per-dispatch memoization of typeOf(name) lookups. */
-    private readonly typeCache;
-    /** Re-entrancy guard: which executors are currently running on
-     *  which head stmts. Prevents an executor sub-dispatching back into
-     *  itself on the same stmt. */
-    private readonly active;
-    /** Sibling list and head index for the current dispatch. Set by
-     *  Registry.dispatch before calling executors; read by peekSibling.
-     *  Most executors don't read these directly. */
-    private _siblings;
-    private _i;
-    constructor(interp: Interpreter, registry: Registry, requireNoBail: boolean, active?: Set<string>);
-    /** Look up a name's JitType from the interpreter env, memoized. */
-    typeOf(name: string): JitType;
-    /** Read a value from env (no inference). Returns undefined if unbound. */
-    envValue(name: string): unknown;
-    /** Peek at a sibling stmt at `offset` from the current head.
-     *  offset=0 is the current stmt; positive values look ahead.
-     *  Returns null if the offset is past the end of the scope. Used by
-     *  chain-style executors that may consume multiple consecutive
-     *  stmts. */
-    peekSibling(offset: number): Stmt | null;
-    /** Sibling list of the current scope. The head stmt is at
-     *  `siblings[headIndex]`. Most executors don't need this directly —
-     *  use `peekSibling(offset)` for lookahead. The rare cases that
-     *  forward the raw list to a legacy adapter (the chain executor) or
-     *  claim the whole scope (the top-level executor) read these. */
-    get siblings(): readonly Stmt[];
-    get headIndex(): number;
-    /** @internal Set the position state for an upcoming dispatch. Only
-     *  the registry calls this. */
-    _setPosition(siblings: readonly Stmt[], i: number): void;
-    /** Reset per-dispatch state so this context can be reused for the
-     *  next stmt in a sibling loop. The reentrancy guard is expected to
-     *  already be empty (every pushActive is paired with a popActive in
-     *  Registry.runCandidate's finally). */
-    resetForNextDispatch(): void;
-    /** Construct a child context for sub-dispatch. `requireNoBail` is
-     *  the OR of the parent flag and the parent executor's
-     *  `requireNoBailInChildren` declaration. */
-    childContext(requireNoBail: boolean): DispatchContext;
-    /** @internal Whether the reentrancy guard has any entries. The
-     *  registry uses this to skip the guard check on the hot path —
-     *  when nothing is active there's nothing to detect. */
-    get hasActive(): boolean;
-    /** @internal Used by the registry's reentrancy guard. Pre-checked
-     *  with hasActive on the hot path, so the actual `has` only fires
-     *  during sub-dispatch. */
-    isActive(executorName: string, stmt: Stmt): boolean;
-    /** @internal */
-    pushActive(executorName: string, stmt: Stmt): void;
-    /** @internal */
-    popActive(executorName: string, stmt: Stmt): void;
-}
-/** Re-export for the runner's signal type. */
-export type { ControlSignal };

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

@@ -1,14 +0,0 @@
-/**
- * Executor registry — public surface.
- *
- * See docs/developer_reference/executors.md for the design.
- */
-export type { Executor, CostEstimate, BailReason, RunResult, Proposal, } from "./types.js";
-export { Registry, makeRootContext } from "./registry.js";
-export type { DispatchResult, CallDispatchResult, WholeScopeResult, } from "./registry.js";
-export { DispatchContext } from "./context.js";
-export { ExecutorCache } from "./cache.js";
-export type { JitType, SignCategory } from "../jitTypes.js";
-export { jitTypeKey, unifyJitTypes, isScalarType, isTensorType, isComplexType, isKnownInteger, } from "../jitTypes.js";
-export { inferJitType } from "../interpreter/builtins/types.js";
-export { registerExecutorsForOpt } from "./plugins.js";

package/dist-lib/numbl-core/executors/jit/cJitCallExecutor.d.ts

@@ -1,35 +0,0 @@
-/**
- * cjit-call — C-backed JIT executor for user-function calls.
- *
- * Mirrors `callExecutor.ts` (the JS-emit sibling) but routes the
- * specialization's emitted code through `compileSpecC` →
- * `cc -shared -fPIC -O3` → `dlopen` via koffi instead of
- * `new Function(source)`. The dispatch, gating, and caching
- * conventions are otherwise identical, so a sibling executor can
- * register alongside the JS path at the same opt level without any
- * arbitration in the dispatcher beyond cost-based selection.
- *
- * Declines when:
- *   - `nativeBridge` / `koffi` are not available (browser).
- *   - Any param or output type fails the C-FFI feasibility check
- *     (`compilerTypeToCDecl` returns null).
- *   - mtoc2 throws `UnsupportedConstruct` / `JitTypeError` at lowering.
- */
-import type { Executor } from "../types.js";
-import { type JitType } from "../../jitTypes.js";
-import type { FunctionDef } from "../../interpreter/types.js";
-import { type Type as CompilerType, type SpecCSignature } from "../../jit/index.js";
-import { type CompiledC } from "./compileC.js";
-interface CJitCallData {
-    readonly fn: FunctionDef;
-    readonly nargout: number;
-    readonly argTypes: readonly JitType[];
-    readonly compilerArgTypes: readonly CompilerType[];
-    readonly args: readonly unknown[];
-}
-interface CompiledArtifact {
-    readonly compiled: CompiledC;
-    readonly signature: SpecCSignature;
-}
-export declare const cJitCallExecutor: Executor<CJitCallData, CompiledArtifact | null>;
-export {};

package/dist-lib/numbl-core/executors/jit/cJitLoopExecutor.d.ts

@@ -1,31 +0,0 @@
-/**
- * cjit-loop — C-backed JIT executor for outermost For/While
- * loops. Mirrors `loopExecutor.ts` (JS-emit sibling) but routes
- * through `compileSpecC` → `cc -shared` → `koffi`. See
- * `cJitCallExecutor.ts` for the marshaling protocol; this file just
- * adapts the loop-shape `data` to the same C-side pipeline.
- */
-import type { Executor } from "../types.js";
-import { type JitType } from "../../jitTypes.js";
-import type { Stmt } from "../../parser/index.js";
-import type { ConstHandle } from "../classification.js";
-import { type Type as CompilerType, type SpecCSignature } from "../../jit/index.js";
-import { type CompiledC } from "./compileC.js";
-interface CJitLoopData {
-    readonly loopStmt: Stmt & {
-        type: "For" | "While";
-    };
-    readonly inputs: readonly string[];
-    readonly outputs: readonly string[];
-    readonly inputTypes: readonly JitType[];
-    readonly compilerInputTypes: readonly CompilerType[];
-    readonly constHandles: readonly ConstHandle[];
-    readonly currentFile: string;
-    readonly cacheKey: string;
-}
-interface CompiledArtifact {
-    readonly compiled: CompiledC;
-    readonly signature: SpecCSignature;
-}
-export declare const cJitLoopExecutor: Executor<CJitLoopData, CompiledArtifact | null>;
-export {};

package/dist-lib/numbl-core/executors/jit/cJitTopLevelExecutor.d.ts

@@ -1,29 +0,0 @@
-/**
- * cjit-top-level — C-backed JIT executor for whole-script bodies.
- *
- * Mirrors `topLevelExecutor.ts` (JS-emit sibling) but routes through
- * `compileSpecC` → `cc -shared` → `koffi`. See `cJitCallExecutor.ts`
- * for the marshaling protocol. Same `isAllSuppressed` gate as the JS
- * sibling so `displayAssign`/`displayResult` semantics stay on the
- * interpreter path.
- */
-import type { Executor } from "../types.js";
-import { type JitType } from "../../jitTypes.js";
-import type { Stmt } from "../../parser/index.js";
-import { type Type as CompilerType, type SpecCSignature } from "../../jit/index.js";
-import { type CompiledC } from "./compileC.js";
-interface CJitTopLevelData {
-    readonly stmts: readonly Stmt[];
-    readonly inputs: readonly string[];
-    readonly outputs: readonly string[];
-    readonly inputTypes: readonly JitType[];
-    readonly compilerInputTypes: readonly CompilerType[];
-    readonly currentFile: string;
-    readonly cacheKey: string;
-}
-interface CompiledArtifact {
-    readonly compiled: CompiledC;
-    readonly signature: SpecCSignature;
-}
-export declare const cJitTopLevelExecutor: Executor<CJitTopLevelData, CompiledArtifact | null>;
-export {};

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

@@ -1,5 +0,0 @@
-/**
- * Dummy no-op built-in function names.
- * Used as placeholders for unsupported functionality.
- */
-export declare function getDummyBuiltinNames(): string[];

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

@@ -1,23 +0,0 @@
-/**
- * Host bag passed to `Builtin.call` for the interpreter backend.
- *
- * Mirrors nexl's `RuntimeContext`. Side-effecty builtins (`disp`,
- * `fprintf`, `error`, plot dispatch, …) consult `helpers.write` to
- * emit text. Pure builtins ignore the bag.
- *
- * `write` is the JS analogue of C's `printf`. The CLI provides one
- * backed by `process.stdout.write`; the browser provides one that
- * pushes lines to the console panel; future test runners provide
- * one that captures into a buffer for byte-for-byte comparison.
- *
- * As the interpreter grows, additional hooks (`time`, `plot`,
- * `error`, …) will join this bag. Adding a hook here is the
- * single source of truth — every host supplies it.
- */
-export interface RuntimeHelpers {
-    /** Append text to stdout. No implicit newline. */
-    write(s: string): void;
-}
-export interface RuntimeContext {
-    helpers: RuntimeHelpers;
-}

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

@@ -1,10 +0,0 @@
-/**
- * Map a runtime value back into a Type. Used by the interpreter to
- * feed `argTypes` into a builtin's `transfer` (for validation) and
- * `call` (for type-dispatched implementations) — so that the three
- * hooks (`emitC`, `emitJs`, `call`) all branch on the same `argTypes`
- * shape rather than reinventing dispatch per-backend.
- */
-import { type Type } from "../lowering/types.js";
-import { type RuntimeValue } from "./value.js";
-export declare function inferTypeFromValue(v: RuntimeValue): Type;

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

@@ -1,101 +0,0 @@
-/**
- * Runtime value carrier for the interpreter backend. Mirrors nexl's
- * `RuntimeValue` design: a discriminated-via-typeof union for the
- * common cases plus tagged-object wrappers for the kinds JS can't
- * distinguish natively.
- *
- * MVP scope (Phase 3): real-double scalars, booleans (logical),
- * strings (double-quoted), chars (single-quoted), real-double tensors.
- * Complex / structs / classes / handles / void / cells follow as the
- * type lattice and interpreter coverage expand.
- *
- * Builtin `call` implementations narrow via `typeof` / `isTensor` /
- * `isChar` and dispatch through the same `argTypes` shape that
- * `emitC` / `emitJs` consume — keeping the three backends parallel.
- */
-export type RuntimeValue = number | boolean | string | RuntimeTensor | RuntimeChar | RuntimeComplex | RuntimeStruct | RuntimeHandle;
-/** Function handle. Named handles (`@foo`) keep the source name and
- *  dispatch via the interpreter's normal call-site resolution at the
- *  call point. Anonymous handles (`@(p1, ...) body`) capture every
- *  visible binding by value at the @-site and run `body` in a fresh
- *  env when invoked. */
-export type RuntimeHandle = {
-    readonly mtoc2Handle: true;
-    readonly kind: "named";
-    readonly name: string;
-} | {
-    readonly mtoc2Handle: true;
-    readonly kind: "anon";
-    readonly params: ReadonlyArray<string>;
-    readonly body: unknown;
-    readonly captures: Readonly<Record<string, RuntimeValue>>;
-};
-/** Narrow a RuntimeValue to a function handle. */
-export declare function isHandleValue(v: RuntimeValue): v is RuntimeHandle;
-/** Struct/object — plain JS object whose keys are field names. The
- *  c-aot path emits a typedef'd C struct; the JS path just uses a
- *  bare object. Recurses through field values that may themselves be
- *  any RuntimeValue (including nested structs). */
-export type RuntimeStruct = {
-    readonly [field: string]: RuntimeValue;
-};
-/** Real or complex double tensor. `data` is the real lane,
- *  column-major to match numbl's `RuntimeTensor.data`. `imag` is the
- *  imaginary lane (same length and orientation as `data`); absent for
- *  real-only tensors. Mirrors the C representation's split-buffer
- *  layout — codegen / interpreter dispatch on `imag !== undefined`
- *  the way the C side dispatches on `imag != NULL`. The shape array
- *  is owned by the value; do not mutate.
- *
- *  `isLogical` flags this tensor as the result of a logical operation
- *  (`~`, `<`, `==`, `&&`, …) so downstream index-slot resolution can
- *  treat it as a mask instead of an IndexVec — same role as numbl's
- *  `_isLogical` on its RuntimeTensor. The flag is one-way (once set,
- *  stays set across copies via the helper) and absent on numeric
- *  tensors; helper sites that don't care leave it undefined. */
-export interface RuntimeTensor {
-    readonly mtoc2Tag: "tensor";
-    readonly shape: number[];
-    readonly data: Float64Array;
-    readonly imag?: Float64Array;
-    readonly isLogical?: boolean;
-}
-/** Single-quoted char-array (`'foo'`). Distinct from `"foo"` strings
- *  because numbl treats them differently: `length('foo') === 3` but
- *  `length("foo") === 1`. */
-export interface RuntimeChar {
-    readonly mtoc2Tag: "char";
-    readonly value: string;
-}
-/** Scalar complex value — JS-side analogue of the `mtoc2_complex_t`
- *  struct in `cscalar.h`. The cscalar runtime helpers
- *  (`mtoc2_cmake`, `mtoc2_creal`, etc.) consume and produce this
- *  shape. We DON'T tag it the way tensor / char are tagged because
- *  emitJs literals (`{re: 0, im: 1}`) and runtime calls produce the
- *  bare object form — adding a tag would force every helper to
- *  re-wrap. Use `isComplexValue` for narrowing. */
-export interface RuntimeComplex {
-    readonly re: number;
-    readonly im: number;
-}
-/** Narrow a RuntimeValue to a complex scalar. Matches the cscalar
- *  helpers' `{re, im}` shape. */
-export declare function isComplexValue(v: RuntimeValue): v is RuntimeComplex;
-export declare function makeTensor(shape: number[], data: Float64Array): RuntimeTensor;
-/** Complex tensor with both lanes. `data` is the real lane, `imag`
- *  the imaginary lane; both must have the same length and match the
- *  product of `shape`. */
-export declare function makeComplexTensor(shape: number[], data: Float64Array, imag: Float64Array): RuntimeTensor;
-/** True iff this tensor carries an imaginary lane. */
-export declare function isComplexTensor(v: RuntimeTensor): boolean;
-export declare function makeChar(value: string): RuntimeChar;
-export declare function isTensor(v: RuntimeValue): v is RuntimeTensor;
-export declare function isChar(v: RuntimeValue): v is RuntimeChar;
-/** Materialize a scalar value as a plain JS number. Used by builtins
- *  that need to treat scalar tensors and scalar numbers uniformly. */
-export declare function toScalarNumber(v: RuntimeValue): number;
-/** MATLAB-style truthiness — for `if` / `while` / `&&` / `||`.
- *  Scalar non-zero, all-elements-non-zero for tensors, nonempty
- *  text. The interpreter uses this; codegen relies on the matching
- *  C-side `__nonzero` helpers. */
-export declare function isTruthy(v: RuntimeValue): boolean;