@vibesdotdev/terminal-client 0.0.0-stage → 1.0.0-rc.2

package/dist/svelte/TerminalWorkspace.svelte

@@ -0,0 +1,562 @@
+<script lang="ts">
+	import { onDestroy } from 'svelte';
+	import { CapabilityError, CaughtFailureSchema } from '@vibesdotdev/kernel';
+	import { getRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte';
+	import { Button } from '@vibesdotdev/kit/components/ui/button';
+	import * as Select from '@vibesdotdev/kit/components/ui/select';
+	import * as AlertDialog from '@vibesdotdev/kit/components/ui/alert-dialog';
+	import {
+		CircleHelp,
+		Eraser,
+		Info,
+		OctagonX,
+		PanelsTopLeft,
+		Play,
+		RotateCw,
+		TriangleAlert
+	} from '@lucide/svelte';
+	import type {
+		ExecutionCapabilities,
+		ExecutionSession,
+		ProcessHandle
+	} from '@vibesdotdev/kernel/execution';
+	import Terminal from './Terminal.svelte';
+	import {
+		openTerminalWorkspaceTargetSession,
+		terminalWorkspaceCapabilityBanner,
+		terminalWorkspacePlaceDefaultCapabilities,
+		terminalWorkspaceQuickActions,
+		terminalWorkspaceConnectionNotice,
+		terminalWorkspaceDefaultCommand,
+		terminalWorkspaceError,
+		terminalWorkspaceExitedEvent,
+		terminalWorkspaceLaunchSignature,
+		terminalWorkspacePlaceLabel,
+		terminalWorkspaceStatusLabel,
+		type TerminalWorkspaceLifecycleEvent,
+		type TerminalWorkspaceOpenedReceipt,
+		type TerminalWorkspaceQuickActionId,
+		type TerminalWorkspaceRuntimePlaceOption,
+		type TerminalWorkspaceStatus
+	} from '../workspace.js';
+	import type { TerminalTheme } from './types.js';
+
+	interface Props {
+		/** Trusted host transport; session lifecycle and rendering remain owner-managed. */
+		sessionOpener?: typeof openTerminalWorkspaceTargetSession;
+		executionId?: string;
+		runtimePlaceId?: string;
+		command?: string;
+		args?: string[];
+		cwd?: string;
+		title?: string;
+		class?: string;
+		compact?: boolean;
+		theme?: TerminalTheme;
+		/** Host-supplied, executable runtime places plus honest unavailable inventory. */
+		loadRuntimePlaces?: () => Promise<readonly TerminalWorkspaceRuntimePlaceOption[]>;
+		/** Opens a separate Terminal window; the current session never migrates silently. */
+		onOpenRuntimePlace?: (place: TerminalWorkspaceRuntimePlaceOption) => void;
+		/** Receives real execution outcomes; `opened` is emitted only after `session()` resolves. */
+		onLifecycle?: (event: TerminalWorkspaceLifecycleEvent) => void;
+	}
+
+	let {
+		sessionOpener = openTerminalWorkspaceTargetSession,
+		executionId = 'browser-shell',
+		runtimePlaceId = 'browser:this-profile',
+		command,
+		args = [],
+		cwd = '/',
+		title = 'Terminal',
+		class: className = '',
+		compact = false,
+		theme,
+		loadRuntimePlaces,
+		onOpenRuntimePlace,
+		onLifecycle
+	}: Props = $props();
+
+	const runtimeStore = getRuntimeSvelteContext();
+
+	let status = $state<TerminalWorkspaceStatus>('idle');
+	let notice = $state('Opening terminal...');
+	let session = $state<ExecutionSession | null>(null);
+	let lastDimensions = $state({ cols: 80, rows: 24 });
+	let inputReady = $state(false);
+	let replaceSessionOpen = $state(false);
+	function requestNewSession(): void {
+		if (status === 'live') replaceSessionOpen = true;
+		else void openSession();
+	}
+	let activeCwd = $state('/');
+	let activeLaunchSignature = $state('');
+	let openedReceipt = $state<TerminalWorkspaceOpenedReceipt | null>(null);
+	let terminalReady = $state(false);
+	let openGeneration = 0;
+	let placeLoadGeneration = 0;
+	let runtimePlaces = $state<TerminalWorkspaceRuntimePlaceOption[]>([]);
+	let runtimePlacesLoading = $state(false);
+	let runtimePlacesError = $state<string | null>(null);
+	/** Live capability mask from the opened place; overrides the pre-open expectation. */
+	let openedCapabilities = $state<ExecutionCapabilities | null>(null);
+	/** Accumulated exec-mode output, appended live as stdout/stderr bytes arrive. */
+	let execResultText = $state<string | null>(null);
+	/** The live exec-mode process; killed on re-open/destroy. */
+	let execProcess = $state<ProcessHandle | null>(null);
+
+	const statusLabel = $derived(terminalWorkspaceStatusLabel(status));
+	const placeLabel = $derived(terminalWorkspacePlaceLabel(runtimePlaceId));
+	const currentRuntimePlace = $derived(
+		runtimePlaces.find((place) => place.id === runtimePlaceId) ?? {
+			id: runtimePlaceId,
+			label: placeLabel,
+			status: 'available' as const,
+			executionId
+		}
+	);
+	const encoder = new TextEncoder();
+	const quickActionIcons = { help: CircleHelp, clear: Eraser, interrupt: OctagonX, end: Play };
+	// Honest capability gate: the live mask if a place has opened, else the place's
+	// advertised mask, else the pre-resolution expectation derived from the id.
+	const caps = $derived(
+		openedCapabilities ??
+			currentRuntimePlace.capabilities ??
+			terminalWorkspacePlaceDefaultCapabilities(runtimePlaceId)
+	);
+	const isExecMode = $derived(caps.pty === false);
+	const capabilityBanner = $derived(terminalWorkspaceCapabilityBanner(caps, runtimePlaceId));
+
+	function fallbackRuntimePlace(): TerminalWorkspaceRuntimePlaceOption {
+		return {
+			id: runtimePlaceId,
+			label: terminalWorkspacePlaceLabel(runtimePlaceId),
+			status: 'available',
+			executionId
+		};
+	}
+
+	onDestroy(() => {
+		openGeneration += 1;
+		placeLoadGeneration += 1;
+		session?.kill();
+		session = null;
+		execProcess?.kill();
+		execProcess = null;
+		openedReceipt = null;
+		inputReady = false;
+		terminalReady = false;
+	});
+
+	$effect(() => {
+		const loader = loadRuntimePlaces;
+		void runtimePlaceId;
+		void executionId;
+		const generation = ++placeLoadGeneration;
+		if (!loader) {
+			runtimePlaces = [fallbackRuntimePlace()];
+			runtimePlacesLoading = false;
+			runtimePlacesError = null;
+			return;
+		}
+		runtimePlacesLoading = true;
+		runtimePlacesError = null;
+		void loader()
+			.then(
+				(places) => ({ kind: 'loaded' as const, places }),
+				(cause) => ({
+					kind: 'failure' as const,
+					failure: CapabilityError.from(CaughtFailureSchema.parse(cause))
+				})
+			)
+			.then((outcome) => {
+				if (generation !== placeLoadGeneration) return;
+				if (outcome.kind === 'failure') {
+					runtimePlaces = [fallbackRuntimePlace()];
+					runtimePlacesError = outcome.failure.message;
+					return;
+				}
+				const unique = new Map(outcome.places.map((place) => [place.id, place]));
+				if (!unique.has(runtimePlaceId)) unique.set(runtimePlaceId, fallbackRuntimePlace());
+				runtimePlaces = [...unique.values()];
+			})
+			.finally(() => {
+				if (generation === placeLoadGeneration) runtimePlacesLoading = false;
+			});
+	});
+
+	function openRuntimePlace(place: TerminalWorkspaceRuntimePlaceOption): void {
+		if (place.status !== 'available') return;
+		onOpenRuntimePlace?.(place);
+	}
+
+	function handleRuntimePlaceSelection(value: string | undefined): void {
+		if (!value || value === runtimePlaceId) return;
+		const place = runtimePlaces.find((candidate) => candidate.id === value);
+		if (place) openRuntimePlace(place);
+	}
+
+	function handleReady(dimensions: { cols: number; rows: number }): void {
+		lastDimensions = dimensions;
+		terminalReady = true;
+		if (!session && status === 'idle') {
+			void openSession(dimensions);
+		}
+	}
+
+	async function openSession(dimensions = lastDimensions): Promise<void> {
+		const generation = ++openGeneration;
+		const sessionExecutionId = executionId;
+		const sessionCommand = command ?? terminalWorkspaceDefaultCommand(runtimePlaceId);
+		const sessionArgs = [...args];
+		const sessionCwd = cwd;
+		activeLaunchSignature = terminalWorkspaceLaunchSignature({
+			runtimePlaceId,
+			executionId: sessionExecutionId,
+			command: sessionCommand,
+			args: sessionArgs,
+			cwd: sessionCwd
+		});
+		let lifecycleEvent: TerminalWorkspaceOpenedReceipt | null = null;
+		session?.kill();
+		session = null;
+		execProcess?.kill();
+		execProcess = null;
+		openedReceipt = null;
+		openedCapabilities = null;
+		execResultText = null;
+		inputReady = false;
+		status = 'opening';
+		notice = isExecMode ? 'Preparing cloud exec…' : 'Opening terminal...';
+		const opening = runtimeStore.load().then((runtime) => sessionOpener({
+				runtime,
+				executionId: sessionExecutionId,
+				command: sessionCommand,
+				args: sessionArgs,
+				runtimePlaceId,
+				cwd: sessionCwd,
+				cols: dimensions.cols,
+				rows: dimensions.rows
+			}));
+		const outcome = await opening.then(
+			(opened) => ({ kind: 'opened' as const, opened }),
+			(cause) => ({
+				kind: 'failure' as const,
+				failure: CapabilityError.from(CaughtFailureSchema.parse(cause))
+			})
+		);
+		if (outcome.kind === 'failure') {
+			if (generation !== openGeneration) return;
+			if (isExecMode) {
+				status = 'idle';
+				notice = 'Cloud exec — connect a cloud runtime to run commands.';
+			} else {
+				status = 'error';
+				notice = terminalWorkspaceError(outcome.failure, runtimePlaceId);
+			}
+			return;
+		}
+		const { opened } = outcome;
+			if (generation !== openGeneration) {
+				opened.session?.kill();
+				return;
+			}
+			openedCapabilities = opened.capabilities;
+			openedReceipt = opened.receipt;
+			activeCwd = sessionCwd;
+			if (opened.mode === 'exec' || !opened.session) {
+				// Honest non-PTY path: NO interactive PTY, NO faked keystroke stream.
+				// But output STREAMS live — drain the ProcessHandle into the panel as
+				// bytes arrive, then settle when the process exits.
+				session = null;
+				execProcess = opened.execProcess ?? null;
+				execResultText = '';
+				status = 'live';
+				notice = 'Cloud exec — streaming output…';
+				if (opened.execProcess) {
+					void streamExecProcess(opened.execProcess, generation, opened.receipt);
+				}
+			} else {
+				session = opened.session;
+				status = 'live';
+				notice = terminalWorkspaceConnectionNotice(sessionCwd, runtimePlaceId);
+			}
+			lifecycleEvent = opened.receipt;
+		if (lifecycleEvent) onLifecycle?.(lifecycleEvent);
+	}
+
+	function handleDisconnect(reason: string): void {
+		status = 'error';
+		inputReady = false;
+		notice = reason || 'Connection lost. Start a new session to reconnect.';
+	}
+
+	function handleExit(result: { exitCode: number | null }): void {
+		const receipt = openedReceipt;
+		status = 'exited';
+		notice = 'Session ended.';
+		inputReady = false;
+		if (receipt) onLifecycle?.(terminalWorkspaceExitedEvent(receipt, result));
+	}
+
+	/**
+	 * Drain a live exec-mode ProcessHandle into the panel. Reads stdout+stderr
+	 * concurrently, appending decoded text as bytes arrive (chunk 1 shows before
+	 * exit), then settles status + emits the exited lifecycle event on exit. A
+	 * stale generation (re-open/destroy) aborts the drain and kills the process.
+	 */
+	async function streamExecProcess(
+		handle: ProcessHandle,
+		generation: number,
+		receipt: TerminalWorkspaceOpenedReceipt
+	): Promise<void> {
+		const pump = async (stream: ReadableStream<Uint8Array> | null): Promise<void> => {
+			if (!stream) return;
+			const reader = stream.getReader();
+			const decoder = new TextDecoder();
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (generation !== openGeneration) return;
+					execResultText = (execResultText ?? '') + decoder.decode(value, { stream: true });
+				}
+				const tail = decoder.decode();
+				if (tail && generation === openGeneration) execResultText = (execResultText ?? '') + tail;
+			} finally {
+				reader.releaseLock();
+			}
+		};
+		const outcome = await Promise.all([
+				pump(handle.stdout),
+				pump(handle.stderr),
+				handle.exited
+			])
+			.then(
+				([, , exit]) => ({ kind: 'exit' as const, exit }),
+				(cause) => ({
+					kind: 'failure' as const,
+					failure: CapabilityError.from(CaughtFailureSchema.parse(cause))
+				})
+			);
+		if (generation !== openGeneration) return;
+		if (outcome.kind === 'failure') {
+			status = 'error';
+			notice = terminalWorkspaceError(outcome.failure, runtimePlaceId);
+			return;
+		}
+		if ((execResultText ?? '').length === 0) execResultText = '(command produced no output)';
+		status = 'exited';
+		const { exit } = outcome;
+		notice = exit.code === 0 || exit.code === null ? 'Command finished.' : `Command exited (${exit.code}).`;
+		onLifecycle?.(terminalWorkspaceExitedEvent(receipt, { exitCode: exit.code }));
+	}
+
+	function handleInputReady(): void {
+		inputReady = true;
+	}
+
+	$effect(() => {
+		const requestedLaunchSignature = terminalWorkspaceLaunchSignature({
+			runtimePlaceId,
+			executionId,
+			command: command ?? terminalWorkspaceDefaultCommand(runtimePlaceId),
+			args,
+			cwd
+		});
+		if (requestedLaunchSignature === activeLaunchSignature) return;
+		// Exec-mode places have no interactive terminal to become ready, so open as
+		// soon as the place resolves; PTY places still wait for onReady dimensions.
+		if (isExecMode) {
+			void openSession();
+			return;
+		}
+		if (!terminalReady) return;
+		void openSession();
+	});
+
+	function runQuickAction(action: {
+		id: TerminalWorkspaceQuickActionId;
+		command?: string;
+		signal?: string;
+	}): void {
+		if (!session || status !== 'live' || !inputReady) return;
+		if (action.signal) {
+			// PTY input delivers SIGINT to the foreground process group. Signaling
+			// only the shell PID can leave its current command running.
+			if (action.signal === 'SIGINT' && caps.pty) session.write(new Uint8Array([3]));
+			else session.signal(action.signal);
+			notice = 'Interrupt requested.';
+			return;
+		}
+		if (action.command) {
+			session.write(encoder.encode(`${action.command}\r`));
+			if (action.id === 'help') notice = 'Showing available commands.';
+			if (action.id === 'clear') notice = 'Cleared terminal output.';
+			if (action.id === 'end') notice = 'Ending session...';
+		}
+	}
+</script>
+
+<section
+	class={`grid h-full min-h-0 min-w-0 grid-rows-[auto_minmax(0,1fr)] ${compact ? 'gap-1' : 'gap-3'} overflow-hidden ${className}`}
+	aria-label={title}
+	data-terminal-workspace
+	data-terminal-status={status}
+	data-terminal-active-cwd={activeCwd}
+	data-terminal-runtime-place={runtimePlaceId}
+>
+	<header class={`flex flex-wrap items-center justify-between ${compact ? 'gap-1 border-b px-3 py-1' : 'gap-3'}`}>
+		<div class="min-w-0">
+			<div class="flex items-center gap-2">
+				<h2 class="truncate text-lg font-semibold">{title}</h2>
+				<span
+					class="rounded-full border border-border bg-background/70 px-2 py-0.5 text-xs font-medium"
+					title={runtimePlaceId}
+					data-runtime-place-id={runtimePlaceId}
+				>
+					{placeLabel}
+				</span>
+				<span class="rounded-full border border-border bg-muted px-2 py-0.5 text-xs font-medium">
+					{statusLabel}
+				</span>
+			</div>
+			<p class={compact && status === 'live' ? 'sr-only' : 'mt-1 truncate text-sm text-muted-foreground'}>{notice}</p>
+		</div>
+		<div class="terminal-workspace-actions flex flex-wrap items-center justify-end gap-2">
+			{#if onOpenRuntimePlace}
+				<Select.Root type="single" value={runtimePlaceId} onValueChange={handleRuntimePlaceSelection}>
+					<Select.Trigger
+						class="h-8 max-w-40 min-w-0 rounded-full"
+						aria-label="Open another terminal on a runtime place"
+					>
+						{runtimePlacesLoading ? 'Finding machines…' : currentRuntimePlace.label}
+					</Select.Trigger>
+					<Select.Content>
+						{#each runtimePlaces as place (place.id)}
+							<Select.Item
+								value={place.id}
+								label={place.label}
+								disabled={place.status !== 'available'}
+							>
+								<span class="flex min-w-0 flex-col">
+									<span class="truncate">{place.label}</span>
+									{#if place.detail}
+										<span class="truncate text-xs text-muted-foreground">{place.detail}</span>
+									{/if}
+								</span>
+							</Select.Item>
+						{/each}
+					</Select.Content>
+				</Select.Root>
+				<Button
+					variant="outline"
+					size="sm"
+					class="gap-2 rounded-full"
+					aria-label={`Open another terminal on ${currentRuntimePlace.label}`}
+					disabled={currentRuntimePlace.status !== 'available'}
+					onclick={() => openRuntimePlace(currentRuntimePlace)}
+				>
+					<PanelsTopLeft class="size-3.5" />
+					New window
+				</Button>
+			{/if}
+			{#each terminalWorkspaceQuickActions as action (action.id)}
+				{@const Icon = quickActionIcons[action.id]}
+				<Button
+					variant="outline"
+					size="sm"
+					class="gap-2 rounded-full"
+					disabled={status !== 'live' || !inputReady || isExecMode}
+					aria-label={action.label}
+					title={action.description}
+					onclick={() => runQuickAction(action)}
+				>
+					<Icon class="size-3.5" />
+					{#if !compact}{action.label}{/if}
+				</Button>
+			{/each}
+			<Button
+				variant="outline"
+				size="sm"
+				class="gap-2 rounded-full"
+				disabled={status === 'opening'}
+				onclick={requestNewSession}
+			>
+				<RotateCw class="size-3.5" />
+				New session
+			</Button>
+		</div>
+	</header>
+	{#if runtimePlacesError}
+		<p class="-mt-2 text-xs text-destructive" role="status">{runtimePlacesError}</p>
+	{/if}
+
+	{#if capabilityBanner}
+		<div
+			class="flex items-start gap-2 rounded-lg border border-border bg-muted px-3 py-2 text-sm text-foreground"
+			role="status"
+			data-capability-banner
+			data-terminal-exec-mode={isExecMode ? 'true' : 'false'}
+		>
+			{#if isExecMode}
+				<TriangleAlert class="mt-0.5 size-4 shrink-0" />
+			{:else}
+				<Info class="mt-0.5 size-4 shrink-0" />
+			{/if}
+			<span>{capabilityBanner}</span>
+		</div>
+	{/if}
+
+	{#if isExecMode}
+		<div
+			class="grid min-h-64 place-items-center rounded-xl border border-dashed border-border bg-muted/30 p-6 text-center"
+			data-terminal-exec-panel
+		>
+			<div class="max-w-md">
+				<h3 class="text-base font-semibold">Exec session — live output, no keystrokes</h3>
+				<p class="mt-2 text-sm leading-6 text-muted-foreground">{notice}</p>
+				{#if execResultText}
+					<pre
+						class="mt-4 max-h-64 overflow-auto rounded-lg bg-background/70 p-3 text-left text-xs">{execResultText}</pre>
+				{/if}
+			</div>
+		</div>
+	{:else if status === 'error'}
+		<div
+			class="grid min-h-64 place-items-center rounded-xl border border-dashed border-border bg-muted/30 p-6 text-center"
+		>
+			<div>
+				<h3 class="text-base font-semibold">Terminal is not available</h3>
+				<p class="mt-2 max-w-sm text-sm leading-6 text-muted-foreground">{notice}</p>
+				<Button class="mt-4 rounded-full" variant="outline" onclick={() => void openSession()}>
+					Try again
+				</Button>
+			</div>
+		</div>
+	{:else}
+		<Terminal
+			{session}
+			{theme}
+			onReady={handleReady}
+			onInputReady={handleInputReady}
+			onExit={handleExit}
+			onDisconnect={handleDisconnect}
+			onNewSession={requestNewSession}
+			class="min-h-0"
+		/>
+	{/if}
+</section>
+
+<AlertDialog.Root bind:open={replaceSessionOpen}>
+	<AlertDialog.Content>
+		<AlertDialog.Header>
+			<AlertDialog.Title>Replace this terminal session?</AlertDialog.Title>
+			<AlertDialog.Description>This ends the current shell and its running commands. Use another terminal tab if you want to keep them running.</AlertDialog.Description>
+		</AlertDialog.Header>
+		<AlertDialog.Footer>
+			<AlertDialog.Cancel>Keep session</AlertDialog.Cancel>
+			<AlertDialog.Action onclick={() => void openSession()}>Replace session</AlertDialog.Action>
+		</AlertDialog.Footer>
+	</AlertDialog.Content>
+</AlertDialog.Root>

package/dist/svelte/TerminalWorkspace.svelte.d.ts

@@ -0,0 +1,25 @@
+import { openTerminalWorkspaceTargetSession, type TerminalWorkspaceLifecycleEvent, type TerminalWorkspaceRuntimePlaceOption } from '../workspace.ts';
+import type { TerminalTheme } from './types.ts';
+interface Props {
+    /** Trusted host transport; session lifecycle and rendering remain owner-managed. */
+    sessionOpener?: typeof openTerminalWorkspaceTargetSession;
+    executionId?: string;
+    runtimePlaceId?: string;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    title?: string;
+    class?: string;
+    compact?: boolean;
+    theme?: TerminalTheme;
+    /** Host-supplied, executable runtime places plus honest unavailable inventory. */
+    loadRuntimePlaces?: () => Promise<readonly TerminalWorkspaceRuntimePlaceOption[]>;
+    /** Opens a separate Terminal window; the current session never migrates silently. */
+    onOpenRuntimePlace?: (place: TerminalWorkspaceRuntimePlaceOption) => void;
+    /** Receives real execution outcomes; `opened` is emitted only after `session()` resolves. */
+    onLifecycle?: (event: TerminalWorkspaceLifecycleEvent) => void;
+}
+declare const TerminalWorkspace: import("svelte").Component<Props, {}, "">;
+type TerminalWorkspace = ReturnType<typeof TerminalWorkspace>;
+export default TerminalWorkspace;
+//# sourceMappingURL=TerminalWorkspace.svelte.d.ts.map

package/dist/svelte/TerminalWorkspace.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerminalWorkspace.svelte.d.ts","sourceRoot":"","sources":["../../src/svelte/TerminalWorkspace.svelte.ts"],"names":[],"mappings":"AAyBA,OAAO,EACL,kCAAkC,EAWlC,KAAK,+BAA+B,EAGpC,KAAK,mCAAmC,EAExC,MAAM,iBAAiB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG/C,UAAU,KAAK;IACd,oFAAoF;IACpF,aAAa,CAAC,EAAE,OAAO,kCAAkC,CAAC;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,kFAAkF;IAClF,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC,SAAS,mCAAmC,EAAE,CAAC,CAAC;IAClF,qFAAqF;IACrF,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,mCAAmC,KAAK,IAAI,CAAC;IAC1E,6FAA6F;IAC7F,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,+BAA+B,KAAK,IAAI,CAAC;CAC/D;AA0cF,QAAA,MAAM,iBAAiB,2CAAwC,CAAC;AAChE,KAAK,iBAAiB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC9D,eAAe,iBAAiB,CAAC"}

package/dist/svelte/ambient.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ambient module declarations for terminal-svelte.
+ *
+ * The component dynamically imports xterm's stylesheet (`@xterm/xterm/css/
+ * xterm.css`) inside `onMount` so the browser bundler injects the styles. CSS
+ * modules carry no TypeScript types, so declare them as side-effecting imports.
+ */
+declare module '*.css';
+declare module '@xterm/xterm/css/xterm.css';

package/dist/svelte/docs/terminal-svelte.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=terminal-svelte.docs.descriptor.d.ts.map

package/dist/svelte/docs/terminal-svelte.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-svelte.docs.descriptor.d.ts","sourceRoot":"","sources":["../../../src/svelte/docs/terminal-svelte.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,QAAA,MAAM,UAAU,EAAE,mBAwEjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/svelte/docs/terminal-svelte.docs.descriptor.js

@@ -0,0 +1,74 @@
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'terminal-svelte',
+    parent: 'runtime',
+    order: 44,
+    title: 'Terminal Svelte',
+    summary: 'Svelte terminal surfaces over runtime-resolved interactive execution sessions.',
+    tags: ['terminal', 'svelte', 'execution', 'runtime', 'vessel'],
+    surfaces: ['web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true,
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: Terminal Svelte
+summary: Svelte terminal surfaces over runtime-resolved interactive execution sessions
+tags: [terminal, svelte, execution, runtime, vessel]
+parent: runtime
+order: 44
+surfaces: [web, in-app]
+hardware: [consumer, cloud]
+---
+
+# Terminal Svelte
+
+\`@vibesdotdev/terminal-client/svelte\` presents interactive terminal sessions without
+owning execution. \`TerminalWorkspace\` resolves \`runtime/execution\`, awaits a
+real \`ExecutionSession\`, and then mounts the xterm renderer over that session's
+byte stream.
+
+## Entrypoints
+
+- \`@vibesdotdev/terminal-client/svelte/Terminal.svelte\` - xterm renderer for an
+  injected \`ExecutionSession\`.
+- \`@vibesdotdev/terminal-client/svelte/TerminalWorkspace.svelte\` - runtime-backed
+  terminal workspace and lifecycle boundary.
+- \`@vibesdotdev/terminal-client/workspace\` - rune-free lifecycle helpers and
+  receipt types.
+- \`@vibesdotdev/terminal-client/svelte/plugin\` - docs descriptor registration and
+  the designed \`terminal\` Kit ToolCard (\`tools/ui\`, web).
+- \`@vibesdotdev/vessel/apps/terminal.vessel.plugin\` - Vessel-owned
+  \`terminal.workspace\` registration and browser loader for this owner component.
+
+## Terminal tool card
+
+The Svelte plugin registers a designed Kit \`ToolCard\` for \`tools/tool:terminal\`.
+The card shows cwd, command/session, and a bounded output excerpt through Kit
+\`CodeViewer\`. First-party terminal calls do not fall through to JSON
+\`DefaultToolCard\`.
+
+## Lifecycle boundary
+
+\`phase: 'opened'\` is emitted only after \`runtime/execution.session()\`
+resolves. Its receipt carries the resolved session, environment, and execution
+ids. A request to open Terminal is intent; this execution-backed receipt is the
+success signal.
+
+## Vessel capability
+
+The owner-declared Vessel surface requires \`runtime/execution\`. That metadata
+lets a host explain why Terminal is unavailable before it attempts to compose
+the surface, while the owner plugin keeps its Svelte module private behind a
+browser-scoped loader.
+
+## Boundary
+
+This package does not allocate PTYs, choose execution environments, manage
+filesystem adapters, or persist Vessel return points. Those capabilities remain
+with their runtime and feature owners.
+`
+    }
+};
+export default descriptor;