numbl 0.4.21 → 0.4.22

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

@@ -14,11 +14,13 @@ import { type RuntimeValue, type RuntimeLogical, type RuntimeTensor, type Runtim
 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 { PlotInstruction } from "../plotting/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";
+import "./specialBuiltins.js";
+import "../plotting/builtins.js";
 export declare class Runtime {
     private options;
     private initialVariableValues?;
@@ -111,7 +113,7 @@ export declare class Runtime {
     strictRefcount: boolean;
     activeAccessors: Set<string>;
     resolveClassMethod: ((className: string, methodName: string) => ((...args: any[]) => any) | null) | null;
-    getClassParent: ((className: string) => string | null) | null;
+    getClassAncestors: ((className: string) => string[]) | 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;
@@ -119,27 +121,15 @@ export declare class Runtime {
     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;
+    /** Warning identifiers turned off with warning('off', id); 'all' covers
+     *  identifiers without their own entry. */
+    warningsOff: Set<string>;
+    /** Counter for uihtml component ids. */
+    uihtmlSeq: number;
     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>;
@@ -166,7 +156,6 @@ export declare class Runtime {
      *  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, {
@@ -220,8 +209,6 @@ export declare class Runtime {
     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. */
@@ -233,14 +220,6 @@ export declare class Runtime {
     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;
@@ -276,11 +255,8 @@ export declare class Runtime {
      * 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;
+    /** Ancestor class names of a class, or [] if unknown. */
+    classAncestors(className: string): string[];
     /** 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;

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

@@ -6,6 +6,12 @@
  */
 import { type RuntimeValue, type RuntimeLogical, RuntimeFunction } from "../runtime/index.js";
 import type { Runtime } from "./runtime.js";
+/** Returned by `invokeBuiltin` when `name` is not a builtin. */
+export declare const NOT_A_BUILTIN: unique symbol;
+/** Call the builtin `name`: an execution-specific custom builtin if one is
+ *  set, else the registered IBuiltin. Returns NOT_A_BUILTIN if neither
+ *  exists. A builtin with no outputs errors when outputs are requested. */
+export declare function invokeBuiltin(rt: Runtime, name: string, nargout: number, args: unknown[]): unknown;
 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;

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

@@ -1,13 +1,7 @@
 /**
  * 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.
+ * They are registered once, at module load, as ordinary IBuiltins; each call
+ * gets the active Runtime from the current-runtime stack.
  */
-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;
+export {};

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

@@ -8,15 +8,11 @@
  * when an event arrives from the iframe — mirroring MATLAB, where the script
  * returns but its callbacks keep firing.
  *
- * Dispatch re-activates the run's own special-builtin closures (captured at
- * end-of-run, NOT re-registered — re-registering would reset their counters)
- * and pushes the runtime so `disp`, plotting, and `sendEventToHTMLSource`
- * inside the callback reach this runtime. This mirrors executeCode's own
- * save/restore of SPECIAL_BUILTIN_NAMES.
+ * Dispatch pushes the runtime so `disp`, plotting, and
+ * `sendEventToHTMLSource` inside the callback reach this runtime.
  */
 import type { Runtime } from "./runtime.js";
-import type { PlotInstruction } from "../../graphics/types.js";
-import { type IBuiltin } from "../interpreter/builtins/types.js";
+import type { PlotInstruction } from "../plotting/types.js";
 export interface UihtmlSession {
     /** True while at least one component still has a registered callback. */
     hasCallbacks(): boolean;
@@ -32,9 +28,5 @@ export interface UihtmlSession {
     /** Release the retained callback handles (and their refs). */
     dispose(): void;
 }
-/**
- * Build a session over a runtime that registered uihtml callbacks.
- * `activeSpecials` is a snapshot of this runtime's special-builtin closures,
- * captured at end-of-run while they are still installed globally.
- */
-export declare function createUihtmlSession(rt: Runtime, activeSpecials: Map<string, IBuiltin>, onDrawnow?: (plotInstructions: PlotInstruction[]) => void): UihtmlSession;
+/** Build a session over a runtime that registered uihtml callbacks. */
+export declare function createUihtmlSession(rt: Runtime, onDrawnow?: (plotInstructions: PlotInstruction[]) => void): UihtmlSession;

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

@@ -1,7 +1,10 @@
 /**
  * Tensor shape/indexing utilities.
  */
-import { type RuntimeTensor } from "./types.js";
+import { type RuntimeTensor, type RuntimeValue } from "./types.js";
+/** The MATLAB size of any runtime value, with at least two dimensions.
+ *  Scalars, strings, structs and objects are 1×1. */
+export declare function valueShape(v: RuntimeValue): number[];
 /** Get 2D size (rows, cols) from shape, padding with 1s as needed.
  *  For N-D tensors (N>2), trailing dimensions are collapsed into cols,
  *  matching MATLAB's behavior when fewer subscripts than dimensions. */

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

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

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

@@ -0,0 +1,64 @@
+/**
+ * The files visible to a run: the caller's workspace files, the implicit cwd,
+ * the search path and the bundled stdlib. Keeps them in sync with addpath,
+ * rmpath and cd, and registers them with the LoweringContext for function
+ * resolution.
+ */
+import type { LoweringContext, FunctionIndex } from "../lowering/loweringContext.js";
+import type { FileIOAdapter } from "../fileIOAdapter.js";
+import type { SystemAdapter } from "../systemAdapter.js";
+import type { WorkspaceFile, NativeBridge } from "./types.js";
+import { type LoadedJsUserFunction } from "../jsUserFunctions.js";
+/** Search-path entry for bundled shim files; always last. */
+export declare const SHIM_SEARCH_PATH = "__numbl_shims__";
+export declare class Workspace {
+    private readonly ctx;
+    private readonly fileIO;
+    private readonly nativeBridge;
+    readonly mFiles: WorkspaceFile[];
+    readonly jsFiles: WorkspaceFile[];
+    readonly wasmFiles: WorkspaceFile[];
+    /** Loaded .numbl.js functions, sorted by search-path priority on rebuild. */
+    jsFunctions: LoadedJsUserFunction[];
+    /** Names of the bundled stdlib and shim files. */
+    readonly bundledFileNames: Set<string>;
+    /** The current directory, searched first unless it is an explicit path. */
+    implicitCwd: string | null;
+    /** True once addpath, rmpath or cd changed the workspace. */
+    modified: boolean;
+    /** Notified when a .m file enters or leaves the workspace after startup. */
+    onFileAdded?: (f: WorkspaceFile) => void;
+    onFileRemoved?: (name: string) => void;
+    constructor(ctx: LoweringContext, fileIO: FileIOAdapter | undefined, nativeBridge: NativeBridge | undefined);
+    get searchPaths(): string[];
+    private resolve;
+    /** Parse a .m file into the shared AST cache. A file that fails to parse
+     *  is skipped with a warning rather than aborting the run. */
+    private parse;
+    /** Initial file set: the caller's files, the implicit cwd, the explicit
+     *  search paths (files already provided are not re-added) and the bundled
+     *  stdlib and shims. All .numbl.js files load as one batch so library
+     *  files (`_name.numbl.js`) are visible across directories. */
+    load(files: WorkspaceFile[], searchPaths: string[], implicitCwd: string | null | undefined, system: SystemAdapter | undefined, bundled: WorkspaceFile[]): void;
+    /** Register the current files and .numbl.js functions with the context. */
+    register(): void;
+    /** Re-sort the files by search-path priority, re-register them and return
+     *  a fresh function index. */
+    rebuild(): FunctionIndex;
+    /** Scan a directory: parse its .m files not already known, and (re)load
+     *  its .numbl.js functions. Files are always reloaded because files sent
+     *  earlier (e.g. by the IDE) may have lacked their wasm/native binaries. */
+    private scanDir;
+    /** Drop the files under `dir`, except those for which `keep` is true. */
+    private removeFilesUnder;
+    /** addpath. Returns false if `dir` is already on the path. */
+    addPath(dir: string, position: "begin" | "end"): boolean;
+    /** rmpath. */
+    removePath(dir: string): void;
+    /** cd: make `newCwd` the implicit cwd. Returns false if it already is. */
+    changeCwd(newCwd: string): boolean;
+    /** Search paths to report back to callers (no implicit cwd or shims). */
+    explicitSearchPaths(): string[];
+    /** Files to report back to callers (no bundled stdlib or shims). */
+    userFiles(): WorkspaceFile[];
+}

package/dist-lib/vfs/unzipToFiles.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unzip a ZIP archive from a Uint8Array and return extracted files.
+ */
+export declare function unzipToFiles(zipData: Uint8Array): {
+    path: string;
+    content: Uint8Array;
+}[];