@wasm-idle/terminal 1.0.0-next.0 → 1.0.0

package/README.md

@@ -22,3 +22,32 @@ pnpm add wasm-idle @wasm-idle/terminal svelte
 
 Compiler and language-runtime payloads are not included in this package. Configure their external
 URLs through the injected playground binding.
+
+## Stop lifecycle
+
+`TerminalControl.stop()` does not resolve until the active sandbox's `kill()` or `terminate()`
+operation resolves. Sandbox implementations may return either `void` or `Promise<void>` from those
+methods; an asynchronous implementation must keep its promise pending until runtime resources are
+released.
+
+The C/C++ and Rust LLDB sandboxes use this contract to wait for both LLDB and WAMR worker teardown.
+Callers can therefore await `stop()` before launching another debug session without overlapping the
+previous session's workers or receiving its late events.
+
+## Interactive runs
+
+Set `interactive: true` only for a run that remains under explicit user control and has a working
+stop/dispose path. The shared execution boundary then omits the wall-clock deadline only for the
+final `run(..., prepare = false)` call. Runtime loading and `prepare()` keep their configured
+deadlines, and AbortSignal cancellation, output/diagnostic limits, exclusive sandbox ownership, and
+teardown remain enforced. wasm-idle uses this contract for Debug runs, which may stay paused at a
+breakpoint indefinitely; ordinary Run requests remain time-bounded.
+
+## Input generations
+
+Input submitted while `prepare()` is still running remains queued for the matching `run()` when the
+same language and runtime assets reuse that sandbox. `stop()`, `clear()`, `destroy()`, runtime
+restart, component teardown, and a language or asset change discard queued input and EOF state
+before retiring the sandbox. A later debug session therefore cannot consume stdin entered for an
+older generation. Clipboard reads are asynchronous, so pasted text is accepted only if the input
+generation that requested it is still current when the browser returns the clipboard contents.

package/dist/Terminal.svelte

@@ -1,12 +1,16 @@
 <script lang="ts">
 	import {
+		RuntimeProgressController,
+		TimeoutError,
 		createRuntimeAssetsKey,
-		phaseProgress,
-		progressBandsForLanguage,
 		type DebugCommand,
-		type DebugSessionEvent
+		type DebugDataBreakpoint,
+		type DebugDataBreakpointInfoArguments,
+		type DebugSessionEvent,
+		type ProgressLike
 	} from '@wasm-idle/core';
 	import { onMount } from 'svelte';
+	import { SvelteMap } from 'svelte/reactivity';
 	import '@xterm/xterm/css/xterm.css';
 	import type { Terminal as TerminalType } from '@xterm/xterm';
 	import registerAllPlugins from './plugin/index.js';
@@ -55,7 +59,9 @@
 		input = '',
 		inputCursor = 0,
 		pendingSandboxInput: string[] = [],
+		pendingDebugBreakpoints = new SvelteMap<string, number[]>(),
 		pendingSandboxEof = false,
+		sandboxInputGeneration = 0,
 		sandbox: BoundSandbox,
 		sandboxAcceptingInput = false,
 		first = true,
@@ -63,15 +69,91 @@
 		plugin = $state(),
 		ll: string | null = null,
 		loadedRuntimeAssetsKey: string | undefined = undefined,
-		stopRequested = false;
+		stopRequested = false,
+		progressLifecycleCounter = 0,
+		activeExecutionProgress: ProgressLike | undefined,
+		activeExecutionLanguage: string | undefined,
+		preparedExecution:
+			| {
+					key: string;
+					sandbox: BoundSandbox;
+			  }
+			| undefined;
+	let preparedExecutionGeneration = 0;
+	let lastExecutionError: unknown;
+	const progressController = new RuntimeProgressController();
+	const terminalOutputReadinessLanguages = new Set([
+		'C',
+		'CPP',
+		'OBJC',
+		'RUST',
+		'GO',
+		'D',
+		'CSHARP',
+		'FSHARP',
+		'VBNET',
+		'FORTRAN',
+		'COBOL',
+		'OCAML',
+		'HASKELL'
+	]);
+
+	function clearPreparedExecution() {
+		preparedExecution = undefined;
+	}
+
+	function invalidatePreparedExecution() {
+		preparedExecutionGeneration += 1;
+		clearPreparedExecution();
+		return preparedExecutionGeneration;
+	}
 
