numbl 0.4.8 → 0.4.9

package/dist-browser/db/operations.d.ts

@@ -0,0 +1,25 @@
+import { type Project, type ProjectFile } from "./schema";
+export declare function createProject(name: string): Promise<void>;
+export declare function getProject(name: string): Promise<Project | undefined>;
+export declare function listProjects(): Promise<Project[]>;
+export declare function deleteProject(name: string): Promise<void>;
+export declare function renameProject(oldName: string, newName: string): Promise<void>;
+export declare function updateLastOpened(projectName: string): Promise<void>;
+export declare function getProjectFiles(projectName: string): Promise<ProjectFile[]>;
+export declare function getFile(fileId: string): Promise<ProjectFile | undefined>;
+export declare function getFileContent(fileId: string): Promise<Uint8Array>;
+export declare function getAllFileContents(projectName: string): Promise<Map<string, Uint8Array>>;
+export declare function saveFileData(fileId: string, data: Uint8Array): Promise<void>;
+export declare function createFile(projectName: string, path: string, data?: Uint8Array): Promise<ProjectFile>;
+export declare function deleteFile(fileId: string): Promise<void>;
+export declare function renameFile(fileId: string, newPath: string): Promise<void>;
+export declare function getProjectFileCount(projectName: string): Promise<number>;
+export declare function getProjectLastModified(projectName: string): Promise<number>;
+export declare const SYSTEM_PROJECT_NAME = "__system__";
+export declare function getSystemFiles(): Promise<ProjectFile[]>;
+export declare function getSystemFileContents(): Promise<Map<string, Uint8Array>>;
+export declare function ensureSystemProject(): Promise<void>;
+/** True if the mip core package is present in the system directory. */
+export declare function isMipCoreInstalled(): Promise<boolean>;
+/** Delete every file (and its content) under the system project. */
+export declare function clearSystemFiles(): Promise<void>;

package/dist-browser/db/schema.d.ts

