import type { RunMatFilesystemProvider } from "./fs/provider-types.js";
import type { FeaCapabilities, FeaCheckResult, FeaFieldRequestOptions, FeaFieldResult, FeaRunResult, FeaStudyDocumentOperation, FeaStudyDocumentOperationOutput } from "./fea-contracts.js";
import { BrowserProjectResolver } from "./package-cache/browser-resolver.js";
import { BrowserProjectSession } from "./package-cache/project-session.js";
import type { BrowserProjectResolverConfig, BrowserProjectSessionConfig, IndexedDbPackageCacheOptions, PackageCacheSnapshot, PackageCacheGcPlan, PackageCacheStatus, RunMatPackageCacheProvider } from "./package-cache/index.js";
import type { GitAcquisitionPlan, GitAcquisitionPlanRequest, GitGatewayRequest, GitSnapshotWire, GitTreeInventoryWire, ServerGitGatewayOptions } from "./package-cache/git-gateway.js";
export { FEA_ANALYSIS_PROFILES, FEA_ANALYSIS_RUN_KINDS, FEA_ARTIFACT_MANIFEST_KIND, FEA_DATASET_ARTIFACT_KIND, FEA_DIAGNOSTICS_ARTIFACT_KIND, FEA_DIAGNOSTICS_SCHEMA_VERSION, FEA_FIELD_DEFAULT_MATERIALIZE_LIMIT, FEA_FIELD_DEFAULT_PAGE_SIZE, FEA_FIELD_DESCRIPTORS_ARTIFACT_KIND, FEA_FIELD_DESCRIPTORS_SCHEMA_VERSION, FEA_OBJECT_ARTIFACT_METADATA_SCHEMA_VERSION, FEA_RUN_DATASET_KIND, FEA_RUN_DATASET_SCHEMA_VERSION, FEA_RUN_CELL_ID, FEA_RUN_KIND, FEA_RUN_MANIFEST_METADATA_SCHEMA_VERSION, FEA_STUDY_DOCUMENT_OPERATIONS, FEA_SUPPORTED_PHYSICS_FAMILIES, FEA_SUPPORTED_PHYSICS_PROFILES, feaRunArtifactRefId, } from "./fea-contracts.js";
export type { FeaAnalysisProfile, FeaAnalysisRunKind, FeaCapabilities, FeaCheckResult, FeaDiagnosticsArtifactPayload, FeaDocumentKind, FeaFieldDescriptorsArtifactPayload, FeaFieldKind, FeaFieldDescriptor, FeaFieldLocation, FeaFieldPagingDescriptor, FeaFieldRequestOptions, FeaFieldResult, FeaFieldStorage, FeaFieldStorageRef, FeaObjectArtifactMetadata, FeaPhysicsProfileCatalogEntry, FeaProgressEvent, FeaProgressPhase, FeaProgressStatus, FeaRunDatasetFieldPagingPolicy, FeaRunDatasetPayload, FeaRunDatasetStudyRef, FeaRunResult, FeaStudyBoundaryConditionEntry, FeaStudyDocumentCounts, FeaStudyDocumentDiff, FeaStudyDocumentOperation, FeaStudyDocumentOperationOutput, FeaStudyDocumentOperationResult, FeaStudyDrivingConditionEntry, FeaStudyMaterialAssignmentEntry, FeaStudyMaterialEntry, FeaStudyOutputEntry, FeaStudyReadiness, FeaStudyRegionEntry, FeaStudyStepEntry, FeaStudySummary, FeaRunArtifactRole } from "./fea-contracts.js";
export { createInMemoryFsProvider, createIndexedDbFsHandle, createIndexedDbFsProvider, createDefaultFsProvider, createRemoteFsProvider, MemoryVolume } from "./fs/index.js";
export type { InMemoryFsProviderOptions, IndexedDbFsHandle, IndexedDbProviderOptions, RemoteProviderOptions, VolumeSnapshotEntry } from "./fs/index.js";
export type { RunMatFsFileType, RunMatFilesystemDirEntry, RunMatFilesystemMetadata, RunMatFilesystemProvider, RunMatOpenFileDialogFilter, RunMatOpenFileDialogRequest, RunMatOpenFileDialogSelection } from "./fs/provider-types.js";
export { BrowserPackageMountFilesystem, createAndRegisterBrowserRecipientKey, createBrowserPrivatePackageKeyStore, createIndexedDbPackageCache, generateBrowserRecipientKey, invalidateBrowserPrivatePackageArtifacts, ImmutableBrowserPackageMount, revokeAndRemoveBrowserRecipientKey } from "./package-cache/index.js";
export { BrowserProjectResolver, BrowserProjectSession };
export type { BrowserProjectResolveOptions, BrowserProjectResolveRequest, BrowserProjectResolverConfig, BrowserProjectResolverNative, BrowserResolvedProject, BrowserProjectSessionConfig, BrowserProjectSessionHandle, BrowserProjectSessionNative, BrowserProjectSessionResolution, BrowserProjectSessionResolveRequest, BrowserRecipientKeyRegistration, BrowserPrivatePackageKeyStore, GeneratedBrowserRecipientKey, RegisterBrowserRecipientKey, RevokeBrowserRecipientKey, BrowserMountEntry, BrowserTreeEntry, BrowserTreeManifest, IndexedDbPackageCacheHandle, IndexedDbPackageCacheOptions, PackageCacheCommitOutcome, PackageCacheGcPlan, PackageCacheFaultInjector, PackageCacheRevision, PackageCacheSnapshot, PackageCacheStatus, PackageCacheTransaction, RunMatPackageCacheProvider, GitGatewayRequest, GitGatewaySelector, GitAcquisitionIntent, GitAcquisitionPlan, GitAcquisitionPlanRequest, GitAcquisitionPolicy, GitSnapshotWire, GitSourceWire, GitTreeInventoryWire, ServerGitGatewayOptions } from "./package-cache/index.js";
export { createWorkspaceHoverProvider } from "./workspace-hover.js";
export type { WorkspaceHoverOptions, WorkspaceHoverController, HoverFormatState } from "./workspace-hover.js";
export { createFusionPlanAdapter } from "./fusion-plan.js";
export type { FusionPlanAdapter, FusionPlanAdapterOptions } from "./fusion-plan.js";
export type LanguageCompatMode = "runmat" | "matlab" | "strict";
type RunMatPresetLogLevel = "trace" | "debug" | "info" | "warn" | "error";
export type RunMatLogLevel = RunMatPresetLogLevel | (string & Record<never, never>);
export type RunmatConfigFormat = "toml" | "json";
export type DesktopRunHistoryMode = "off" | "budgeted" | "full";
export type DesktopRunLogMode = "off" | "errors" | "all";
export type DesktopNotebookOnError = "stop" | "continue";
export type DesktopNotebookRerunAfterCancel = "remaining" | "all";
export interface ResolvedDesktopConfig {
    artifacts: {
        root: string;
    };
    run_history: {
        mode: DesktopRunHistoryMode;
        trace: boolean;
        logs: DesktopRunLogMode;
    };
    script: {
        clear_workspace_before_run: boolean;
        clear_figures_before_run: boolean;
    };
    notebook: {
        on_error: DesktopNotebookOnError;
        rerun_after_cancel: DesktopNotebookRerunAfterCancel;
    };
}
export interface ResolvedRunmatConfig {
    desktop: ResolvedDesktopConfig;
    runtime: Record<string, unknown> & {
        error_namespace: string;
        language: Record<string, unknown> & {
            compat: LanguageCompatMode;
        };
        accelerate: Record<string, unknown> & {
            enabled: boolean;
        };
        plotting: Record<string, unknown> & {
            export?: Record<string, unknown> & {
                scene_budget_bytes: number;
            };
        };
    };
}
export interface RunmatConfigPatch {
    desktop?: {
        artifacts?: {
            root?: string;
        };
        run_history?: {
            mode?: DesktopRunHistoryMode;
            trace?: boolean;
            logs?: DesktopRunLogMode;
        };
        script?: {
            clear_workspace_before_run?: boolean;
            clear_figures_before_run?: boolean;
        };
        notebook?: {
            on_error?: DesktopNotebookOnError;
            rerun_after_cancel?: DesktopNotebookRerunAfterCancel;
        };
    };
    runtime?: {
        accelerate_enabled?: boolean;
        scene_budget_bytes?: number;
    };
}
export interface LegacyRunmatConfigMigration {
    source: string;
    changed: boolean;
    removedKeys: string[];
}
export type WasmInitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
export interface RunMatInitOptions {
    enableGpu?: boolean;
    enableJit?: boolean;
    verbose?: boolean;
    logLevel?: RunMatLogLevel;
    gpuBufferPoolMaxPerKey?: number;
    telemetryConsent?: boolean;
    telemetryId?: string;
    telemetryRunKind?: "script" | "repl" | "benchmark" | "install";
    telemetryEmitter?: (envelope: unknown) => void;
    wgpuPowerPreference?: "auto" | "high-performance" | "low-power";
    wgpuForceFallbackAdapter?: boolean;
    wasmModule?: WasmInitInput;
    fsProvider?: RunMatFilesystemProvider;
    packageCache?: IndexedDbPackageCacheOptions & {
        provider?: RunMatPackageCacheProvider;
    };
    executionHost?: RunMatExecutionHost;
    plotCanvas?: HTMLCanvasElement;
    scatterTargetPoints?: number;
    surfaceVertexBudget?: number;
    emitFusionPlan?: boolean;
    callstackLimit?: number;
    errorNamespace?: string;
    language?: {
        compat?: LanguageCompatMode;
    };
}
export type BrowserExecutionTopology = "coordinator" | "flat" | "serial";
export interface BrowserExecutionHostCapabilities {
    topology: BrowserExecutionTopology;
    maxWorkers: number;
}
export interface BrowserProgramLaunchRequest {
    taskId: string;
    workerId: string;
    program: Record<string, unknown>;
}
export interface RunMatExecutionHost {
    capabilities: BrowserExecutionHostCapabilities;
    launch(request: BrowserProgramLaunchRequest): Promise<Record<string, unknown>>;
    cancel(taskId: string): void;
}
export type FigureEventKind = "created" | "updated" | "cleared" | "closed";
export interface FigureEvent {
    handle: number;
    kind: FigureEventKind;
    fingerprint?: string;
    figure?: FigureSnapshot;
}
export interface FigureSnapshot {
    layout: FigureLayout;
    metadata: FigureMetadata;
    plots: FigurePlotDescriptor[];
}
export interface FigureTextStyle {
    colorRgba?: [number, number, number, number];
    fontSize?: number;
    fontWeight?: string;
    fontAngle?: string;
    interpreter?: string;
    visible: boolean;
}
export interface FigureLayout {
    axesRows: number;
    axesCols: number;
    axesIndices: number[];
}
export interface FigureMetadata {
    title?: string;
    sgTitle?: string;
    sgTitleStyle?: FigureTextStyle;
    xLabel?: string;
    yLabel?: string;
    gridEnabled: boolean;
    legendEnabled: boolean;
    colorbarEnabled: boolean;
    axisEqual: boolean;
    backgroundRgba: [number, number, number, number];
    colormap?: string;
    colorLimits?: [number, number];
    legendEntries: FigureLegendEntry[];
}
export interface FigureLegendEntry {
    label: string;
    plotType: FigurePlotKind;
    colorRgba: [number, number, number, number];
}
export interface FigurePlotDescriptor {
    kind: FigurePlotKind;
    label?: string;
    axesIndex: number;
    colorRgba: [number, number, number, number];
    visible: boolean;
}
export type FigurePlotKind = "line" | "line3" | "scatter" | "bar" | "error_bar" | "stairs" | "stem" | "area" | "quiver" | "pie" | "surface" | "mesh" | "scatter3" | "contour" | "contour_fill";
export type FigureEventListener = (event: FigureEvent) => void;
export type HoldMode = "on" | "off" | "toggle" | boolean;
export type PlotSurfaceEvent = {
    kind: "mouseDown";
    x: number;
    y: number;
    button: number;
    shiftKey?: boolean;
    ctrlKey?: boolean;
    altKey?: boolean;
    metaKey?: boolean;
} | {
    kind: "mouseUp";
    x: number;
    y: number;
    button: number;
    shiftKey?: boolean;
    ctrlKey?: boolean;
    altKey?: boolean;
    metaKey?: boolean;
} | {
    kind: "mouseMove";
    x: number;
    y: number;
    dx: number;
    dy: number;
    shiftKey?: boolean;
    ctrlKey?: boolean;
    altKey?: boolean;
    metaKey?: boolean;
} | {
    kind: "wheel";
    x: number;
    y: number;
    wheelDeltaX: number;
    wheelDeltaY: number;
    wheelDeltaMode?: number;
    shiftKey?: boolean;
    ctrlKey?: boolean;
    altKey?: boolean;
    metaKey?: boolean;
};
export type PlotSurfaceHostAction = {
    kind: "createFeaStudy";
};
export type StdoutStreamKind = "stdout" | "stderr" | "clear";
export interface StdoutEntry {
    stream: StdoutStreamKind;
    text: string;
    timestampMs: number;
}
export type StdoutListener = (entry: StdoutEntry) => void;
export interface RuntimeLogEntry {
    ts: string;
    level: string;
    target: string;
    message: string;
    traceId?: string;
    spanId?: string;
    fields?: Record<string, unknown>;
}
export type RuntimeLogListener = (entry: RuntimeLogEntry) => void;
export interface TraceEvent {
    name: string;
    cat: string;
    ph: string;
    ts: number;
    dur?: number;
    pid?: number;
    tid?: number;
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    args?: Record<string, unknown>;
}
export type TraceEventListener = (entries: TraceEvent[]) => void;
export type SignalTraceHandler = <T>(traceId: string, name: string, fn: () => T) => T;
export declare function setSignalTraceHandler(handler: SignalTraceHandler | null): void;
export declare function withSignalTrace<T>(traceId: string | undefined, name: string, fn: () => T): T;
export type InputRequest = {
    kind: "line";
    prompt: string;
    echo: boolean;
} | {
    kind: "keyPress";
    prompt: string;
    echo: boolean;
};
export interface ResumeInputPayload {
    value?: string | number | boolean;
    line?: string | number | boolean;
    kind?: "line" | "keyPress";
    error?: string;
}
export type ResumeInputScalar = string | number | boolean | null | undefined;
export type ResumeInputValue = ResumeInputScalar | ResumeInputPayload;
export type InputHandlerResult = ResumeInputValue | Promise<ResumeInputValue>;
export type InputHandler = (request: InputRequest) => InputHandlerResult;
export interface AxesInfo {
    handle: number;
    axesRows: number;
    axesCols: number;
    activeIndex: number;
}
export interface FigureImageOptions {
    handle?: number;
    width?: number;
    height?: number;
    cameraState?: FigureImageCameraState;
    textmark?: string;
}
export interface GeometrySceneImageOptions {
    handle: number;
    width?: number;
    height?: number;
    view?: string | null;
    visibility?: GeometrySceneImageVisibilityState | null;
    section?: GeometrySceneImageSectionState | null;
}
export interface GeometrySceneImageVisibilityState {
    mode: "all" | "hidden" | "isolated" | string;
    hidden_ids?: string[];
    isolated_ids?: string[];
}
export interface GeometrySceneImageSectionState {
    plane: GeometrySceneImageSectionPlane;
}
export interface GeometrySceneImageSectionPlane {
    normal: [number, number, number];
    origin?: [number, number, number] | null;
    offset?: number | null;
    label?: string | null;
}
export type FigureImageCameraProjectionState = {
    kind: "perspective";
    fov: number;
    near: number;
    far: number;
} | {
    kind: "orthographic";
    left: number;
    right: number;
    bottom: number;
    top: number;
    near: number;
    far: number;
};
export interface FigureImageAxesCameraState {
    position: [number, number, number];
    target: [number, number, number];
    up: [number, number, number];
    zoom: number;
    aspectRatio: number;
    projection: FigureImageCameraProjectionState;
}
export interface FigureImageCameraState {
    activeAxes: number;
    axes: FigureImageAxesCameraState[];
}
export interface FigureBindingError extends Error {
    code: "InvalidHandle" | "InvalidSubplotGrid" | "InvalidSubplotIndex" | "RenderFailure" | "Unknown";
    handle?: number;
    rows?: number;
    cols?: number;
    index?: number;
    details?: string;
}
export interface MatlabWarning {
    identifier: string;
    message: string;
}
export interface StdinEventLog {
    prompt: string;
    kind: "line" | "keyPress";
    echo: boolean;
    value?: string;
    error?: string;
}
export type RuntimeFlow = {
    kind: "no-value";
} | {
    kind: "single";
    value: unknown;
} | {
    kind: "output-list";
    values: unknown[];
} | {
    kind: "comma-list";
    values: unknown[];
} | {
    kind: "dynamic-list";
    id: string;
};
export interface ExecuteRequestTextSource {
    kind: "text";
    name: string;
    text: string;
}
export interface ExecuteRequestPathSource {
    kind: "path";
    path: string;
}
export type ExecuteRequestSource = ExecuteRequestTextSource | ExecuteRequestPathSource;
export interface ExecuteRequest {
    source: ExecuteRequestSource;
    compatibility?: LanguageCompatMode;
    hostPolicy?: {
        topLevelAwait?: boolean;
    };
    requestedOutputs?: number;
    retainFigures?: boolean;
}
export interface ExecuteResult {
    flow: RuntimeFlow;
    displayEvents: DisplayEvent[];
    valueText?: string;
    valueJson?: unknown;
    typeInfo?: string;
    error?: RunMatErrorDetails;
    executionTimeMs: number;
    usedJit: boolean;
    stdout: StdoutEntry[];
    workspace: WorkspaceSnapshot;
    figuresTouched: number[];
    warnings: MatlabWarning[];
    stdinEvents: StdinEventLog[];
    profiling?: ProfilingSummary;
    fusionPlan?: FusionPlanSnapshot;
}
export interface DisplayEvent {
    label: string;
    valueText: string;
    valueJson: unknown;
    span: {
        start: number;
        end: number;
    };
}
export type RunMatErrorKind = "syntax" | "semantic" | "compile" | "runtime";
export interface RunMatErrorSpan {
    start: number;
    end: number;
    line: number;
    column: number;
}
export interface RunMatErrorDetails {
    kind: RunMatErrorKind;
    message: string;
    identifier?: string;
    diagnostic: string;
    span?: RunMatErrorSpan;
    callstack: string[];
    callstackElided?: number;
}
export declare class RunMatExecutionError extends Error {
    readonly kind: RunMatErrorKind;
    readonly identifier?: string;
    readonly diagnostic: string;
    readonly span?: RunMatErrorSpan;
    readonly callstack: string[];
    readonly callstackElided?: number;
    constructor(details: RunMatErrorDetails);
}
export type WorkspaceResidency = "cpu" | "gpu" | "unknown";
export interface WorkspaceSnapshot {
    full: boolean;
    version: number;
    values: WorkspaceEntry[];
    removals?: string[];
}
export interface WorkspaceEntry {
    name: string;
    className: string;
    dtype?: string;
    shape: number[];
    isGpu: boolean;
    sizeBytes?: number;
    preview?: WorkspacePreview;
    residency: WorkspaceResidency;
    previewToken?: string;
}
export interface WorkspacePreview {
    values: number[];
    truncated: boolean;
}
export type WorkspaceMaterializeSelector = string | {
    name?: string;
    previewToken?: string;
};
export interface MaterializeSliceOptions {
    start: number[];
    shape: number[];
}
export interface MaterializeVariableOptions {
    limit?: number;
    slice?: MaterializeSliceOptions;
}
export interface MaterializedVariable {
    name: string;
    className: string;
    dtype?: string;
    shape: number[];
    isGpu: boolean;
    residency: WorkspaceResidency;
    sizeBytes?: number;
    preview?: WorkspacePreview;
    valueText: string;
    valueJson: unknown;
}
export interface ProfilingSummary {
    totalMs: number;
    cpuMs?: number;
    gpuMs?: number;
    kernelCount?: number;
}
export interface FusionPlanSnapshot {
    nodes: FusionPlanNode[];
    edges: FusionPlanEdge[];
    shaders: FusionPlanShader[];
    decisions: FusionPlanDecision[];
}
export interface FusionPlanNode {
    id: string;
    kind: string;
    label: string;
    shape: number[];
    residency?: string;
}
export interface FusionPlanEdge {
    from: string;
    to: string;
    reason?: string;
}
export interface FusionPlanShader {
    name: string;
    stage: string;
    workgroupSize?: [number, number, number];
    sourceHash?: string;
}
export interface FusionPlanDecision {
    nodeId: string;
    fused: boolean;
    reason?: string;
    thresholds?: string;
}
export interface SessionStats {
    totalExecutions: number;
    jitCompiled: number;
    interpreterFallback: number;
    totalExecutionTimeMs: number;
    averageExecutionTimeMs: number;
}
export interface GpuStatus {
    requested: boolean;
    active: boolean;
    error?: string;
    adapter?: GpuAdapterInfo;
}
export interface GpuAdapterInfo {
    deviceId: number;
    name: string;
    vendor: string;
    backend?: string;
    memoryBytes?: number;
    precision?: "single" | "double";
}
export interface MemoryUsage {
    bytes: number;
    pages: number;
}
export interface GeometryPreviewBudget {
    maxBytes?: number;
    maxTriangles?: number;
    maxVertices?: number;
    timeoutMs?: number;
    budgetPolicy?: "truncate" | "strict";
    tessellationProfile?: GeometryPreviewTessellationProfile;
    xray?: boolean;
    allowCreateFeaStudy?: boolean;
}
export interface GeometryPreviewTessellationProfile {
    profileId?: string;
    chordTolerance?: number;
    angleToleranceDeg?: number;
}
export interface GeometryStats {
    meshCount: number;
    totalVertices: number;
    totalElements: number;
    regionCount: number;
}
export interface GeometryBoundsSummary {
    min: [number, number, number];
    max: [number, number, number];
}
export interface GeometryMeshSummary {
    meshId: string;
    kind: string;
    vertexCount: number;
    elementCount: number;
    surfaceVertexCount?: number | null;
    surfaceTriangleCount?: number | null;
    bounds?: GeometryBoundsSummary | null;
}
export interface GeometryRegionMappingSummaryEntry {
    regionId: string;
    meshId: string;
    entityKind: string;
    rangeCount: number;
    entityCount: number;
    rangePreview: {
        start: number;
        count: number;
    }[];
    truncated: boolean;
}
export interface GeometryRegionMappingSummary {
    mappingCount: number;
    mappedRegionCount: number;
    totalEntityCount: number;
    rangePreviewLimit: number;
    entries: GeometryRegionMappingSummaryEntry[];
}
export interface GeometryCadSummary {
    backend?: string | null;
    sourceFormat?: string | null;
    faceRegionCount: number;
    mappedFaceRegionCount: number;
    semanticRegionCount: number;
    mappedSemanticRegionCount: number;
    regionStatus: "not_cad" | "metadata_only" | "generic_face_topology" | "semantic_regions";
}
export interface GeometrySourceSummary {
    path: string;
    sha256: string;
    importer_version: string;
}
export interface GeometryAssemblyNodeSummary {
    node_id: string;
    label: string;
    children: GeometryAssemblyNodeSummary[];
}
export interface GeometryMaterialEvidenceSummary {
    source_key: string;
    normalized_key: string;
    value: string;
    confidence: "high" | "medium" | "low";
    unit_basis?: string | null;
    assumptions: string[];
}
export interface GeometrySourceGeometrySummary {
    kind: "mesh" | "cad";
    assembly?: GeometryAssemblyNodeSummary | null;
    material_evidence: GeometryMaterialEvidenceSummary[];
}
export interface GeometryTessellationProfileSummary {
    profile_id: string;
    chord_tolerance?: number | null;
    angle_tolerance_deg?: number | null;
    healing_mode: "safe" | "off" | "aggressive";
}
export interface GeometryAssetSummary {
    geometryId: string;
    revision: number;
    source: GeometrySourceSummary;
    sourceGeometry: GeometrySourceGeometrySummary;
    tessellationProfile: GeometryTessellationProfileSummary;
    units: string;
    meshes: GeometryMeshSummary[];
    mappingSummary: GeometryRegionMappingSummary;
    cad: GeometryCadSummary;
}
export interface GeometryInspectResult {
    path: string;
    format: string;
    byteCount: number;
    supported: boolean;
    stats?: GeometryStats | null;
    geometrySummary?: GeometryAssetSummary | null;
    regions?: unknown[];
    diagnostics?: unknown[];
    degradedReason?: string | null;
}
export interface GeometryPreviewResult extends GeometryInspectResult {
    sceneKind: "mesh" | "summary" | "unavailable";
    figureHandle: number | null;
    geometrySceneHandle: number | null;
    truncated: boolean;
    previewMessage?: string | null;
}
export interface RunMatSessionHandle {
    executeRequest(request: ExecuteRequest): Promise<ExecuteResult>;
    resetSession(): Promise<void>;
    stats(): Promise<SessionStats>;
    clearWorkspace(): void;
    exportWorkspaceState(options?: {
        includeVariables?: "off" | "auto" | "force";
    }): Promise<Uint8Array | null>;
    importWorkspaceState(state: Uint8Array): Promise<boolean>;
    workspaceSnapshot(): Promise<WorkspaceSnapshot>;
    inspectDataFile(path: string): Promise<WorkspaceEntry[]>;
    previewGeometry(path: string, budget?: GeometryPreviewBudget | null): Promise<GeometryPreviewResult>;
    disposeGeometryPreview?(figureHandle?: number | null, geometrySceneHandle?: number | null): Promise<void> | void;
    feaCapabilities(): Promise<FeaCapabilities>;
    checkFeaStudy(path: string): Promise<FeaCheckResult>;
    applyFeaStudyDocumentOperation(operation: FeaStudyDocumentOperation, path: string, source: string | null, input: Record<string, unknown>): Promise<FeaStudyDocumentOperationOutput>;
    runFeaStudy(path: string, artifactRoot?: string | null): Promise<FeaRunResult>;
    feaField(runId: string, fieldId: string, options?: FeaFieldRequestOptions): Promise<FeaFieldResult>;
    materializeDataFileVariable(path: string, selector: WorkspaceMaterializeSelector, options?: MaterializeVariableOptions): Promise<MaterializedVariable>;
    exportFigureScene?(handle: number): Promise<Uint8Array | null>;
    exportGeometryScene?(handle: number): Promise<Uint8Array | null>;
    importFigureScene?(scene: Uint8Array): Promise<number | null>;
    importGeometryScene?(scene: Uint8Array): Promise<number | null>;
    importFigureSceneFromPath?(path: string): Promise<number | null>;
    currentFigureHandle?(): Promise<number>;
    dispose(): void;
    telemetryConsent(): boolean;
    memoryUsage(): Promise<MemoryUsage>;
    telemetryClientId(): string | undefined;
    gpuStatus(): GpuStatus;
    cancelExecution(): void;
    setInputHandler(handler: InputHandler | null): Promise<void>;
    materializeVariable(selector: WorkspaceMaterializeSelector, options?: MaterializeVariableOptions): Promise<MaterializedVariable>;
    setFusionPlanEnabled(enabled: boolean): void;
    setLanguageCompat(mode: LanguageCompatMode): void;
    setErrorNamespace(namespace: string): void;
    fusionPlanForSource?(source: string): Promise<FusionPlanSnapshot | null>;
    setFsProvider?(provider: RunMatFilesystemProvider): Promise<void>;
    packageCacheSnapshot(): Promise<PackageCacheSnapshot | null>;
    installProjectHandoff(handoff: unknown): Promise<unknown>;
    clearProjectHandoff(): Promise<void>;
    projectRevision(): Promise<unknown | null>;
    prepareTests(snapshot: Record<string, unknown>, selector: Record<string, unknown>): Promise<{
        snapshot: Record<string, unknown>;
        discovery: Record<string, unknown>;
        plan: Record<string, unknown>;
    }>;
    executeTestAttempt(input: {
        plan: Record<string, unknown>;
        snapshot: Record<string, unknown>;
        testId: string;
        attempt: number;
    }): Promise<{
        result: unknown;
        events: unknown[];
        coverage?: unknown[];
    }>;
}
interface NativeInitOptions {
    enableGpu?: boolean;
    enableJit?: boolean;
    verbose?: boolean;
    logLevel?: RunMatLogLevel;
    gpuBufferPoolMaxPerKey?: number;
    telemetryConsent?: boolean;
    telemetryId?: string;
    telemetryRunKind?: string;
    telemetryEmitter?: (envelope: unknown) => void;
    wgpuPowerPreference?: string;
    wgpuForceFallbackAdapter?: boolean;
    scatterTargetPoints?: number;
    surfaceVertexBudget?: number;
    emitFusionPlan?: boolean;
    callstackLimit?: number;
    errorNamespace?: string;
    languageCompat?: LanguageCompatMode;
    fsProvider?: RunMatFilesystemProvider;
    packageCacheProvider?: RunMatPackageCacheProvider;
    executionHost?: RunMatExecutionHost;
}
interface RunMatNativeSession {
    executeRequest(request: ExecuteRequest): Promise<ExecuteResult>;
    resetSession(): void;
    stats(): SessionStats;
    clearWorkspace(): void;
    exportWorkspaceState?: (includeVariables?: string) => Promise<Uint8Array | null>;
    importWorkspaceState?: (state: Uint8Array) => boolean;
    workspaceSnapshot?: () => WorkspaceSnapshot;
    inspectDataFile?: (path: string) => WorkspaceEntry[] | Promise<WorkspaceEntry[]>;
    previewGeometry?: (path: string, budget?: GeometryPreviewBudget | null) => GeometryPreviewResult | Promise<GeometryPreviewResult>;
    disposeGeometryPreview?: (figureHandle?: number | null, geometrySceneHandle?: number | null) => void | Promise<void>;
    feaCapabilities?: () => FeaCapabilities | Promise<FeaCapabilities>;
    checkFeaStudy?: (path: string) => FeaCheckResult | Promise<FeaCheckResult>;
    applyFeaStudyDocumentOperation?: (operation: FeaStudyDocumentOperation, path: string, source: string | null, input: Record<string, unknown>) => FeaStudyDocumentOperationOutput | Promise<FeaStudyDocumentOperationOutput>;
    runFeaStudy?: (path: string, artifactRoot?: string | null) => FeaRunResult | Promise<FeaRunResult>;
    feaField?: (runId: string, fieldId: string, options?: FeaFieldRequestOptions) => FeaFieldResult | Promise<FeaFieldResult>;
    materializeDataFileVariable?: (path: string, array: string, options?: MaterializeVariableOptionsWire) => MaterializedVariable | Promise<MaterializedVariable>;
    exportFigureScene?: (handle: number) => Uint8Array | null | Promise<Uint8Array | null>;
    exportGeometryScene?: (handle: number) => Uint8Array | null;
    importFigureScene?: (scene: Uint8Array) => number | null | Promise<number | null>;
    importGeometryScene?: (scene: Uint8Array) => number | null | Promise<number | null>;
    importFigureSceneFromPath?: (path: string) => number | null | Promise<number | null>;
    currentFigureHandle?: () => number;
    dispose?: () => void;
    telemetryConsent(): boolean;
    memoryUsage?: () => MemoryUsage;
    telemetryClientId?: () => string | undefined;
    gpuStatus(): GpuStatus;
    cancelExecution?: () => void;
    setInputHandler?: (handler: InputHandler | null) => void;
    materializeVariable?: (selector: WorkspaceMaterializeSelectorWire, options?: MaterializeVariableOptionsWire) => MaterializedVariable;
    setFusionPlanEnabled?: (enabled: boolean) => void;
    setLanguageCompat?: (mode: LanguageCompatMode) => void;
    setErrorNamespace?: (namespace: string) => void;
    fusionPlanForSource?: (source: string) => FusionPlanSnapshot | null;
    setFsProvider?: (provider: RunMatFilesystemProvider) => void;
    packageCacheSnapshot?: () => Promise<PackageCacheSnapshot | null>;
    installProjectHandoff?: (handoff: unknown) => unknown;
    clearProjectHandoff?: () => void;
    projectRevision?: () => unknown | null;
    prepareTests?: (snapshot: Record<string, unknown>, selector: Record<string, unknown>) => {
        snapshot: Record<string, unknown>;
        discovery: Record<string, unknown>;
        plan: Record<string, unknown>;
    };
    executeTestAttempt?: (input: {
        plan: Record<string, unknown>;
        snapshot: Record<string, unknown>;
        testId: string;
        attempt: number;
    }) => Promise<{
        result: unknown;
        events: unknown[];
        coverage?: unknown[];
    }>;
}
type WorkspaceMaterializeSelectorWire = string | {
    name?: string;
    token?: string;
    previewToken?: string;
};
interface MaterializeVariableOptionsWire {
    limit?: number;
    slice?: {
        start: number[];
        shape: number[];
    };
}
export type PlotCameraProjectionState = {
    kind: "perspective";
    fov: number;
    near: number;
    far: number;
} | {
    kind: "orthographic";
    left: number;
    right: number;
    bottom: number;
    top: number;
    near: number;
    far: number;
};
export interface PlotCameraState {
    position: [number, number, number];
    target: [number, number, number];
    up: [number, number, number];
    zoom: number;
    aspectRatio: number;
    projection: PlotCameraProjectionState;
}
export interface PlotSurfaceCameraState {
    activeAxes: number;
    axes: PlotCameraState[];
}
export type GeometrySceneDisplayMode = "shaded" | "edges" | "wireframe";
export type GeometrySceneViewPreset = "perspective" | "isometric" | "front" | "back" | "left" | "right" | "top" | "bottom";
export interface GeometrySceneRegionHighlightState {
    regionId: string;
    color?: [number, number, number, number] | null;
    role?: string | null;
    label?: string | null;
}
export interface GeometrySceneRegionAnnotationState {
    regionId: string;
    color?: [number, number, number, number] | null;
    role?: string | null;
    label?: string | null;
    direction?: [number, number, number] | null;
    size?: number | null;
}
export interface GeometryScenePresentationState {
    selectedRegionId?: string | null;
    selectedRegionIds?: string[] | null;
    hoveredRegionId?: string | null;
    regionHighlights?: GeometrySceneRegionHighlightState[];
    regionAnnotations?: GeometrySceneRegionAnnotationState[];
    displayMode?: GeometrySceneDisplayMode;
    edgeOverlayEnabled?: boolean;
    hiddenOwnerNodeIds?: string[] | null;
    isolatedOwnerNodeIds?: string[] | null;
    section?: GeometrySceneImageSectionState | null;
    viewPreset?: GeometrySceneViewPreset | null;
}
export interface GeometryScenePickResult {
    meshId: string | null;
    chunkId: string;
    triangleIndex: number;
    regionId: string | null;
    regionLabel: string | null;
    regionTag: string | null;
    distance: number;
    position: [number, number, number];
}
interface RunMatNativeModule {
    default: (module?: {
        module_or_path: WasmInitInput | Promise<WasmInitInput>;
    } | WasmInitInput | Promise<WasmInitInput>) => Promise<unknown>;
    initRunMat(options: NativeInitOptions): Promise<RunMatNativeSession>;
    executeProgramArtifact?: (request: Record<string, unknown>) => Promise<Record<string, unknown>>;
    buildGitSnapshot?: (repository: string, subdir: string, inventory: GitTreeInventoryWire) => GitSnapshotWire;
    planGitAcquisition?: (request: GitAcquisitionPlanRequest) => GitAcquisitionPlan;
    validateGitSnapshot?: (snapshot: GitSnapshotWire) => GitSnapshotWire;
    projectTestLayout?: (input: unknown) => unknown;
    freezeTestSnapshot?: (input: unknown) => Record<string, unknown>;
    runTests?: (input: unknown, backend: unknown) => Promise<unknown>;
    runTestsWithEvents?: (input: unknown, backend: unknown, observer: (event: Record<string, unknown>) => void) => Promise<unknown>;
    resolveRunmatConfig?: (source: string, format: RunmatConfigFormat) => ResolvedRunmatConfig;
    patchRunmatConfig?: (source: string, format: RunmatConfigFormat, patch: RunmatConfigPatch) => string;
    migrateLegacyRunmatConfig?: (source: string, format: RunmatConfigFormat) => LegacyRunmatConfigMigration;
    migrateLegacyRunmatConfigInto?: (legacySource: string, destinationSource: string, format: RunmatConfigFormat) => LegacyRunmatConfigMigration;
    decodePackageLock?: (input: string) => unknown;
    encodePackageLock?: (value: unknown) => string;
    handoffFromFrozenProject?: (project: unknown) => unknown;
    resolveProject?: BrowserProjectResolverConfig["native"]["resolveProject"];
    packageCacheStatus?: (provider: RunMatPackageCacheProvider) => Promise<PackageCacheStatus>;
    packageCacheGc?: (provider: RunMatPackageCacheProvider, targetBytes: bigint, retainRecentMs: bigint) => Promise<PackageCacheGcPlan>;
    packageCacheRenewLease?: BrowserProjectResolverConfig["native"]["packageCacheRenewLease"];
    packageCacheReleaseLease?: BrowserProjectResolverConfig["native"]["packageCacheReleaseLease"];
    plotRendererReady?: () => boolean;
    renderCurrentFigureScene?: (handle: number) => void;
    exportFigureScene?: (handle: number) => Uint8Array | null | Promise<Uint8Array | null>;
    exportGeometryScene?: (handle: number) => Uint8Array | null;
    importFigureScene?: (scene: Uint8Array) => number | null | Promise<number | null>;
    importGeometryScene?: (scene: Uint8Array) => number | null | Promise<number | null>;
    importFigureSceneFromPath?: (path: string) => number | null | Promise<number | null>;
    exportWorkspaceState?: (includeVariables?: string) => Promise<Uint8Array | null>;
    importWorkspaceState?: (state: Uint8Array) => boolean;
    workspaceSnapshot?: () => WorkspaceSnapshot;
    createPlotSurface?: (canvas: HTMLCanvasElement | OffscreenCanvas) => Promise<number>;
    destroyPlotSurface?: (surfaceId: number) => void;
    resizePlotSurface?: (surfaceId: number, width: number, height: number, pixelsPerPoint?: number) => void;
    bindSurfaceToFigure?: (surfaceId: number, handle: number) => void;
    presentSurface?: (surfaceId: number) => void;
    presentFigureOnSurface?: (surfaceId: number, handle: number) => void;
    presentGeometrySceneOnSurface?: (surfaceId: number, handle: number) => void;
    setGeometryScenePresentation?: (surfaceId: number, presentation: GeometryScenePresentationState) => void;
    pickGeometrySceneRegion?: (surfaceId: number, x: number, y: number) => GeometryScenePickResult | null;
    handlePlotSurfaceEvent?: (surfaceId: number, event: PlotSurfaceEvent) => void;
    takePlotSurfaceHostActions?: (surfaceId: number) => unknown;
    fitPlotSurfaceExtents?: (surfaceId: number) => void;
    resetPlotSurfaceCamera?: (surfaceId: number) => void;
    getPlotSurfaceCameraState?: (surfaceId: number) => unknown;
    setPlotSurfaceCameraState?: (surfaceId: number, state: unknown) => void;
    setPlotThemeConfig?: (theme: unknown) => void;
    onFigureEvent?: (callback: ((event: FigureEvent) => void) | null) => void;
    newFigureHandle?: () => number;
    selectFigure?: (handle: number) => void;
    currentFigureHandle?: () => number;
    setHoldMode?: (mode: HoldMode) => boolean;
    configureSubplot?: (rows: number, cols: number, index: number) => void;
    clearFigure?: (handle: number | null) => number;
    resetPlotState?: () => void;
    closeFigure?: (handle: number | null) => number;
    currentAxesInfo?: () => AxesInfo;
    renderFigureImage?: (handle: number | null, width: number, height: number) => Promise<Uint8Array>;
    renderFigureImageWithTextmark?: (handle: number | null, width: number, height: number, textmark?: string) => Promise<Uint8Array>;
    renderFigureImageWithCameraState?: (handle: number | null, width: number, height: number, cameraState: FigureImageCameraState, textmark?: string) => Promise<Uint8Array>;
    renderGeometrySceneImage?: (handle: number, width: number, height: number, view?: string | null) => Promise<Uint8Array>;
    subscribeStdout?: (listener: (entry: StdoutEntry) => void) => number;
    unsubscribeStdout?: (id: number) => void;
    subscribeRuntimeLog?: (listener: (entry: RuntimeLogEntry) => void) => number;
    unsubscribeRuntimeLog?: (id: number) => void;
    setLogFilter?: (filter: string) => void;
    subscribeTraceEvents?: (listener: (entries: TraceEvent[]) => void) => number;
    unsubscribeTraceEvents?: (id: number) => void;
}
export declare function initRunMat(options?: RunMatInitOptions): Promise<RunMatSessionHandle>;
export declare function executeProgramArtifact(request: Record<string, unknown>, wasmModule?: WasmInitInput): Promise<Record<string, unknown>>;
export declare function fetchGitSnapshot(request: GitGatewayRequest, options: ServerGitGatewayOptions): Promise<GitSnapshotWire>;
export declare function planGitAcquisition(request: GitAcquisitionPlanRequest): Promise<GitAcquisitionPlan>;
export declare function projectTestLayout(input: {
    manifestPath: string;
    manifestContent: string;
}): Promise<unknown>;
export declare function freezeTestSnapshot(input: unknown): Promise<Record<string, unknown>>;
export declare function runTests(input: unknown, backend: unknown): Promise<unknown>;
export declare function runTestsWithEvents(input: unknown, backend: unknown, observer: (event: Record<string, unknown>) => void): Promise<unknown>;
export declare function resolveRunmatConfig(source: string, format: RunmatConfigFormat): Promise<ResolvedRunmatConfig>;
export declare function patchRunmatConfig(source: string, format: RunmatConfigFormat, patch: RunmatConfigPatch): Promise<string>;
export declare function migrateLegacyRunmatConfig(source: string, format: RunmatConfigFormat): Promise<LegacyRunmatConfigMigration>;
export declare function migrateLegacyRunmatConfigInto(legacySource: string, destinationSource: string, format: RunmatConfigFormat): Promise<LegacyRunmatConfigMigration>;
export declare function createBrowserProjectResolver(config: Omit<BrowserProjectResolverConfig, "native">): Promise<BrowserProjectResolver>;
export declare function createBrowserProjectSession(config: Omit<BrowserProjectSessionConfig, "native">): Promise<BrowserProjectSession>;
export declare function decodePackageLock(input: string): Promise<unknown>;
export declare function encodePackageLock(value: unknown): Promise<string>;
export declare function handoffFromFrozenProject(project: unknown): Promise<unknown>;
export declare function browserPackageCacheStatus(provider: RunMatPackageCacheProvider): Promise<PackageCacheStatus>;
export declare function browserPackageCacheGc(provider: RunMatPackageCacheProvider, targetBytes: bigint, retainRecentMs?: bigint): Promise<PackageCacheGcPlan>;
export declare function plotRendererReady(): Promise<boolean>;
export declare function createPlotSurface(canvas: HTMLCanvasElement | OffscreenCanvas): Promise<number>;
export declare function destroyPlotSurface(surfaceId: number): Promise<void>;
export declare function resizePlotSurface(surfaceId: number, widthPx: number, heightPx: number, pixelsPerPoint?: number): Promise<void>;
export declare function bindSurfaceToFigure(surfaceId: number, handle: number): Promise<void>;
export declare function presentSurface(surfaceId: number): Promise<void>;
export declare function presentFigureOnSurface(surfaceId: number, handle: number): Promise<void>;
export declare function presentGeometrySceneOnSurface(surfaceId: number, handle: number): Promise<void>;
export declare function setGeometryScenePresentation(surfaceId: number, presentation: GeometryScenePresentationState): Promise<void>;
export declare function pickGeometrySceneRegion(surfaceId: number, x: number, y: number): Promise<GeometryScenePickResult | null>;
export declare function renderCurrentFigureScene(handle: number): Promise<void>;
export declare function handlePlotSurfaceEvent(surfaceId: number, event: PlotSurfaceEvent): Promise<void>;
export declare function takePlotSurfaceHostActions(surfaceId: number): Promise<PlotSurfaceHostAction[]>;
export declare function fitPlotSurfaceExtents(surfaceId: number): Promise<void>;
export declare function resetPlotSurfaceCamera(surfaceId: number): Promise<void>;
export declare function getPlotSurfaceCameraState(surfaceId: number): Promise<PlotSurfaceCameraState>;
export declare function setPlotSurfaceCameraState(surfaceId: number, state: PlotSurfaceCameraState): Promise<void>;
export declare function setPlotThemeConfig(theme: unknown): Promise<void>;
export declare function onFigureEvent(listener: FigureEventListener | null): Promise<void>;
export declare function subscribeStdout(listener: StdoutListener): Promise<number>;
export declare function unsubscribeStdout(id: number): Promise<void>;
export declare function subscribeRuntimeLog(listener: RuntimeLogListener): Promise<number>;
export declare function unsubscribeRuntimeLog(id: number): Promise<void>;
export declare function setLogFilter(filter: string): Promise<void>;
export declare function subscribeTraceEvents(listener: TraceEventListener): Promise<number>;
export declare function unsubscribeTraceEvents(id: number): Promise<void>;
export declare function figure(handle?: number): Promise<number>;
export declare function newFigureHandle(): Promise<number>;
export declare function currentFigureHandle(): Promise<number>;
export declare function setHoldMode(mode?: HoldMode): Promise<boolean>;
export declare function hold(mode?: HoldMode): Promise<boolean>;
export declare function holdOn(): Promise<boolean>;
export declare function holdOff(): Promise<boolean>;
export declare function configureSubplot(rows: number, cols: number, index?: number): Promise<void>;
export declare function subplot(rows: number, cols: number, index?: number): Promise<void>;
export declare function clearFigure(handle?: number): Promise<number>;
export declare function resetPlotState(): Promise<void>;
export declare function closeFigure(handle?: number): Promise<number>;
export declare function currentAxesInfo(): Promise<AxesInfo>;
export declare function renderFigureImage(options?: FigureImageOptions): Promise<Uint8Array>;
export declare function renderGeometrySceneImage(options: GeometrySceneImageOptions): Promise<Uint8Array>;
export declare function exportFigureScene(handle: number): Promise<Uint8Array | null>;
export declare function exportGeometryScene(handle: number): Promise<Uint8Array | null>;
export declare function importFigureScene(scene: Uint8Array): Promise<number | null>;
export declare function importGeometryScene(scene: Uint8Array): Promise<number | null>;
export declare function importFigureSceneFromPath(path: string): Promise<number | null>;
export declare function exportWorkspaceState(options?: {
    includeVariables?: "off" | "auto" | "force";
}): Promise<Uint8Array | null>;
export declare function importWorkspaceState(state: Uint8Array): Promise<boolean>;
declare function coerceFigureError(value: unknown): FigureBindingError;
declare function normalizeResumeInputValue(value: ResumeInputValue): ResumeInputPayload;
export declare const __internals: {
    coerceFigureError: typeof coerceFigureError;
    normalizeResumeInputValue: typeof normalizeResumeInputValue;
    workspaceHover: Record<string, unknown>;
    setNativeModuleOverride(module: RunMatNativeModule | RunMatNativeSession | null): void;
};
//# sourceMappingURL=index.d.ts.map