-	function writeTerminalOutput(text: string) {
+	function executionPreparationKey(
+		language: string,
+		code: string,
+		log: boolean,
+		args: string[],
+		options: TerminalExecutionOptions
+	) {
+		try {
+			const keyOptions = { ...options };
+			delete keyOptions.signal;
+			return JSON.stringify([language, code, log, args, keyOptions]);
+		} catch {
+			return undefined;
+		}
+	}
+
+	function activityOnlyProgress(progress: ProgressLike | undefined) {
+		if (!progress) return undefined;
+		return {
+			set: progress.set,
+			report: (event: Parameters<NonNullable<ProgressLike['report']>>[0]) => {
+				if (event.kind === 'activity') progress.report?.(event);
+			}
+		} satisfies ProgressLike;
+	}
+
+	function writeTerminalOutput(text: string, executionOutput = false) {
 		if (!text) return;
+		if (
+			executionOutput &&
+			activeExecutionLanguage &&
+			terminalOutputReadinessLanguages.has(activeExecutionLanguage)
+		) {
+			activeExecutionProgress?.report?.({
+				kind: 'ready',
+				state: 'running',
+				reason: 'stdout',
+				label: 'Program output received'
+			});
+		}
 		debugOutput += text;
 		term?.write(text);
 	}
 
 	function wait() {
+		if (term) return Promise.resolve();
 		return new Promise<void>((r) => {
 			const i = setInterval(() => {
 				if (term) {
@@ -91,7 +173,12 @@
 		let _tc = ++tc;
 		await wait();
 		sandboxAcceptingInput = false;
-		if (sandbox && requiresSandboxReset) await sandbox.clear();
+		if (requiresSandboxReset) clearPreparedExecution();
+		if (sandbox && requiresSandboxReset) {
+			discardPendingSandboxInput();
+			await sandbox.clear();
+			discardPendingSandboxInput();
+		}
 		input = '';
 		inputCursor = 0;
 		finish = false;
@@ -102,10 +189,21 @@
 			loadedRuntimeAssetsKey = currentRuntimeAssetsKey;
 		}
 		sandbox.image = onimage;
-		sandbox.ondebug = ondebug;
+		sandbox.ondebug = (event) => {
+			if (event.type === 'pause') {
+				activeExecutionProgress?.report?.({
+					kind: 'ready',
+					state: 'paused',
+					reason: 'debug-paused',
+					label: 'Debugger paused'
+				});
+			}
+			ondebug?.(event);
+		};
 		sandbox.oncompilerdiagnostic = oncompilediagnostic;
 		sandbox.output = (output: string) =>
-			_tc === tc && writeTerminalOutput(output.replaceAll('\n', '\r\n'));
+			_tc === tc && writeTerminalOutput(output.replaceAll('\n', '\r\n'), true);
+		return requiresSandboxReset;
 	}
 
 	function flushPendingSandboxInput() {
@@ -121,12 +219,33 @@
 		}
 	}
 
+	function discardPendingSandboxInput() {
+		sandboxInputGeneration += 1;
+		pendingSandboxInput = [];
+		pendingSandboxEof = false;
+	}
+
 	function submitSandboxEof() {
 		if (sandbox && sandboxAcceptingInput) sandbox.eof?.();
 		else pendingSandboxEof = true;
 	}
 
-	function runSandbox<T>(pr: Promise<T>, reportFinish = true) {
+	function finishSandboxRun() {
+		sandboxAcceptingInput = false;
+		stopRequested = false;
+		onfinish?.();
+		finish = true;
+		if (term) term.options.cursorBlink = false;
+	}
+
+	function isTimeoutError(error: unknown) {
+		return (
+			error instanceof TimeoutError ||
+			(error instanceof Error && error.name === 'TimeoutError')
+		);
+	}
+
+	function runSandbox<T>(pr: Promise<T>, reportFinish = true, finalize = true) {
 		return pr
 			.then((x) => {
 				if (reportFinish) {
@@ -137,19 +256,37 @@
 				return x;
 			})
 			.catch((msg) => {
+				lastExecutionError = msg;
 				if (stopRequested) return false;
+				if (isTimeoutError(msg)) {
+					writeTerminalOutput(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
+					throw msg;
+				}
 				writeTerminalOutput(`\r\n\x1B[1;3;31m${msg}\u001B[?25l`);
 				return false;
 			})
 			.finally(() => {
-				sandboxAcceptingInput = false;
-				stopRequested = false;
-				onfinish?.();
-				finish = true;
-				if (term) term.options.cursorBlink = false;
+				if (finalize) finishSandboxRun();
 			});
 	}
 
+	async function withProgressLifecycle<T>(
+		language: string,
+		progress: ProgressLike | undefined,
+		operation: (progress: ProgressLike | undefined) => Promise<T>
+	) {
+		const lifecycle = progressController.begin(
+			`${language}:${++progressLifecycleCounter}`,
+			progress,
+			`Loading ${language} runtime`
+		);
+		try {
+			return await operation(lifecycle.progress);
+		} finally {
+			lifecycle.end();
+		}
+	}
+
 	async function initTerm(blink = true) {
 		await wait();
 		if (!term) return;
@@ -242,8 +379,12 @@
 	}
 
 	const terminalControl: TerminalControl = {
+		getExecutionError: () => lastExecutionError,
 		async clear() {
 			await wait();
+			lastExecutionError = undefined;
+			invalidatePreparedExecution();
+			discardPendingSandboxInput();
 			term?.reset();
 			term?.write(`\u001B[?25l\x1b[0m\x1b[?25h`);
 			if (term) term.options.cursorBlink = false;
@@ -251,90 +392,259 @@
 			input = '';
 			inputCursor = 0;
 			sandboxAcceptingInput = false;
-			pendingSandboxEof = false;
 			first = true;
 			await new Promise((r) => setTimeout(r, 100));
+			discardPendingSandboxInput();
 		},
 		async prepare(
 			language: string,
 			code: string,
 			log = true,
-			prog?: { set?: (value: number, stage?: string) => void },
+			prog?: ProgressLike,
 			args: string[] = [],
 			options: TerminalExecutionOptions = {}
 		) {
-			prog?.set?.(0, `Loading ${language} runtime`);
-			const progressBands = progressBandsForLanguage(language);
-			const loadProgress = phaseProgress(
-				prog,
-				progressBands.load[0],
-				progressBands.load[1],
-				`Loading ${language} runtime`
-			);
-			const prepareProgress = phaseProgress(
-				prog,
-				progressBands.prepare[0],
-				progressBands.prepare[1],
-				`Preparing ${language} program`
-			);
-			await Promise.all([
-				initSandbox(language).then(() =>
-					sandbox.load(code, log, args, options, loadProgress)
-				),
-				initTerm(false)
-			]);
-			prepareProgress?.set?.(0, `Preparing ${language} program`);
-			const prepared = !!(await runSandbox(
-				sandbox.run(code, true, log, prepareProgress, args, options),
-				false
-			));
-			if (prepared) prepareProgress?.set?.(1, `${language} runtime ready`);
-			return prepared;
+			return await withProgressLifecycle(language, prog, async (runProgress) => {
+				const preparationGeneration = invalidatePreparedExecution();
+				const prepareProgress = activityOnlyProgress(runProgress);
+				await Promise.all([
+					initSandbox(language).then(() =>
+						sandbox.load(code, log, args, options, prepareProgress)
+					),
+					initTerm(false)
+				]);
+				const preparationSandbox = sandbox;
+				runProgress?.report?.({
+					kind: 'activity',
+					phase: 'starting',
+					label: `Preparing ${language} program`
+				});
+				const prepared = !!(await runSandbox(
+					preparationSandbox.run(code, true, log, prepareProgress, args, options),
+					false
+				));
+				const preparationKey = executionPreparationKey(language, code, log, args, options);
+				if (
+					prepared &&
+					preparationKey &&
+					preparationGeneration === preparedExecutionGeneration &&
+					preparationSandbox === sandbox
+				) {
+					preparedExecution = { key: preparationKey, sandbox: preparationSandbox };
+				}
+				return prepared;
+			});
 		},
 		async run(
 			language: string,
 			code: string,
 			log = true,
-			prog?: { set?: (value: number, stage?: string) => void },
+			prog?: ProgressLike,
 			args: string[] = [],
 			options: TerminalExecutionOptions = {}
 		) {
-			await Promise.all([
-				initSandbox(language).then(() => sandbox.load(code, log, args, options, prog)),
-				initTerm()
-			]);
-			sandboxAcceptingInput = true;
-			flushPendingSandboxInput();
-			return await runSandbox(sandbox.run(code, false, log, prog, args, options));
+			return await withProgressLifecycle(language, prog, async (runProgress) => {
+				let executionRunWillFinalize = false;
+				const preparedCandidate = preparedExecution;
+				const executionGeneration = invalidatePreparedExecution();
+				pendingDebugBreakpoints.clear();
+				for (const { sourcePath, lines } of options.sourceBreakpoints || []) {
+					pendingDebugBreakpoints.set(sourcePath, [...lines]);
+				}
+				const [sandboxWasReset] = await Promise.all([
+					initSandbox(language).then(async (wasReset) => {
+						await sandbox.load(
+							code,
+							log,
+							args,
+							options,
+							activityOnlyProgress(runProgress)
+						);
+						return wasReset;
+					}),
+					initTerm()
+				]);
+				const executionOptions = {
+					...options,
+					sourceBreakpoints: Array.from(
+						pendingDebugBreakpoints,
+						([sourcePath, lines]) => ({
+							sourcePath,
+							lines: [...lines]
+						})
+					)
+				};
+				const preparationKey = executionPreparationKey(language, code, log, args, options);
+				const mayUsePreparedOutput =
+					executionGeneration === preparedExecutionGeneration &&
+					!sandboxWasReset &&
+					!!preparationKey &&
+					preparedCandidate?.sandbox === sandbox &&
+					preparedCandidate.key === preparationKey;
+				try {
+					if (terminalOutputReadinessLanguages.has(language) && !mayUsePreparedOutput) {
+						const prepareProgress = activityOnlyProgress(runProgress);
+						runProgress?.report?.({
+							kind: 'activity',
+							phase: 'starting',
+							label: `Preparing ${language} program`
+						});
+						const prepared = !!(await runSandbox(
+							sandbox.run(code, true, log, prepareProgress, args, options),
+							false,
+							false
+						));
+						if (!prepared) {
+							runProgress?.report?.({
+								kind: 'settled',
+								outcome: options.signal?.aborted ? 'cancelled' : 'failed',
+								label: `${language} run ended`
+							});
+							return false;
+						}
+					}
+
+					activeExecutionProgress = runProgress;
+					activeExecutionLanguage = language;
+					sandboxAcceptingInput = true;
+					flushPendingSandboxInput();
+					executionRunWillFinalize = true;
+					const result = await runSandbox(
+						sandbox.run(code, false, log, runProgress, args, executionOptions)
+					);
+					if (result === false) {
+						runProgress?.report?.({
+							kind: 'settled',
+							outcome: options.signal?.aborted ? 'cancelled' : 'failed',
+							label: `${language} run ended`
+						});
+					} else {
+						runProgress?.report?.({
+							kind: 'ready',
+							state: 'running',
+							reason: 'result',
+							label: `${language} run completed`
+						});
+						runProgress?.report?.({
+							kind: 'settled',
+							outcome: 'completed',
+							label: `${language} run completed`
+						});
+					}
+					return result;
+				} catch (error) {
+					if (isTimeoutError(error)) {
+						runProgress?.report?.({
+							kind: 'settled',
+							outcome: 'timed-out',
+							label: `${language} run timed out`
+						});
+					}
+					throw error;
+				} finally {
+					if (!executionRunWillFinalize) finishSandboxRun();
+					if (activeExecutionProgress === runProgress) {
+						activeExecutionProgress = undefined;
+						activeExecutionLanguage = undefined;
+					}
+				}
+			});
 		},
 		async destroy() {
 			await wait();
+			progressController.invalidate();
+			invalidatePreparedExecution();
 			sandboxAcceptingInput = false;
-			pendingSandboxEof = false;
+			discardPendingSandboxInput();
 			term?.dispose();
 			if (sandbox) await sandbox.clear();
+			discardPendingSandboxInput();
+		},
+		async restartRuntime() {
+			await wait();
+			if (!sandbox) return;
+			progressController.invalidate();
+			invalidatePreparedExecution();
+			sandboxAcceptingInput = false;
+			discardPendingSandboxInput();
+			input = '';
+			inputCursor = 0;
+			finish = true;
+			stopRequested = false;
+			tc += 1;
+			if (sandbox.restart) await sandbox.restart();
+			else await sandbox.clear();
+			discardPendingSandboxInput();
 		},
 		async stop() {
 			await wait();
+			progressController.invalidate();
+			invalidatePreparedExecution();
 			stopRequested = true;
 			finish = true;
 			sandboxAcceptingInput = false;
-			pendingSandboxEof = false;
-			if (sandbox?.kill) sandbox.kill();
-			else sandbox?.terminate?.();
+			discardPendingSandboxInput();
+			if (sandbox?.kill) await sandbox.kill();
+			else await sandbox?.terminate?.();
+			discardPendingSandboxInput();
 		},
 		async debugCommand(command: DebugCommand) {
 			await wait();
-			sandbox.debugCommand?.(command);
+			await sandbox.debugCommand?.(command);
+		},
+		async debugPause() {
+			await wait();
+			await sandbox.debugPause?.();
 		},
-		async setBreakpoints(lines: number[]) {
+		async setBreakpoints(lines: number[], sourcePath?: string) {
+			pendingDebugBreakpoints.set(sourcePath || '', [...lines]);
 			await wait();
-			sandbox?.setBreakpoints?.(lines);
+			await sandbox?.setBreakpoints?.(lines, sourcePath);
 		},
 		async debugEvaluate(expression: string) {
 			await wait();
 			return (await sandbox.debugEvaluate?.(expression)) || '?';
 		},
+		async debugVariables(variablesReference: number, start?: number, count?: number) {
+			await wait();
+			return (await sandbox.debugVariables?.(variablesReference, start, count)) || [];
+		},
+		async debugScopes(frameId: number) {
+			await wait();
+			return (await sandbox.debugScopes?.(frameId)) ?? [];
+		},
+		async debugFrameScopes(frameId: number) {
+			await wait();
+			return (await sandbox.debugFrameScopes?.(frameId)) ?? [];
+		},
+		async debugFrameName(frameId: number) {
+			await wait();
+			return (await sandbox.debugFrameName?.(frameId)) ?? null;
+		},
+		async debugReadMemory(memoryReference: string, offset: number, count: number) {
+			await wait();
+			return (await sandbox.debugReadMemory?.(memoryReference, offset, count)) ?? null;
+		},
+		async debugWriteMemory(
+			memoryReference: string,
+			offset: number,
+			data: Uint8Array,
+			allowPartial?: boolean
+		) {
+			await wait();
+			return (
+				(await sandbox.debugWriteMemory?.(memoryReference, offset, data, allowPartial)) ??
+				null
+			);
+		},
+		async debugDataBreakpointInfo(arguments_: DebugDataBreakpointInfoArguments) {
+			await wait();
+			return (await sandbox.debugDataBreakpointInfo?.(arguments_)) ?? null;
+		},
+		async debugSetDataBreakpoints(breakpoints: DebugDataBreakpoint[]) {
+			await wait();
+			return (await sandbox.debugSetDataBreakpoints?.(breakpoints)) ?? [];
+		},
 		async waitForInput() {
 			await waitForInput();
 		},
@@ -477,9 +787,14 @@
 					submitSandboxEof();
 				} else if ((ev.ctrlKey || ev.metaKey) && ev.key.toLowerCase() === 'v') {
 					ev.preventDefault();
-					navigator.clipboard.readText().then((text) => {
-						applyPastedText(text);
-					});
+					const generation = sandboxInputGeneration;
+					navigator.clipboard
+						.readText()
+						.then((text) => {
+							if (generation !== sandboxInputGeneration) return;
+							applyPastedText(text);
+						})
+						.catch(() => {});
 				}
 			});
 			plugin = await registerAllPlugins(term);
@@ -488,8 +803,12 @@
 		});
 
 		return async () => {
+			progressController.invalidate();
+			invalidatePreparedExecution();
+			discardPendingSandboxInput();
 			term?.dispose();
 			if (sandbox) await sandbox.clear();
+			discardPendingSandboxInput();
 		};
 	});
 </script>

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import Terminal from './Terminal.svelte';
 import registerAllPlugins from './plugin/index.js';
 import Theme from './theme.js';
-import type { BoundSandbox, CompilerDiagnostic, CompilerDiagnosticSeverity, DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, PlaygroundBinding, SandboxExecutionOptions, TerminalControl, TerminalExecutionOptions } from './types.js';
+import type { BoundSandbox, CompilerDiagnostic, CompilerDiagnosticSeverity, DebugCommand, DebugFrame, DebugMemory, DebugSessionEvent, DebugVariable, DebugWriteMemoryResult, PlaygroundBinding, SandboxExecutionOptions, TerminalControl, TerminalExecutionOptions } from './types.js';
 export { Terminal, Theme, registerAllPlugins };
-export type { BoundSandbox, CompilerDiagnostic, CompilerDiagnosticSeverity, DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, PlaygroundBinding, SandboxExecutionOptions, TerminalControl, TerminalExecutionOptions };
+export type { BoundSandbox, CompilerDiagnostic, CompilerDiagnosticSeverity, DebugCommand, DebugFrame, DebugMemory, DebugSessionEvent, DebugVariable, DebugWriteMemoryResult, PlaygroundBinding, SandboxExecutionOptions, TerminalControl, TerminalExecutionOptions };
 export default Terminal;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { BoundSandbox as CoreBoundSandbox, DebugCommand, PlaygroundBinding as CorePlaygroundBinding, ProgressLike, SandboxExecutionOptions as CoreSandboxExecutionOptions, TerminalControl as CoreTerminalControl } from '@wasm-idle/core';
+import type { BoundSandbox as CoreBoundSandbox, DebugCommand, DebugSourceBreakpoints, PlaygroundBinding as CorePlaygroundBinding, ProgressLike, SandboxExecutionOptions as CoreSandboxExecutionOptions, TerminalControl as CoreTerminalControl } from '@wasm-idle/core';
 export type CompilerDiagnosticSeverity = 'error' | 'warning' | 'other';
 export interface CompilerDiagnostic {
     fileName?: string | null;
@@ -9,6 +9,7 @@ export interface CompilerDiagnostic {
     message: string;
 }
 export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
+export type BrowserDebugMode = 'none' | 'trace' | 'lldb';
 export type GoTarget = 'wasip1/wasm' | 'wasip2/wasm' | 'wasip3/wasm' | 'js/wasm';
 export type TinyGoTarget = 'wasm' | 'wasip1' | 'wasip2' | 'wasip3';
 export type OcamlBackend = 'js' | 'wasm';
@@ -19,10 +20,16 @@ export interface SandboxWorkspaceFile {
     content: string;
 }
 export interface SandboxExecutionOptions {
+    debugMode?: BrowserDebugMode;
+    /** @deprecated Use debugMode. */
     debug?: boolean;
+    /** Keep the final run alive until the host explicitly stops or disposes it. */
+    interactive?: boolean;
     breakpoints?: number[];
+    sourceBreakpoints?: DebugSourceBreakpoints[];
     pauseOnEntry?: boolean;
     stdin?: string;
+    signal?: AbortSignal;
     activePath?: string;
     debugPath?: string;
     workspaceFiles?: SandboxWorkspaceFile[];
@@ -47,8 +54,10 @@ export interface PlaygroundBinding extends Pick<CorePlaygroundBinding, 'runtimeA
     load: (language: string) => Promise<BoundSandbox>;
 }
 export interface TerminalControl extends Omit<CoreTerminalControl, 'prepare' | 'run' | 'debugCommand'> {
+    /** The original failure when the compatibility runner resolves false. */
+    getExecutionError?: () => unknown;
     prepare: (language: string, code: string, log?: boolean, progress?: ProgressLike, args?: string[], options?: TerminalExecutionOptions) => Promise<boolean>;
     run: (language: string, code: string, log?: boolean, progress?: ProgressLike, args?: string[], options?: TerminalExecutionOptions) => Promise<boolean | string>;
     debugCommand: (command: DebugCommand) => Promise<void>;
 }
-export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, ProgressLike } from '@wasm-idle/core';
+export type { DebugCommand, DebugFrame, DebugMemory, DebugResolvedBreakpoint, DebugSessionEvent, DebugScope, DebugVariable, DebugWriteMemoryResult, ProgressLike } from '@wasm-idle/core';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wasm-idle/terminal",
-  "version": "1.0.0-next.0",
+  "version": "1.0.0",
   "description": "Svelte terminal component for wasm-idle playground bindings",
   "license": "MIT",
   "type": "module",
@@ -19,10 +19,10 @@
   ],
   "publishConfig": {
     "access": "public",
-    "tag": "next"
+    "tag": "latest"
   },
   "peerDependencies": {
-    "@wasm-idle/core": "1.0.0-next.0",
+    "@wasm-idle/core": "1.0.0",
     "svelte": "^5.0.0"
   },
   "dependencies": {
@@ -33,7 +33,7 @@
     "@xterm/addon-web-links": "^0.12.0",
     "@xterm/addon-webgl": "^0.19.0",
     "@xterm/xterm": "^6.0.0",
-    "@wasm-idle/core": "1.0.0-next.0"
+    "@wasm-idle/core": "1.0.0"
   },
   "devDependencies": {
     "@sveltejs/package": "^2.5.7",