@@ -0,0 +1,26 @@
+import Dexie, { type EntityTable } from "dexie";
+export interface Project {
+    name: string;
+    displayName?: string;
+    createdAt: number;
+    updatedAt: number;
+    lastOpenedAt: number;
+}
+export interface ProjectFile {
+    id: string;
+    projectName: string;
+    path: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FileContent {
+    id: string;
+    data: Uint8Array;
+}
+export declare class NumblDatabase extends Dexie {
+    projects: EntityTable<Project, "name">;
+    files: EntityTable<ProjectFile, "id">;
+    fileContents: EntityTable<FileContent, "id">;
+    constructor();
+}
+export declare const db: NumblDatabase;

package/dist-browser/graphics/axisLimits.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure computation of the current axis limits for an `AxesState`.
+ *
+ * This is the source of truth for the query form `lim = axis`: the numbl
+ * runtime reduces its accumulated plot instructions into an `AxesState` and
+ * asks this module for the limit vector. It is deliberately rendering-free
+ * (no canvas, no DOM) so numbl-core can import it.
+ *
+ * For an axis with an explicit limit, that limit is returned verbatim (a
+ * `null` bound falls back to the data-derived bound). For a fully automatic
+ * axis the data extent is computed across every trace type and padded the
+ * same way `drawPlot` pads a default 2-D view, so the reported limits track
+ * what is drawn.
+ */
+import type { AxesState } from "./figuresReducer.js";
+/** Does this axes hold any 3-D content (so limits are a 6-vector)? */
+export declare function axesIs3D(axes: AxesState): boolean;
+/**
+ * Compute the limit vector for `lim = axis`.
+ * Returns 4 elements `[xmin xmax ymin ymax]` for a 2-D view, or 6 elements
+ * `[xmin xmax ymin ymax zmin zmax]` when the axes holds 3-D content.
+ */
+export declare function computeAxisLimits(axes: AxesState): number[];

package/dist-browser/graphics/figuresReducer.d.ts

@@ -0,0 +1,86 @@
+import type { PlotTrace, Plot3Trace, PatchTrace, SurfTrace, ImagescTrace, PcolorTrace, ContourTrace, BarTrace, Bar3Trace, ErrorBarTrace, BoxTrace, PieTrace, HeatmapTrace, QuiverTrace, Quiver3Trace, PlotInstruction } from "./types.js";
+export type AxesState = {
+    holdOn: boolean;
+    traces: PlotTrace[];
+    plot3Traces: Plot3Trace[];
+    surfTraces: SurfTrace[];
+    imagescTrace?: ImagescTrace;
+    pcolorTraces: PcolorTrace[];
+    contourTraces: ContourTrace[];
+    barTraces: BarTrace[];
+    barhTraces: BarTrace[];
+    bar3Traces: Bar3Trace[];
+    bar3hTraces: Bar3Trace[];
+    errorBarTraces: ErrorBarTrace[];
+    boxTraces: BoxTrace[];
+    pieTrace?: PieTrace;
+    heatmapTrace?: HeatmapTrace;
+    quiverTraces: QuiverTrace[];
+    quiver3Traces: Quiver3Trace[];
+    areaTraces: PlotTrace[];
+    areaBaseValue: number;
+    patchTraces: PatchTrace[];
+    title?: string;
+    xlabel?: string;
+    ylabel?: string;
+    zlabel?: string;
+    shading?: "faceted" | "flat" | "interp";
+    legend?: string[];
+    gridOn?: boolean;
+    /** Axes border. Undefined/true → full rectangle (numbl's default, matching
+     *  MATLAB `box on`); false → only the left and bottom axis lines (`box off`). */
+    boxOn?: boolean;
+    colorbar?: boolean;
+    colorbarLocation?: string;
+    colormap?: string;
+    colormapData?: number[][];
+    view?: {
+        az: number;
+        el: number;
+    };
+    axisMode?: string;
+    axisScale?: "linear" | "semilogx" | "semilogy" | "loglog";
+    caxis?: [number, number];
+    /** Explicit axis limits from `axis([...])` / `xlim` / `ylim`. Each bound
+     *  may be `null`, meaning "use the data-derived bound" (partial limits). An
+     *  absent field means the whole axis is automatic. */
+    xlim?: [number | null, number | null];
+    ylim?: [number | null, number | null];
+    zlim?: [number | null, number | null];
+    /** y-axis direction: "reverse" is `axis ij` (origin at top-left). */
+    yDir?: "normal" | "reverse";
+    /** Axes lines/background visibility (`axis off` sets this false). */
+    axisVisible?: boolean;
+};
+export type FigureState = {
+    subplotGrid?: {
+        rows: number;
+        cols: number;
+    };
+    currentAxesIndex: number;
+    sgtitle?: string;
+    axes: {
+        [index: number]: AxesState;
+    };
+    /** When set, this figure is an HTML UI component (MATLAB `uihtml`): the
+     *  `html` string is rendered in an iframe instead of the axes/trace canvas.
+     *  Takes precedence over `axes`. `data` is the JSON-encoded `Data` property
+     *  (from `jsonencode`), pushed into the page's `htmlComponent`. */
+    uihtml?: {
+        id: string;
+        html: string;
+        data?: string;
+    };
+};
+export type FiguresState = {
+    currentHandle: number;
+    figs: {
+        [handle: number]: FigureState;
+    };
+};
+/** Actions accepted by the figures reducer: any PlotInstruction, plus "clear" for UI resets. */
+export type FiguresAction = PlotInstruction | {
+    type: "clear";
+};
+export declare const initialFiguresState: FiguresState;
+export declare const figuresReducer: (state: FiguresState, action: FiguresAction) => FiguresState;

package/dist-browser/graphics/types.d.ts

@@ -0,0 +1,423 @@
+/**
+ * Shared graphics types used by both numbl-core and the rendering layer.
+ *
+ * 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.
+ */
+export interface PlotTrace {
+    x: number[];
+    y: number[];
+    lineStyle?: string;
+    marker?: string;
+    color?: [number, number, number];
+    lineWidth?: number;
+    markerSize?: number;
+    markerEdgeColor?: [number, number, number];
+    markerFaceColor?: [number, number, number];
+    markerIndices?: number[];
+    /** Stable identity for a trace returned as a graphics handle (e.g. from
+     *  `line`). Lets `set(h,'XData',...)` / `update_trace` find and mutate this
+     *  exact trace in the renderer's accumulated state across `drawnow`. */
+    id?: number;
+}
+export interface Plot3Trace {
+    x: number[];
+    y: number[];
+    z: number[];
+    lineStyle?: string;
+    marker?: string;
+    color?: [number, number, number];
+    lineWidth?: number;
+    markerSize?: number;
+    markerEdgeColor?: [number, number, number];
+    markerFaceColor?: [number, number, number];
+    markerIndices?: number[];
+    /** See PlotTrace.id. */
+    id?: number;
+}
+/** A patch object: one or more colored polygons sharing a single set of
+ *  vertices. Mirrors MATLAB's Faces/Vertices model — `patch(X,Y,C)` and the
+ *  name-value forms are all canonicalized to this shape at parse time. */
+export interface PatchTrace {
+    /** Unique vertices: `vertices[k] = [x, y]` (2-D) or `[x, y, z]` (3-D). */
+    vertices: number[][];
+    /** Faces as 0-based vertex-index arrays — one polygon per face. */
+    faces: number[][];
+    /** Single RGB for all faces, a colormap keyword, or 'none'. */
+    faceColor?: [number, number, number] | "flat" | "interp" | "none";
+    /** Edge color (default black [0,0,0]). */
+    edgeColor?: [number, number, number] | "flat" | "interp" | "none";
+    /** Face transparency in [0,1]. */
+    faceAlpha?: number;
+    lineWidth?: number;
+    lineStyle?: string;
+    marker?: string;
+    markerFaceColor?: [number, number, number] | "flat" | "none";
+    /** Color data driving 'flat'/'interp': one entry per face (flat) or per
+     *  vertex (interp). Each entry is a scalar (mapped through the colormap) or
+     *  an RGB triplet. */
+    faceVertexCData?: (number | [number, number, number])[];
+    /** True when vertices carry a z-coordinate (3-D patch). */
+    is3D?: boolean;
+    /** See PlotTrace.id — lets `set(p,...)` live-update this patch. */
+    id?: number;
+}
+export interface SurfTrace {
+    /** X coordinates: flat array of length rows*cols (column-major) */
+    x: number[];
+    /** Y coordinates: flat array of length rows*cols (column-major) */
+    y: number[];
+    /** Z values: flat array of length rows*cols (column-major) */
+    z: number[];
+    /** Number of rows in the grid */
+    rows: number;
+    /** Number of columns in the grid */
+    cols: number;
+    /** Optional color data (same shape as Z) */
+    c?: number[];
+    edgeColor?: [number, number, number] | "none" | "flat" | "interp";
+    faceColor?: [number, number, number] | "flat" | "interp" | "none" | "texturemap";
+    faceAlpha?: number;
+}
+export interface ImagescTrace {
+    /** X limits [xmin, xmax] */
+    x: [number, number];
+    /** Y limits [ymin, ymax] */
+    y: [number, number];
+    /** Z data: flat array (column-major), rows × cols */
+    z: number[];
+    rows: number;
+    cols: number;
+}
+export interface PcolorTrace {
+    /** X coordinates: flat array of length rows*cols (column-major) */
+    x: number[];
+    /** Y coordinates: flat array of length rows*cols (column-major) */
+    y: number[];
+    /** Color values: flat array of length rows*cols (column-major) */
+    c: number[];
+    /** Number of rows in the grid */
+    rows: number;
+    /** Number of columns in the grid */
+    cols: number;
+    edgeColor?: [number, number, number] | "none";
+    faceAlpha?: number;
+}
+export interface ContourTrace {
+    /** X coordinates: flat array (column-major) */
+    x: number[];
+    /** Y coordinates: flat array (column-major) */
+    y: number[];
+    /** Z values: flat array (column-major) */
+    z: number[];
+    rows: number;
+    cols: number;
+    /** Number of contour levels (used only when `levels` is not given) */
+    nLevels: number;
+    /** Explicit contour levels (from `contour(...,V)` or `LevelList`). When
+     *  absent, levels are chosen automatically from the data range. */
+    levels?: number[];
+    /** Line width from a `'LineWidth'` name-value pair. */
+    lineWidth?: number;
+    /** Line style from a `'LineStyle'` name-value pair (e.g. '-', '--'). */
+    lineStyle?: string;
+    /** Line color: an RGB triple, or a colormap keyword like 'flat'. */
+    lineColor?: number[] | string;
+    /** Whether this is a filled contour (contourf) */
+    filled: boolean;
+}
+export interface BarTrace {
+    /** X positions for each bar */
+    x: number[];
+    /** Y values (bar heights) for each bar */
+    y: number[];
+    /** Relative bar width (0–1, default 0.8) */
+    width: number;
+    /** Bar color as RGB triple [0–1] */
+    color?: [number, number, number];
+}
+export interface Bar3Trace {
+    /** X positions for each bar (column index) */
+    x: number[];
+    /** Y positions for each bar (row index) */
+    y: number[];
+    /** Z values (bar heights) for each bar */
+    z: number[];
+    /** Number of rows in the grid */
+    rows: number;
+    /** Number of columns in the grid */
+    cols: number;
+    /** Relative bar width (0–1, default 0.8) */
+    width: number;
+    /** Bar color as RGB triple [0–1] */
+    color?: [number, number, number];
+}
+export interface ErrorBarTrace {
+    x: number[];
+    y: number[];
+    /** Error below each data point */
+    yNeg: number[];
+    /** Error above each data point */
+    yPos: number[];
+    /** Error left of each data point (horizontal error bars) */
+    xNeg?: number[];
+    /** Error right of each data point (horizontal error bars) */
+    xPos?: number[];
+    color?: [number, number, number];
+    lineStyle?: string;
+    marker?: string;
+    lineWidth?: number;
+}
+export interface BoxTrace {
+    /** X position for this box */
+    x: number;
+    /** Median value */
+    median: number;
+    /** Lower quartile (Q1, 25th percentile) */
+    q1: number;
+    /** Upper quartile (Q3, 75th percentile) */
+    q3: number;
+    /** Lower whisker end (min non-outlier) */
+    whiskerLow: number;
+    /** Upper whisker end (max non-outlier) */
+    whiskerHigh: number;
+    /** Outlier values */
+    outliers: number[];
+    /** Relative box width */
+    width: number;
+    /** Box color as RGB triple [0–1] */
+    color?: [number, number, number];
+}
+export interface PieTrace {
+    /** Slice values (absolute, not percentages) */
+    values: number[];
+    /** Optional slice names */
+    names?: string[];
+    /** Inner radius as fraction of outer radius (0 = pie, >0 = donut) */
+    innerRadius: number;
+    /** Per-slice colors as RGB triples [0–1] */
+    colors?: [number, number, number][];
+}
+export interface QuiverTrace {
+    /** Tail x-coordinates (flat array) */
+    x: number[];
+    /** Tail y-coordinates (flat array) */
+    y: number[];
+    /** x-component of each arrow (already scaled to data units) */
+    u: number[];
+    /** y-component of each arrow (already scaled to data units) */
+    v: number[];
+    /** Whether to draw arrowheads */
+    showArrowHead: boolean;
+    /** Arrow color as RGB triple [0–1] */
+    color?: [number, number, number];
+    lineStyle?: string;
+    lineWidth?: number;
+    marker?: string;
+    /** Whether the marker should be filled */
+    markerFilled?: boolean;
+}
+export interface Quiver3Trace {
+    /** Tail coordinates (flat arrays) */
+    x: number[];
+    y: number[];
+    z: number[];
+    /** Directional components, already scaled to data units */
+    u: number[];
+    v: number[];
+    w: number[];
+    /** Whether to draw arrowheads */
+    showArrowHead: boolean;
+    /** Arrow color as RGB triple [0–1] */
+    color?: [number, number, number];
+    lineStyle?: string;
+    lineWidth?: number;
+    marker?: string;
+    markerFilled?: boolean;
+    /** Whether auto-scaling was applied (for handle queries) */
+    autoScale?: boolean;
+    autoScaleFactor?: number;
+}
+export interface HeatmapTrace {
+    /** Cell values: flat array (column-major), rows × cols */
+    data: number[];
+    rows: number;
+    cols: number;
+    /** X-axis labels (one per column) */
+    xLabels?: string[];
+    /** Y-axis labels (one per row) */
+    yLabels?: string[];
+}
+/** A single axis's limit request from `axis([...])` / `axis auto`.
+ *  - A `[lo, hi]` pair, where either bound may be `null` to mean "keep the
+ *    automatically-chosen bound" (from `inf`/`-inf` in the limits vector).
+ *  - The string `"auto"` clears any explicit limit so the axis refits to its
+ *    data (from `axis auto` / `axis 'auto x'`). */
+export type AxisLimitSpec = [number | null, number | null] | "auto";
+export type PlotInstruction = {
+    type: "set_figure_handle";
+    handle: number;
+} | {
+    /** An HTML UI component (MATLAB `uihtml`): renders self-contained HTML
+     *  markup in an iframe, bypassing the axes/trace model. `html` is the
+     *  full HTMLSource string; `id` is a stable per-component key. `data`, when
+     *  present, is the `Data` property JSON-encoded (via `jsonencode`); the
+     *  renderer parses it and pushes it to the page's `htmlComponent` so the
+     *  `setup`/`"DataChanged"` bridge fires (MATLAB `h.Data` → JavaScript). */
+    type: "uihtml";
+    id: string;
+    html: string;
+    data?: string;
+} | {
+    type: "plot";
+    traces: PlotTrace[];
+} | {
+    type: "plot3";
+    traces: Plot3Trace[];
+} | {
+    type: "line";
+    traces: PlotTrace[];
+} | {
+    type: "line3";
+    traces: Plot3Trace[];
+} | {
+    type: "patch";
+    trace: PatchTrace;
+    newplot?: boolean;
+} | {
+    type: "update_trace";
+    id: number;
+    props: Record<string, unknown>;
+} | {
+    type: "surf";
+    trace: SurfTrace;
+} | {
+    type: "surface";
+    trace: SurfTrace;
+} | {
+    type: "imagesc";
+    trace: ImagescTrace;
+} | {
+    type: "pcolor";
+    trace: PcolorTrace;
+} | {
+    type: "contour";
+    trace: ContourTrace;
+} | {
+    type: "mesh";
+    trace: SurfTrace;
+} | {
+    type: "bar";
+    traces: BarTrace[];
+} | {
+    type: "barh";
+    traces: BarTrace[];
+} | {
+    type: "bar3";
+    trace: Bar3Trace;
+} | {
+    type: "bar3h";
+    trace: Bar3Trace;
+} | {
+    type: "errorbar";
+    traces: ErrorBarTrace[];
+} | {
+    type: "area";
+    traces: PlotTrace[];
+    baseValue: number;
+} | {
+    type: "boxchart";
+    traces: BoxTrace[];
+} | {
+    type: "piechart";
+    trace: PieTrace;
+} | {
+    type: "heatmap";
+    trace: HeatmapTrace;
+} | {
+    type: "quiver";
+    traces: QuiverTrace[];
+} | {
+    type: "quiver3";
+    trace: Quiver3Trace;
+} | {
+    type: "set_hold";
+    value: boolean;
+} | {
+    type: "set_title";
+    text: string;
+} | {
+    type: "set_xlabel";
+    text: string;
+} | {
+    type: "set_ylabel";
+    text: string;
+} | {
+    type: "set_zlabel";
+    text: string;
+} | {
+    type: "set_shading";
+    shading: "faceted" | "flat" | "interp";
+} | {
+    type: "close";
+} | {
+    type: "close_all";
+} | {
+    type: "clf";
+} | {
+    type: "cla";
+    reset: boolean;
+} | {
+    type: "set_subplot";
+    rows: number;
+    cols: number;
+    index: number;
+} | {
+    type: "set_legend";
+    labels: string[];
+} | {
+    type: "set_sgtitle";
+    text: string;
+} | {
+    type: "set_grid";
+    value: boolean;
+} | {
+    type: "set_box";
+    value: boolean;
+} | {
+    type: "set_colorbar";
+    value: string;
+    location?: string;
+} | {
+    type: "set_colormap";
+    name: string;
+    data?: number[][];
+} | {
+    type: "set_axis";
+    value: string;
+} | {
+    type: "set_axis_limits";
+    xlim?: AxisLimitSpec;
+    ylim?: AxisLimitSpec;
+    zlim?: AxisLimitSpec;
+} | {
+    type: "set_axis_ydir";
+    dir: "normal" | "reverse";
+} | {
+    type: "set_axis_visible";
+    value: boolean;
+} | {
+    type: "set_axis_scale";
+    value: "linear" | "semilogx" | "semilogy" | "loglog";
+} | {
+    type: "set_view";
+    az: number;
+    el: number;
+} | {
+    type: "set_caxis";
+    limits: [number, number];
+};

package/dist-browser/hooks/useProjectFiles.d.ts

@@ -0,0 +1,45 @@
+/** Metadata-only file reference (no content loaded). */
+export interface WorkspaceFile {
+    id: string;
+    name: string;
+}
+/** Decode file data as UTF-8 text. */
+export declare function fileText(data: Uint8Array): string;
+/** Check if data contains binary (non-text) content. */
+export declare function isBinaryData(data: Uint8Array): boolean;
+export interface UseProjectFilesResult {
+    files: WorkspaceFile[];
+    activeFileId: string;
+    loading: boolean;
+    setActiveFileId: (id: string) => void;
+    updateFileContent: (content: string) => void;
+    addFile: (folderPath?: string) => Promise<string>;
+    addFolder: (parentPath?: string) => Promise<string>;
+    deleteFile: (fileId: string) => void;
+    deleteFolder: (folderPath: string) => void;
+    renameFile: (fileId: string, newName: string) => void;
+    renameFolder: (oldPath: string, newName: string) => void;
+    moveFile: (fileId: string, targetFolder: string | null) => void;
+    duplicateFile: (fileId: string) => Promise<string>;
+    uploadFiles: (entries: {
+        path: string;
+        content: string;
+    }[], targetFolder?: string) => Promise<void>;
+    reload: () => Promise<void>;
+    /** Load content for a single file (cached). */
+    loadFileContent: (fileId: string) => Promise<Uint8Array>;
+    /** Load all file contents for this project. Returns map of id → data. */
+    loadAllContents: () => Promise<Map<string, Uint8Array>>;
+    /** Content cache — updated on edits and loads. */
+    contentCache: React.RefObject<Map<string, Uint8Array>>;
+    mergeVfsChanges: (result: {
+        addedFiles: WorkspaceFile[];
+        modifiedFiles: {
+            path: string;
+            data: Uint8Array;
+        }[];
+        deletedPaths: string[];
+    }) => void;
+}
+export declare function generateDuplicateName(files: WorkspaceFile[], sourcePath: string): string;
+export declare function useProjectFiles(projectName: string): UseProjectFilesResult;

package/dist-browser/numbl-core/diagnostics/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Aggregate compilation error — collects multiple errors from parsing/lowering
+ * across workspace files so that all errors can be reported at once.
+ */
+export declare class CompilationErrors extends Error {
+    errors: Error[];
+    constructor(errors: Error[]);
+}

package/dist-browser/numbl-core/diagnostics/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared error diagnostic utilities for extracting structured error info
+ * with source context (snippets). Used by both the CLI and the web worker.
+ */
+import { type CallFrame } from "../runtime/error.js";
+import type { WorkspaceFile } from "../workspace/index.js";
+interface DiagnosticInfo {
+    message: string;
+    errorType: "syntax" | "semantic" | "runtime" | "unknown";
+    file: string | null;
+    line: number | null;
+    snippet: string | null;
+    callStack?: CallFrame[] | null;
+}
+/** Look up source text for a given filename. */
+export declare function getSourceForFile(file: string, mainFileName: string, mainSource: string, wsFiles: WorkspaceFile[] | undefined): string | null;
+/**
+ * Extract structured diagnostic info from any error, returning an array.
+ * For CompilationErrors, returns one DiagnosticInfo per inner error.
+ * For all other errors, returns a single-element array.
+ */
+export declare function diagnoseErrors(error: unknown, mainSource: string, mainFileName: string, wsFiles?: WorkspaceFile[]): DiagnosticInfo[];
+/** Format multiple DiagnosticInfo as a human-readable string for console output. */
+export declare function formatDiagnostics(infos: DiagnosticInfo[], getSource?: (file: string) => string | null): string;
+/** Format a DiagnosticInfo as a human-readable string for console output. */
+export declare function formatDiagnostic(info: DiagnosticInfo, getSource?: (file: string) => string | null): string;
+export {};