@specy/x86 2.1.0 → 2.3.0

package/dist/index.d.mts

@@ -5,78 +5,173 @@ declare function toResourceUrl(source: string | URL): URL;
 declare function readResourceBytes(source: ResourceSource): Promise<Uint8Array>;
 declare function defaultResourceUrl(relativePath: string, baseUrl: string): URL;
 //#endregion
-//#region src/assemblers.d.ts
-interface Binary {
-  file: ResourceSource;
-  commands: string;
-}
-interface DiagnosticLine {
-  file?: string;
+//#region src/interface.d.ts
+type StatusRegister = {
+  name: string;
+  value: number;
+  prev: number;
+};
+type DiagnosticSeverity = 'error' | 'warning';
+type MonacoError = {
+  /** Project-relative source path when checking a virtual Project. */file?: string;
+  lineIndex: number;
+  column: number;
+  line: {
+    line: string;
+    line_index: number;
+  };
+  message: string;
+  formatted: string; /** A warning still assembles; only an error stops the build. Absent means error. */
+  severity?: DiagnosticSeverity; /** The assembler's own name for the warning, such as `label-orphan`. */
+  code?: string; /** Help beyond what the assembler said, when this diagnostic has a known explanation. */
+  hint?: string;
+};
+type StackFrame = {
+  name: string;
+  address: bigint;
+  destination: bigint;
+  sp: bigint;
   line: number;
-  error: string;
+  file?: string;
+  color: string;
+};
+type RegisterHex = [hi: string, lo: string];
+declare enum RegisterSize {
+  Byte = 1,
+  Word = 2,
+  Long = 4,
+  Double = 8
 }
-type DiagnosticsParser = (assemblerLogs: string) => DiagnosticLine[];
-interface AssemblerMode {
-  id: string;
-  displayName: string;
-  description: string;
-  diagnosticsParser?: DiagnosticsParser;
-  binaries: {
-    assembler: Binary;
-    linker?: Binary;
+type ExecutionStep = {
+  mutations: MutationOperation[];
+  pc: number;
+  old_ccr: {
+    bits: number;
   };
-}
-declare const assemblers: {
-  GNU_trunk: {
-    id: string;
-    displayName: string;
-    description: string;
-    diagnosticsParser: typeof gnuDiagnostics;
-    binaries: {
-      assembler: {
-        file: URL;
-        commands: string;
-      };
-      linker: {
-        file: URL;
-        commands: string;
-      };
-    };
+  new_ccr: {
+    bits: number;
   };
-  FASM_trunk: {
-    id: string;
-    displayName: string;
-    description: string;
-    diagnosticsParser: typeof fasmDiagnostics;
-    binaries: {
-      assembler: {
-        file: URL;
-        commands: string;
-      };
-    };
+  line: number;
+  file?: string;
+};
+type MutationOperation = {
+  type: 'WriteRegister';
+  value: {
+    register: string;
+    old: bigint;
+    size: RegisterSize;
   };
-  NASM_trunk: {
-    id: string;
-    displayName: string;
-    description: string;
-    diagnosticsParser: typeof nasmDiagnostics;
-    binaries: {
-      assembler: {
-        file: URL;
-        commands: string;
-      };
-      linker: {
-        file: URL;
-        commands: string;
-      };
-    };
+} | {
+  type: 'WriteMemory';
+  value: {
+    address: bigint;
+    old: bigint;
+    size: RegisterSize;
+  };
+} | {
+  type: 'WriteMemoryBytes';
+  value: {
+    address: bigint;
+    old: number[];
   };
+} | {
+  type: 'PopCallStack';
+  value: {
+    to: bigint;
+    from: bigint;
+  };
+} | {
+  type: 'PushCallStack';
+  value: {
+    to: bigint;
+    from: bigint;
+  };
+} | {
+  type: 'Other';
+  value: string;
 };
-type AssemblerId = keyof typeof assemblers;
-declare const DEFAULT_ASSEMBLER_ID: AssemblerId;
-declare function nasmDiagnostics(str: string): DiagnosticLine[];
-declare function gnuDiagnostics(str: string): DiagnosticLine[];
-declare function fasmDiagnostics(str: string): DiagnosticLine[];
+type EmulatorDecoration = {
+  type: 'below-line';
+  note?: string;
+  belowLine: number;
+  md: string;
+};
+type CompilationError = {
+  type: 'raw';
+  message: string;
+};
+declare enum EmulatorStatus {
+  Terminated = 0,
+  Running = 1,
+  WaitingForInput = 2,
+  NotReady = 3
+}
+type Instruction = {
+  address: bigint;
+  lineNumber: number;
+  file?: string;
+  size?: number;
+  bytes?: Uint8Array;
+  code: string;
+};
+type EmulatorConfig<R extends string> = {
+  systemSize: RegisterSize;
+  registerNames: R[];
+  endianness?: 'little' | 'big';
+  hiddenRegisters?: R[];
+};
+declare abstract class BaseEmulator<T, R extends string, CompileResult = {
+  ok: true;
+} | {
+  ok: false;
+  errors: CompilationError[];
+  report: string;
+}> {
+  protected _registerNames: R[];
+  protected _systemSize: RegisterSize;
+  protected _endianness: 'little' | 'big';
+  constructor(options: EmulatorConfig<R>);
+  getSystemSize(): RegisterSize;
+  getEndianness(): 'little' | 'big';
+  getRegisterNames(): R[];
+  abstract initialize(undoSize: number): void;
+  abstract getCompiledCode(): {
+    decorations: EmulatorDecoration[];
+    code: string;
+  };
+  abstract dispose(): void;
+  abstract stringifyError(error: unknown): string;
+  abstract compile(code: string): Promise<CompileResult>;
+  abstract checkCode(code: string): Promise<MonacoError[]>;
+  abstract undo(): void;
+  abstract canUndo(): boolean;
+  abstract step(): Promise<{
+    terminated: boolean;
+  }>;
+  abstract getStatus(): EmulatorStatus;
+  abstract writeMemoryBytes(address: bigint, data: Uint8Array): void;
+  abstract readMemoryBytes(address: bigint, length: bigint): Uint8Array;
+  abstract getNextInstruction(): Instruction | null;
+  abstract getUndoHistory(max: number): ExecutionStep[];
+  abstract getPc(): bigint;
+  abstract getSp(): bigint;
+  abstract getFlags(): {
+    name: string;
+    value: number;
+    prev?: number;
+  }[];
+  abstract getCallStack(): StackFrame[];
+  abstract getInstructionAt(address: bigint): Instruction | null;
+  abstract getRegisterValues(): bigint[];
+  abstract getRegisterValuesRecord(): Record<R, bigint>;
+  abstract getRegisterValue(register: R, size?: RegisterSize): bigint;
+  abstract setRegisterValue(register: R, value: bigint, size?: RegisterSize): void;
+  abstract hasTerminated(): boolean;
+  abstract run(limit?: number, breakpoints?: Array<number | {
+    path: string;
+    line: number;
+  }>): Promise<EmulatorStatus>;
+}
 //#endregion
 //#region src/callbacks.d.ts
 type MaybePromise<T> = T | PromiseLike<T>;
@@ -110,7 +205,9 @@ type StopReason = {
 type X86CompilationDiagnostic = {
   line: number;
   error: string; /** Project-relative source path when compiling a virtual Project. */
-  file?: string;
+  file?: string; /** A warning still assembles; only an error stops the build. */
+  severity: DiagnosticSeverity; /** The assembler's own name for the warning, such as `label-orphan`. */
+  warningClass?: string;
 };
 type X86ProjectFile = string | Uint8Array;
 type X86Project = {
@@ -122,13 +219,20 @@ type X86SourceLocation = {
   line: number;
 };
 type X86Breakpoint = number | X86SourceLocation;
+/**
+ * `diagnostics` carries everything the assembler said, warnings included - a
+ * successful build routinely has some, and they are the most useful thing it
+ * produces. `errors` is the subset that stopped the build.
+ */
 type X86CompileResult = {
   ok: true;
   report: string;
+  diagnostics: X86CompilationDiagnostic[];
 } | {
   ok: false;
   errors: X86CompilationDiagnostic[];
   report: string;
+  diagnostics: X86CompilationDiagnostic[];
 };
 type X86EmulatorEventMap = {
   stateChange: {
@@ -148,6 +252,152 @@ type X86EmulatorEventMap = {
 type X86EmulatorEventName = keyof X86EmulatorEventMap;
 type X86EmulatorEventHandler<T extends X86EmulatorEventName> = (event: X86EmulatorEventMap[T]) => MaybePromise<void>;
 //#endregion
+//#region src/wasm-assembler.d.ts
+/**
+ * An assembler that runs as its own WebAssembly module rather than as an x86-64
+ * ELF interpreted by blink. Blink costs roughly 1.2s of startup plus 14ms per
+ * line of source for NASM; the same work in its own module takes single-digit
+ * milliseconds, and produces byte-identical output.
+ *
+ * The object files come back as bytes for the caller to stage wherever the
+ * linker expects them, so the linker can keep running inside blink unchanged.
+ */
+interface WasmAssembler {
+  assemble(project: X86Project): Promise<WasmAssemblyResult>;
+}
+/** One translation unit's object, and the Project File it was assembled from. */
+type WasmAssemblyUnit = {
+  path: string;
+  object: Uint8Array;
+};
+type WasmAssemblyResult = {
+  /** The assembler's exit status: 0 when every translation unit assembled. */status: number; /** What it wrote to stdout, verbatim. */
+  stdout: string; /** What it wrote to stderr, verbatim - the diagnostics a parser reads. */
+  stderr: string;
+  /**
+   * The objects to link, Entry first. Empty when any translation unit failed:
+   * a partial link would report missing symbols that are only missing because
+   * the File defining them is the one that did not assemble.
+   */
+  units: WasmAssemblyUnit[]; /** The Entry's object, or null when the assembly failed. */
+  object: Uint8Array | null;
+};
+//#endregion
+//#region src/assemblers.d.ts
+interface Binary {
+  file: ResourceSource;
+  commands: string;
+}
+interface LinkerBinary {
+  file: ResourceSource;
+  /**
+   * The command that links however many objects the Project's translation units produced. Every
+   * path it is given is one this package generated, so none of them needs escaping.
+   */
+  link(objects: readonly string[]): string;
+}
+interface DiagnosticLine {
+  file?: string;
+  line: number;
+  error: string;
+  /** A warning still assembles; only an error stops the build. */
+  severity: DiagnosticSeverity;
+  /**
+   * NASM's own name for the warning, taken from the `[-w+label-orphan]` tag it
+   * appends. It is a stable identifier for the kind of mistake, which is what
+   * an explanation can be keyed on.
+   */
+  warningClass?: string;
+}
+type DiagnosticsParser = (assemblerLogs: string) => DiagnosticLine[];
+interface AssemblerMode {
+  id: string;
+  displayName: string;
+  description: string;
+  diagnosticsParser?: DiagnosticsParser;
+  binaries: {
+    /**
+     * The assembler as an x86-64 ELF for blink to interpret. Absent when
+     * `wasmAssembler` is set, which runs the assembler as its own module
+     * instead - far faster, but only possible for an assembler written in
+     * portable C. Fasm is written in x86 assembly and has no such build.
+     */
+    assembler?: Binary;
+    linker?: LinkerBinary;
+  };
+  /** Runs outside blink, and takes precedence over `binaries.assembler`. */
+  wasmAssembler?: WasmAssembler;
+}
+declare const assemblers: {
+  GNU_trunk: {
+    id: string;
+    displayName: string;
+    description: string;
+    diagnosticsParser: typeof gnuDiagnostics;
+    binaries: {
+      assembler: {
+        file: URL;
+        commands: string;
+      };
+      linker: {
+        file: URL;
+        link: (objects: readonly string[]) => string;
+      };
+    };
+  };
+  FASM_trunk: {
+    id: string;
+    displayName: string;
+    description: string;
+    diagnosticsParser: typeof fasmDiagnostics;
+    binaries: {
+      assembler: {
+        file: URL;
+        commands: string;
+      };
+    };
+  };
+  NASM_trunk: {
+    id: string;
+    displayName: string;
+    description: string;
+    diagnosticsParser: typeof nasmDiagnostics;
+    binaries: {
+      linker: {
+        file: URL;
+        link: (objects: readonly string[]) => string;
+      };
+    };
+    wasmAssembler: WasmAssembler;
+  };
+};
+type AssemblerId = keyof typeof assemblers;
+declare const DEFAULT_ASSEMBLER_ID: AssemblerId;
+declare function nasmDiagnostics(str: string): DiagnosticLine[];
+declare function gnuDiagnostics(str: string): DiagnosticLine[];
+declare function fasmDiagnostics(str: string): DiagnosticLine[];
+/**
+ * What `ld` said, as diagnostics. Nothing else in the toolchain reports a symbol that no
+ * translation unit defines: NASM accepts every `extern` on the author's word, and the mistake
+ * only surfaces here. Without this the link simply failed and the build looked like it had
+ * succeeded, leaving the program unrunnable and nothing on screen to say why.
+ *
+ * `ld` writes a location as `file:line:(section+offset):`, and writes the notes that introduce an
+ * error - "in function `_start':" - as lines ending in a colon, which are skipped in favour of
+ * the error itself.
+ */
+declare function ldDiagnostics(str: string): DiagnosticLine[];
+/**
+ * The one-based column a diagnostic belongs on. NASM reports a line and no
+ * column, but it names the thing it is complaining about: `msg' in "symbol
+ * `msg' not defined", `.data' in a section warning. Finding that name in the
+ * line turns a whole-line squiggle into one under the mistake itself.
+ *
+ * Falls back to the first column, which is what the caller would have used
+ * anyway, so a message that names nothing findable is no worse off.
+ */
+declare function locateDiagnosticColumn(message: string, line: string, warningClass?: string): number;
+//#endregion
 //#region src/wasm-types.d.ts
 type EmscriptenFS = {
   init(stdin: () => number | null, stdout: (charCode: number) => void, stderr: (charCode: number) => void): void;
@@ -291,13 +541,20 @@ declare class BlinkRuntime {
   state: BlinkState;
   stopReason: StopReason | null;
   assemblerLogs: string;
+  /** The subset of `assemblerDiagnostics` that stopped the build. */
   assemblerErrors: X86CompilationDiagnostic[];
+  /** Everything the assembler said, warnings included. */
+  assemblerDiagnostics: X86CompilationDiagnostic[];
   private readonly callbacks;
   private readonly scheduler;
   private readonly stateWaiters;
   private readonly stdinBytes;
   private sourceMap;
   private sourceProject;
+  private assembleOnly;
+  private assembledObjects;
+  /** What the linker said, kept apart from the assembler's log so `ld`'s own parser reads it. */
+  private linkerLogs;
   private readonly defaultArgc;
   private readonly defaultArgv;
   private constructor();
@@ -305,6 +562,57 @@ declare class BlinkRuntime {
   setMode(mode: AssemblerMode | AssemblerId): Promise<void>;
   compileAssembly(code: string): Promise<X86CompileResult>;
   compileProject(project: X86Project): Promise<X86CompileResult>;
+  /**
+   * Assembles without linking, for diagnostics. The linked executable is only
+   * needed to run or debug a program; a caller that just wants to know what is
+   * wrong with the source pays ~450ms for a link it never looks at.
+   *
+   * A mode with a `wasmAssembler` never touches blink here, so checking also
+   * leaves a loaded program - and anything paused in the debugger - alone.
+   */
+  checkProject(project: X86Project): Promise<X86CompileResult>;
+  private checkProjectWithWasmAssembler;
+  private buildProject;
+  /**
+   * The objects this build's assembler wrote, for the checks that read them
+   * rather than the assembler's own words. Empty when the assembly failed, and
+   * when the assembler writes an executable directly and never produces one.
+   * Read once per build, so a previous build's objects can never stand in for
+   * ones that were never written.
+   */
+  private takeAssembledObjects;
+  /**
+   * What the link had to say. A link that failed leaves no program to run, so a build that
+   * reported nothing would hand the caller a success it cannot act on - the state stays `Ready`
+   * and the next step or run fails with a message about the emulator rather than the mistake.
+   * The fallback covers a linker that fails in a way its parser does not recognise, so a failed
+   * link is always visible as an error whatever `ld` chose to say about it.
+   */
+  private linkDiagnostics;
+  /**
+   * Nothing in the toolchain treats a missing entry point as a failure: NASM
+   * has no opinion on it and `ld` only warns, then starts the program at the
+   * top of its text segment, where it runs whatever happens to be first. That
+   * is the least explicable thing a program can do to someone learning, so it
+   * is reported as an error here and the mistake is usually a misspelling.
+   */
+  private entryPointDiagnostics;
+  private assembleInBlink;
+  /**
+   * Assembles outside blink and hands the object file to the linker inside it,
+   * which is where the state machine picks up again as if blink had produced
+   * the object itself.
+   */
+  private assembleWithWasmAssembler;
+  /**
+   * Starts the link, and starts a log of its own for it. The assembler's parser cannot read
+   * `ld`'s diagnostics and `ld`'s cannot read the assembler's, so what each of them said has to
+   * stay separable even though both reach the caller as one report.
+   */
+  private beginLinking;
+  private collectAssemblerDiagnostics;
+  private emitAssemblerOutput;
+  private parseAssemblerDiagnostics;
   loadElf(data: ArrayBuffer | Uint8Array): void;
   starti(): void;
   pauseAtEntry(): void;
@@ -355,170 +663,6 @@ declare class BlinkRuntime {
   private tryReadSourceMap;
 }
 //#endregion
-//#region src/interface.d.ts
-type StatusRegister = {
-  name: string;
-  value: number;
-  prev: number;
-};
-type MonacoError = {
-  /** Project-relative source path when checking a virtual Project. */file?: string;
-  lineIndex: number;
-  column: number;
-  line: {
-    line: string;
-    line_index: number;
-  };
-  message: string;
-  formatted: string;
-};
-type StackFrame = {
-  name: string;
-  address: bigint;
-  destination: bigint;
-  sp: bigint;
-  line: number;
-  file?: string;
-  color: string;
-};
-type RegisterHex = [hi: string, lo: string];
-declare enum RegisterSize {
-  Byte = 1,
-  Word = 2,
-  Long = 4,
-  Double = 8
-}
-type ExecutionStep = {
-  mutations: MutationOperation[];
-  pc: number;
-  old_ccr: {
-    bits: number;
-  };
-  new_ccr: {
-    bits: number;
-  };
-  line: number;
-  file?: string;
-};
-type MutationOperation = {
-  type: 'WriteRegister';
-  value: {
-    register: string;
-    old: bigint;
-    size: RegisterSize;
-  };
-} | {
-  type: 'WriteMemory';
-  value: {
-    address: bigint;
-    old: bigint;
-    size: RegisterSize;
-  };
-} | {
-  type: 'WriteMemoryBytes';
-  value: {
-    address: bigint;
-    old: number[];
-  };
-} | {
-  type: 'PopCallStack';
-  value: {
-    to: bigint;
-    from: bigint;
-  };
-} | {
-  type: 'PushCallStack';
-  value: {
-    to: bigint;
-    from: bigint;
-  };
-} | {
-  type: 'Other';
-  value: string;
-};
-type EmulatorDecoration = {
-  type: 'below-line';
-  note?: string;
-  belowLine: number;
-  md: string;
-};
-type CompilationError = {
-  type: 'raw';
-  message: string;
-};
-declare enum EmulatorStatus {
-  Terminated = 0,
-  Running = 1,
-  WaitingForInput = 2,
-  NotReady = 3
-}
-type Instruction = {
-  address: bigint;
-  lineNumber: number;
-  file?: string;
-  size?: number;
-  bytes?: Uint8Array;
-  code: string;
-};
-type EmulatorConfig<R extends string> = {
-  systemSize: RegisterSize;
-  registerNames: R[];
-  endianness?: 'little' | 'big';
-  hiddenRegisters?: R[];
-};
-declare abstract class BaseEmulator<T, R extends string, CompileResult = {
-  ok: true;
-} | {
-  ok: false;
-  errors: CompilationError[];
-  report: string;
-}> {
-  protected _registerNames: R[];
-  protected _systemSize: RegisterSize;
-  protected _endianness: 'little' | 'big';
-  constructor(options: EmulatorConfig<R>);
-  getSystemSize(): RegisterSize;
-  getEndianness(): 'little' | 'big';
-  getRegisterNames(): R[];
-  abstract initialize(undoSize: number): void;
-  abstract getCompiledCode(): {
-    decorations: EmulatorDecoration[];
-    code: string;
-  };
-  abstract dispose(): void;
-  abstract stringifyError(error: unknown): string;
-  abstract compile(code: string): Promise<CompileResult>;
-  abstract checkCode(code: string): Promise<MonacoError[]>;
-  abstract undo(): void;
-  abstract canUndo(): boolean;
-  abstract step(): Promise<{
-    terminated: boolean;
-  }>;
-  abstract getStatus(): EmulatorStatus;
-  abstract writeMemoryBytes(address: bigint, data: Uint8Array): void;
-  abstract readMemoryBytes(address: bigint, length: bigint): Uint8Array;
-  abstract getNextInstruction(): Instruction | null;
-  abstract getUndoHistory(max: number): ExecutionStep[];
-  abstract getPc(): bigint;
-  abstract getSp(): bigint;
-  abstract getFlags(): {
-    name: string;
-    value: number;
-    prev?: number;
-  }[];
-  abstract getCallStack(): StackFrame[];
-  abstract getInstructionAt(address: bigint): Instruction | null;
-  abstract getRegisterValues(): bigint[];
-  abstract getRegisterValuesRecord(): Record<R, bigint>;
-  abstract getRegisterValue(register: R, size?: RegisterSize): bigint;
-  abstract setRegisterValue(register: R, value: bigint, size?: RegisterSize): void;
-  abstract hasTerminated(): boolean;
-  abstract run(limit?: number, breakpoints?: Array<number | {
-    path: string;
-    line: number;
-  }>): Promise<EmulatorStatus>;
-}
-//#endregion
 //#region src/project.d.ts
 declare const X86_PROJECT_ROOT = "/__x86_project";
 declare function validateX86Project(project: X86Project): void;
@@ -528,6 +672,13 @@ declare function validateX86Project(project: X86Project): void;
  * preprocessor macros.
  */
 declare function stageX86Project(fs: EmscriptenFS, project: X86Project): void;
+/**
+ * Points the assembler at one staged Project File and leaves that File's own directory as the
+ * working directory, so its `%include`s and `incbin`s resolve from where it was written rather
+ * than from wherever the Entry happens to live. The Entry keeps its `/assembly.s` identity, which
+ * is the path its existing diagnostics and source maps are written in terms of.
+ */
+declare function selectX86Source(fs: EmscriptenFS, project: X86Project, path: string): string;
 /** Maps a path emitted by NASM or DWARF back to the exact Project path. */
 declare function x86ProjectSourcePath(sourcePath: string | undefined, project: Pick<X86Project, 'entry' | 'files'>): string;
 declare function x86ProjectText(project: X86Project, path: string): string;
@@ -564,6 +715,11 @@ declare class X86Emulator extends BaseEmulator<BlinkRuntime, X86RegisterName, X8
   dispose(): void;
   stringifyError(error: unknown): string;
   checkCode(code: string): Promise<MonacoError[]>;
+  /**
+   * Diagnostics only: this assembles but does not link, and for an assembler
+   * that runs as its own wasm module it does not touch blink at all, so a
+   * loaded or paused program survives a check.
+   */
   checkProject(project: X86Project): Promise<MonacoError[]>;
   undo(): void;
   canUndo(): boolean;
@@ -607,5 +763,5 @@ declare class X86Emulator extends BaseEmulator<BlinkRuntime, X86RegisterName, X8
 }
 declare function createX86Emulator(options?: X86EmulatorOptions): Promise<X86Emulator>;
 //#endregion
-export { AssemblerId, AssemblerMode, BaseEmulator, Binary, BlinkRunOptions, BlinkRuntime, BlinkRuntimeCallbacks, BlinkRuntimeOptions, BlinkState, BlinkenlibModule, BlinkenlibModuleOptions, CompilationError, DEFAULT_ASSEMBLER_ID, DiagnosticLine, DiagnosticsParser, DisassemblySnapshot, EmscriptenFS, EmulatorConfig, EmulatorDecoration, EmulatorStatus, ExecutionStep, Instruction, MaybePromise, MemoryReadResult, MemoryWriteResult, MonacoError, MutationOperation, NativeControlFlowKind, NativeInstruction, NativeMemoryWrite, NativeRunControls, NativeRunStop, NativeRunStopKind, NativeStepInfo, NativeSymbol, RegisterHex, RegisterSize, RegisterSnapshot, ResourceSource, StackFrame, StatusRegister, StopReason, StopReasonKind, X86Breakpoint, X86CompilationDiagnostic, X86CompileResult, X86Emulator, X86EmulatorEventHandler, X86EmulatorEventMap, X86EmulatorEventName, X86EmulatorOptions, X86Project, X86ProjectFile, X86RegisterName, X86SourceLocation, X86_PROJECT_ROOT, X86_REGISTER_NAMES, assemblers, createX86Emulator, defaultResourceUrl, fasmDiagnostics, gnuDiagnostics, isNodeRuntime, nasmDiagnostics, observeCallbackResult, readResourceBytes, stageX86Project, toResourceUrl, validateX86Project, x86ProjectSourcePath, x86ProjectText };
+export { AssemblerId, AssemblerMode, BaseEmulator, Binary, BlinkRunOptions, BlinkRuntime, BlinkRuntimeCallbacks, BlinkRuntimeOptions, BlinkState, BlinkenlibModule, BlinkenlibModuleOptions, CompilationError, DEFAULT_ASSEMBLER_ID, DiagnosticLine, DiagnosticSeverity, DiagnosticsParser, DisassemblySnapshot, EmscriptenFS, EmulatorConfig, EmulatorDecoration, EmulatorStatus, ExecutionStep, Instruction, LinkerBinary, MaybePromise, MemoryReadResult, MemoryWriteResult, MonacoError, MutationOperation, NativeControlFlowKind, NativeInstruction, NativeMemoryWrite, NativeRunControls, NativeRunStop, NativeRunStopKind, NativeStepInfo, NativeSymbol, RegisterHex, RegisterSize, RegisterSnapshot, ResourceSource, StackFrame, StatusRegister, StopReason, StopReasonKind, X86Breakpoint, X86CompilationDiagnostic, X86CompileResult, X86Emulator, X86EmulatorEventHandler, X86EmulatorEventMap, X86EmulatorEventName, X86EmulatorOptions, X86Project, X86ProjectFile, X86RegisterName, X86SourceLocation, X86_PROJECT_ROOT, X86_REGISTER_NAMES, assemblers, createX86Emulator, defaultResourceUrl, fasmDiagnostics, gnuDiagnostics, isNodeRuntime, ldDiagnostics, locateDiagnosticColumn, nasmDiagnostics, observeCallbackResult, readResourceBytes, selectX86Source, stageX86Project, toResourceUrl, validateX86Project, x86ProjectSourcePath, x86ProjectText };
 //# sourceMappingURL=index.d.mts.map