numbl 0.4.19 → 0.4.22

package/dist-browser/numbl-core/plotting/parseArgsSurface.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Argument parsers for gridded data: surf, mesh, pcolor, imagesc, contour
+ * (including the MATLAB contour matrix), and heatmap.
+ */
+import { type RuntimeValue } from "../runtime/types.js";
+import type { SurfTrace, ImagescTrace, PcolorTrace, ContourTrace, HeatmapTrace } from "./types.js";
+/**
+ * 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 imagesc() arguments.
+ *
+ * Supported forms:
+ *   imagesc(C)         — C is m×n matrix
+ *   imagesc(x, y, C)   — x and y are vectors defining axis limits
+ *   imagesc(..., clims) — clims = [low high] sets the axes' color limits
+ */
+export declare function parseImagescArgs(args: RuntimeValue[]): {
+    trace: ImagescTrace;
+    clims?: [number, number];
+};
+/**
+ * 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 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-browser/numbl-core/plotting/streamline.d.ts

@@ -0,0 +1,16 @@
+/**
+ * streamline / stream2: trace 2-D streamlines through a gridded vector field.
+ */
+import type { RuntimeValue } from "../runtime/index.js";
+import type { PlotInstruction } from "./types.js";
+/**
+ * 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-graphics/graphics → dist-browser/numbl-core/plotting}/types.d.ts

@@ -1,12 +1,12 @@
 /**
- * Shared graphics types used by both numbl-core and the rendering layer.
+ * Plot data types: the trace interfaces and `PlotInstruction`, the
+ * serializable contract between numbl-core (which emits instructions) and the
+ * renderer in src/graphics/ (which consumes them). The renderer imports these
+ * from here; numbl-core does not depend on src/graphics/.
  *
- * This file is the single source of truth for plot trace interfaces and
- * PlotInstruction.  numbl-core re-exports these types so that internal
- * runtime code can import them without reaching into src/graphics/.
- *
- * The numbl-vscode extension syncs this file (and the rest of src/graphics/)
- * via devel/sync-graphics.sh.
+ * The numbl-vscode extension syncs src/graphics/ via devel/sync-graphics.sh;
+ * it also needs the core modules the renderer imports (types, figuresReducer,
+ * axisLimits, imagescExtent, colormaps).
  */
 export interface PlotTrace {
     x: number[];
@@ -53,6 +53,8 @@ export interface PatchTrace {
     edgeColor?: [number, number, number] | "flat" | "interp" | "none";
     /** Face transparency in [0,1]. */
     faceAlpha?: number;
+    /** Edge transparency in [0,1]. */
+    edgeAlpha?: number;
     lineWidth?: number;
     lineStyle?: string;
     marker?: string;

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

@@ -21,13 +21,5 @@ import { type RefcountRuntime } from "./refcount.js";
  *  be copied (handle-class instances, primitives) — the caller can
  *  `=== v` test if the copy was a no-op. */
 export declare function cowCopy(v: RuntimeValue): RuntimeValue;
-/** If `v` is shared (rc-driven), return a fresh non-shared copy;
- *  otherwise return `v` unchanged. The new wrapper has refcount 0
- *  (or 1 if the active scope adopts it via the constructor); the
- *  caller must bind it into the parent slot to keep it alive.
- *
- *  Returns the original `v` for handle-class instances and primitives —
- *  callers can `result === v` test to detect a no-op. */
-export declare function cowIfShared(v: RuntimeValue): RuntimeValue;
 export { isShared } from "./refcount.js";
 export type { RefcountRuntime };

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

@@ -53,9 +53,6 @@ export declare abstract class Refcounted {
      *  RuntimeDummyHandle, etc.). */
     protected _destroy(_rt: RefcountRuntime): void;
 }
-/** True if the value is a container that participates in refcounting.
- *  Primitives (number, boolean, string) return false. */
-export declare function isRefcountable(v: unknown): v is Refcounted;
 /** Increment refcount on a value if it's a container; primitives are noop. */
 export declare function incref(v: unknown): void;
 /** Decrement refcount on a value if it's a container; primitives are noop. */

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

@@ -0,0 +1,15 @@
+/**
+ * Registration helpers for builtins that need the active Runtime. They are
+ * ordinary IBuiltins; each call gets the runtime from the current-runtime
+ * stack.
+ */
+import type { Runtime } from "./runtime.js";
+import type { RuntimeValue } from "./types.js";
+/** The runtime executing the current call. */
+export declare function currentRuntime(): Runtime;
+/** Register a builtin that accepts any args and gets the active runtime. */
+export declare function registerSpecial(name: string, fn: (nargout: number, args: RuntimeValue[], rt: Runtime) => unknown): void;
+/** Register a builtin with no outputs. The call site raises "Too many output
+ *  arguments." when nargout > 0, and `ans` is not set when called as a
+ *  statement. */
+export declare function registerSpecialVoid(name: string, fn: (args: RuntimeValue[], rt: Runtime) => void): void;

package/dist-browser/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-browser/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-browser/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-browser/numbl-core/runtime/types.d.ts

@@ -173,6 +173,15 @@ export declare class RuntimeStructArray extends Refcounted {
 }
 /** Sparse matrix in CSC (Compressed Sparse Column) format, matching MATLAB's
  *  internal representation. */
+/** Cached structural analysis of a sparse matrix (see helpers/sparse-direct). */
+export interface SparseTriInfo {
+    upper: boolean;
+    lower: boolean;
+    /** Index into ir/pr of the diagonal entry of each column, or -1. */
+    diagPos: Int32Array;
+    /** Diagonal values (0 where absent). */
+    diag: Float64Array;
+}
 export declare class RuntimeSparseMatrix extends Refcounted {
     readonly kind: "sparse_matrix";
     m: number;
@@ -181,6 +190,9 @@ export declare class RuntimeSparseMatrix extends Refcounted {
     jc: Int32Array;
     pr: Float64Array;
     pi: Float64Array | undefined;
+    /** Lazily computed by triangularInfo(); valid because sparse matrices are
+     *  never mutated in place (indexed assignment builds a new matrix). */
+    _triInfo: SparseTriInfo | undefined;
     constructor(m: number, n: number, ir: Int32Array, jc: Int32Array, pr: Float64Array, pi?: Float64Array);
 }
 /** Dictionary mapping unique keys to values (MATLAB R2022b+). */

package/dist-browser/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-browser/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-browser/numbl-core/version.d.ts

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

package/dist-browser/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-browser/ts-lapack/src/BLAS/dsymv.d.ts

@@ -0,0 +1 @@
+export declare function dsymv(uplo: number, n: number, alpha: number, a: Float64Array, aOff: number, lda: number, x: Float64Array, xOff: number, incx: number, beta: number, y: Float64Array, yOff: number, incy: number): void;

package/dist-browser/ts-lapack/src/BLAS/dsyr2.d.ts

@@ -0,0 +1 @@
+export declare function dsyr2(uplo: number, n: number, alpha: number, x: Float64Array, xOff: number, incx: number, y: Float64Array, yOff: number, incy: number, a: Float64Array, aOff: number, lda: number): void;

package/dist-browser/ts-lapack/src/SRC/dlae2.d.ts

@@ -0,0 +1,4 @@
+export declare function dlae2(a: number, b: number, c: number): {
+    rt1: number;
+    rt2: number;
+};

package/dist-browser/ts-lapack/src/SRC/dlaev2.d.ts

@@ -0,0 +1,6 @@
+export declare function dlaev2(a: number, b: number, c: number): {
+    rt1: number;
+    rt2: number;
+    cs1: number;
+    sn1: number;
+};

package/dist-browser/ts-lapack/src/SRC/dlanst.d.ts

@@ -0,0 +1 @@
+export declare function dlanst(norm: number, n: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dlansy.d.ts

@@ -0,0 +1 @@
+export declare function dlansy(norm: number, uplo: number, n: number, a: Float64Array, aOff: number, lda: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dlasrt.d.ts

@@ -0,0 +1 @@
+export declare function dlasrt(id: number, n: number, d: Float64Array, dOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dorgtr.d.ts

@@ -0,0 +1 @@
+export declare function dorgtr(uplo: number, n: number, a: Float64Array, aOff: number, lda: number, tau: Float64Array, tauOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dsteqr.d.ts

@@ -0,0 +1,4 @@
+export declare const COMPZ_N = 0;
+export declare const COMPZ_V = 1;
+export declare const COMPZ_I = 2;
+export declare function dsteqr(compz: number, n: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, z: Float64Array, zOff: number, ldz: number, work: Float64Array, workOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dsyev.d.ts

@@ -0,0 +1 @@
+export declare function dsyev(wantz: boolean, uplo: number, n: number, a: Float64Array, aOff: number, lda: number, w: Float64Array, wOff: number): number;

package/dist-browser/ts-lapack/src/SRC/dsytd2.d.ts

@@ -0,0 +1 @@
+export declare function dsytd2(uplo: number, n: number, a: Float64Array, aOff: number, lda: number, d: Float64Array, dOff: number, e: Float64Array, eOff: number, tau: Float64Array, tauOff: number): number;

package/dist-browser/vfs/syncVfsChanges.d.ts

@@ -2,9 +2,9 @@
  * Syncs VFS changes from a worker execution back to IndexedDB.
  */
 import type { VfsChanges } from "./VirtualFileSystem.js";
-import type { WorkspaceFile } from "../hooks/useProjectFiles.js";
+import type { FileEntry } from "../hooks/projectFilesState.js";
 export interface VfsSyncResult {
-    addedFiles: WorkspaceFile[];
+    addedFiles: FileEntry[];
     modifiedFiles: {
         path: string;
         data: Uint8Array;