@deepseek-ai/dsh-api-terminal-controller 0.1.6-alpha.1

package/lib/types/client/index.d.ts

@@ -0,0 +1,88 @@
+/** Client terminal model service; views are keyed independently from Host terminal identities. */
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { TerminalView, type TerminalRemote } from './model.ts';
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { TerminalShell, WebTerminalId, WebTerminalInfo } from '../types.ts';
+export type { TerminalView, TerminalViewState, TerminalViewIssue, TerminalRenderFrame, TerminalRemote } from './model.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** React-free browser terminal views and explicit process cleanup. */
+        webTerminals: ClientTerminals;
+    }
+}
+/** Host-discovered shell menu with the browser's remembered available choice. */
+export interface TerminalLaunchShells {
+    readonly shells: readonly TerminalShell[];
+    readonly selectedShell: string | undefined;
+}
+/** A failed background close that can be retried without restoring its tab. */
+export interface TerminalCloseFailure {
+    readonly id: WebTerminalId;
+    readonly title: string;
+    readonly message: string;
+}
+/** Session and occurrence lookup, independent tab and terminal identities and background cleanup. */
+export declare class ClientTerminals extends Service {
+    private readonly remote;
+    /** Failed cleanup tasks; successful and in-progress closes have no visible notification. */
+    readonly closeFailures: SnapshotStore<readonly TerminalCloseFailure[]>;
+    private readonly requests;
+    private readonly closing;
+    private readonly closed;
+    private disposed;
+    private readonly views;
+    /**
+     * @param ctx - Client root Context with Gateway and terminal Remote namespace.
+     * @param remote - generated terminal namespace.
+     */
+    constructor(ctx: Context, remote: TerminalRemote);
+    /**
+     * Return the stable model for one sidebar occurrence.
+     * @param sessionId - owning Session.
+     * @param key - sidebar occurrence key.
+     * @param terminalId - existing Host identity when restoring a listed terminal.
+     * @param shellPath - explicit shell for a new terminal; restored terminals retain their own shell.
+     * @returns its observable state and terminal commands.
+     */
+    view(sessionId: SessionId, key: string, terminalId?: WebTerminalId, shellPath?: string): TerminalView;
+    /**
+     * Discover available launch choices on demand without allocating a PTY.
+     * @param sessionId - target Session.
+     * @param signal - the menu request lifetime.
+     * @returns installed shells and the currently usable browser preference.
+     */
+    launchShells(sessionId: SessionId, signal: AbortSignal): Promise<TerminalLaunchShells>;
+    /**
+     * Remember the guide selection before allocating its terminal tab.
+     * @param path - shell selected from Host discovery.
+     */
+    selectShell(path: string): void;
+    /**
+     * Save a close intent and release the tab immediately; cleanup outlives DOM unmount and reload.
+     * @param sessionId - owning Session.
+     * @param key - sidebar occurrence key, including an inactive restored tab.
+     * @param terminalId - restored identity if the tab has no model yet.
+     */
+    close(sessionId: SessionId, key: string, terminalId?: WebTerminalId): void;
+    /**
+     * Query Host terminals that have neither a tab in this page nor an unfinished close.
+     * @param sessionId - Session being displayed.
+     * @returns terminals available for opening as recovered tabs.
+     */
+    recover(sessionId: SessionId): Promise<WebTerminalInfo[]>;
+    /**
+     * Retry a saved close request without reopening its tab.
+     * @param id - failed terminal identity.
+     */
+    retryClose(id: WebTerminalId): void;
+    private cleanup;
+}
+/** Required Client transport and terminal namespace. */
+export declare const inject: string[];
+/**
+ * Install the Client terminal models.
+ * @param ctx - Client root Context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.js

@@ -0,0 +1,157 @@
+/** Client terminal model service; views are keyed independently from Host terminal identities. */
+import { Service } from '@deepseek-ai/cordis';
+import { remoteErrorOf } from '@deepseek-ai/dsh-typert-protocol';
+import { TerminalView } from "./model.js";
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-store';
+import { randomUUID } from '@deepseek-ai/dsh-util-crypto';
+import { preferredShell, rememberShell } from "./shell-preference.js";
+import { TerminalCloseRequests } from "./close-requests.js";
+/** Session and occurrence lookup, independent tab and terminal identities and background cleanup. */
+export class ClientTerminals extends Service {
+    remote;
+    /** Failed cleanup tasks; successful and in-progress closes have no visible notification. */
+    closeFailures = createSnapshotStore([]);
+    requests = new TerminalCloseRequests();
+    closing = new Map();
+    closed = new Set(this.requests.pending().map(request => request.id));
+    disposed = false;
+    views = new Map();
+    /**
+     * @param ctx - Client root Context with Gateway and terminal Remote namespace.
+     * @param remote - generated terminal namespace.
+     */
+    constructor(ctx, remote) {
+        super(ctx, 'webTerminals');
+        this.remote = remote;
+        ctx.effect(() => async () => {
+            this.disposed = true;
+            const detaching = [...this.views.values()].flatMap(views => [...views.values()].map(view => view.dispose()));
+            this.views.clear();
+            await Promise.all([...detaching, ...this.closing.values()]);
+        }, 'terminal-controller.client.views');
+        for (const request of this.requests.pending())
+            this.cleanup(request);
+    }
+    /**
+     * Return the stable model for one sidebar occurrence.
+     * @param sessionId - owning Session.
+     * @param key - sidebar occurrence key.
+     * @param terminalId - existing Host identity when restoring a listed terminal.
+     * @param shellPath - explicit shell for a new terminal; restored terminals retain their own shell.
+     * @returns its observable state and terminal commands.
+     */
+    view(sessionId, key, terminalId, shellPath) {
+        let views = this.views.get(sessionId);
+        if (views === undefined) {
+            views = new Map();
+            this.views.set(sessionId, views);
+        }
+        let view = views.get(key);
+        if (view === undefined) {
+            const id = terminalId ?? randomUUID();
+            view = new TerminalView(sessionId, this.remote, this.ctx.remote, id, terminalId === undefined, shellPath);
+            views.set(key, view);
+            void view.refresh();
+        }
+        return view;
+    }
+    /**
+     * Discover available launch choices on demand without allocating a PTY.
+     * @param sessionId - target Session.
+     * @param signal - the menu request lifetime.
+     * @returns installed shells and the currently usable browser preference.
+     */
+    async launchShells(sessionId, signal) {
+        const result = await this.remote.shells(sessionId, signal);
+        if (!result.ok)
+            throw new Error(result.error.message);
+        const previous = preferredShell();
+        return { shells: result.value, selectedShell: result.value.find(shell => shell.path === previous)?.path ?? result.value[0]?.path };
+    }
+    /**
+     * Remember the guide selection before allocating its terminal tab.
+     * @param path - shell selected from Host discovery.
+     */
+    selectShell(path) { rememberShell(path); }
+    /**
+     * Save a close intent and release the tab immediately; cleanup outlives DOM unmount and reload.
+     * @param sessionId - owning Session.
+     * @param key - sidebar occurrence key, including an inactive restored tab.
+     * @param terminalId - restored identity if the tab has no model yet.
+     */
+    close(sessionId, key, terminalId) {
+        const views = this.views.get(sessionId);
+        const view = views?.get(key);
+        const id = view?.id ?? terminalId;
+        if (id === undefined)
+            return;
+        const request = { sessionId, id, title: view?.state.getSnapshot().title ?? key };
+        this.closed.add(id);
+        this.requests.save(request);
+        views?.delete(key);
+        if (views?.size === 0)
+            this.views.delete(sessionId);
+        this.cleanup(request, view);
+    }
+    /**
+     * Query Host terminals that have neither a tab in this page nor an unfinished close.
+     * @param sessionId - Session being displayed.
+     * @returns terminals available for opening as recovered tabs.
+     */
+    async recover(sessionId) {
+        const result = await this.remote.list(sessionId);
+        if (!result.ok)
+            throw new Error(result.error.message);
+        const held = new Set([...(this.views.get(sessionId)?.values() ?? [])].map(view => view.id));
+        const closing = new Set(this.requests.pending().map(request => request.id));
+        return result.value.filter(info => !held.has(info.id) && !closing.has(info.id) && !this.closed.has(info.id));
+    }
+    /**
+     * Retry a saved close request without reopening its tab.
+     * @param id - failed terminal identity.
+     */
+    retryClose(id) {
+        const record = this.requests.pending().find(item => item.id === id);
+        if (record !== undefined)
+            this.cleanup(record);
+    }
+    cleanup(record, view) {
+        if (this.closing.has(record.id) || this.disposed)
+            return;
+        this.closeFailures.set(this.closeFailures.getSnapshot().filter(failure => failure.id !== record.id));
+        const pending = (async () => {
+            if (view !== undefined)
+                await view.close();
+            else {
+                const result = await this.remote.close(record.sessionId, record.id);
+                if (!result.ok)
+                    throw result.error;
+            }
+            this.requests.remove(record.id);
+        })().catch((error) => {
+            if (remoteErrorOf(error)?.code === 'session/not-found') {
+                this.requests.remove(record.id);
+                return;
+            }
+            if (!this.disposed)
+                this.closeFailures.set([...this.closeFailures.getSnapshot(), {
+                        id: record.id, title: record.title,
+                        message: error instanceof Error ? error.message : String(error),
+                    }]);
+        }).then(async () => {
+            await view?.dispose();
+            this.closing.delete(record.id);
+        });
+        this.closing.set(record.id, pending);
+    }
+}
+/** Required Client transport and terminal namespace. */
+export const inject = ['remote', 'remote.terminal'];
+/**
+ * Install the Client terminal models.
+ * @param ctx - Client root Context.
+ */
+export function apply(ctx) {
+    new ClientTerminals(ctx, ctx.remote.terminal);
+}
+//# sourceMappingURL=index.js.map

package/lib/types/client/model.d.ts

@@ -0,0 +1,119 @@
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import { type ClientRemote } from '@deepseek-ai/dsh-api-gateway/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { TerminalEnvironment, TerminalFrame, WebTerminalId, WebTerminalInfo } from '../types.ts';
+/** The generated terminal namespace's browser-facing operations. */
+export type TerminalRemote = ClientRemote['terminal'];
+/** Product error identifiers translated by the terminal UI. */
+export type TerminalViewIssue = 'missingTerminal' | 'inputFull' | 'attachmentEnded' | 'invalidOutput' | 'terminalLimit';
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        /** Client terminal failure preserved through the Remote stream supervisor. */
+        'terminal/view': {
+            readonly issue: TerminalViewIssue;
+        };
+    }
+}
+/** One screen write awaiting the DOM emulator's callback. */
+export interface TerminalRenderFrame {
+    readonly revision: number;
+    readonly frame: Extract<TerminalFrame, {
+        type: 'snapshot' | 'output';
+    }>;
+}
+/** Observable state of one sidebar occurrence. */
+export interface TerminalViewState {
+    readonly phase: 'idle' | 'loading' | 'creating' | 'connecting' | 'connected' | 'disconnected' | 'closing' | 'closed' | 'failed';
+    readonly environment?: TerminalEnvironment | undefined;
+    readonly title?: string | undefined;
+    readonly info?: WebTerminalInfo | undefined;
+    readonly writable: boolean;
+    readonly render?: TerminalRenderFrame | undefined;
+    readonly error?: string | undefined;
+    readonly issue?: TerminalViewIssue | undefined;
+}
+/** A view survives DOM unmount; its process only ends on explicit close. */
+export declare class TerminalView {
+    private readonly sessionId;
+    private readonly remote;
+    private readonly gateway;
+    readonly id: WebTerminalId;
+    private readonly createWhenMissing;
+    private readonly shellPath?;
+    /** Observable controls, process metadata and the next screen update awaiting acknowledgement. */
+    readonly state: SnapshotStore<TerminalViewState>;
+    private readonly lifetime;
+    private stream;
+    private mounted;
+    private attachmentId;
+    private pendingRender;
+    private revision;
+    private creation;
+    private loading;
+    private closing;
+    private writes;
+    private queuedInput;
+    private readonly detaching;
+    /**
+     * @param sessionId - Session owning the terminal.
+     * @param remote - typed terminal Remote operations.
+     * @param gateway - reconnecting stream factory.
+     * @param id - Host terminal identity, reused when recovering an item from its Session list.
+     * @param createWhenMissing - allow allocation only for a new tab, never a listed terminal.
+     * @param shellPath - explicit shell chosen at the guide; omission uses the remembered available shell.
+     */
+    constructor(sessionId: SessionId, remote: TerminalRemote, gateway: Pick<ClientRemote, '$stream'>, id: WebTerminalId, createWhenMissing?: boolean, shellPath?: string | undefined);
+    /**
+     * Attach the DOM lifetime, starting the chosen shell or reconnecting the saved process.
+     * @returns a detach callback that leaves the terminal process alive.
+     */
+    mount(): () => void;
+    /**
+     * Start or recover this tab, deduplicating mounts and retries during allocation.
+     * Only a new tab may allocate a shell; listed terminals cannot be silently replaced.
+     * @returns after environment lookup and creation or recovery settle.
+     */
+    refresh(): Promise<void>;
+    private stopped;
+    private create;
+    private adopt;
+    /** Reattach with a fresh screen and regain input control. */
+    connect(): void;
+    /**
+     * Release the next stream item after xterm has parsed this frame.
+     * @param revision - locally delivered render revision.
+     */
+    acknowledge(revision: number): void;
+    /**
+     * Serialize raw input so concurrent RPC requests cannot reorder keystrokes.
+     * @param data - input from the terminal emulator.
+     */
+    write(data: string): void;
+    /**
+     * Resize only from the currently writable view.
+     * @param cols - measured column count.
+     * @param rows - measured row count.
+     */
+    resize(cols: number, rows: number): void;
+    /**
+     * Update the Host terminal's display name.
+     * @param title - user-entered terminal title.
+     * @returns after the rename settles and its result is reflected in view state.
+     */
+    rename(title: string): Promise<void>;
+    /**
+     * Explicitly terminate this view's process independently of its DOM lifetime.
+     * @returns after Host process cleanup succeeds; failures remain retryable by the owner.
+     */
+    close(): Promise<void>;
+    /**
+     * Stop Client work on plugin unload without closing Host terminals.
+     * @returns after active and previously detached stream iterators have closed.
+     */
+    dispose(): Promise<void>;
+    private detach;
+    private consume;
+    private patch;
+    private fail;
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/types/client/model.js

@@ -0,0 +1,323 @@
+/** React-free browser terminal state and reconnecting Remote-stream ownership. */
+import { preferredShell, rememberShell } from "./shell-preference.js";
+import { randomUUID } from '@deepseek-ai/dsh-util-crypto';
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-store';
+import { RemoteStreamCarrierError } from '@deepseek-ai/dsh-api-gateway/client';
+import { RemoteError, remoteErrorOf } from '@deepseek-ai/dsh-typert-protocol';
+class TerminalViewError extends RemoteError {
+    constructor(issue, message = issue) { super('terminal/view', message, { issue }); }
+}
+/** A view survives DOM unmount; its process only ends on explicit close. */
+export class TerminalView {
+    sessionId;
+    remote;
+    gateway;
+    id;
+    createWhenMissing;
+    shellPath;
+    /** Observable controls, process metadata and the next screen update awaiting acknowledgement. */
+    state = createSnapshotStore({ phase: 'idle', writable: false });
+    lifetime = new AbortController();
+    stream;
+    mounted = false;
+    attachmentId;
+    pendingRender;
+    revision = 0;
+    creation;
+    loading;
+    closing;
+    writes = Promise.resolve();
+    queuedInput = 0;
+    detaching = new Set();
+    /**
+     * @param sessionId - Session owning the terminal.
+     * @param remote - typed terminal Remote operations.
+     * @param gateway - reconnecting stream factory.
+     * @param id - Host terminal identity, reused when recovering an item from its Session list.
+     * @param createWhenMissing - allow allocation only for a new tab, never a listed terminal.
+     * @param shellPath - explicit shell chosen at the guide; omission uses the remembered available shell.
+     */
+    constructor(sessionId, remote, gateway, id, createWhenMissing = true, shellPath) {
+        this.sessionId = sessionId;
+        this.remote = remote;
+        this.gateway = gateway;
+        this.id = id;
+        this.createWhenMissing = createWhenMissing;
+        this.shellPath = shellPath;
+    }
+    /**
+     * Attach the DOM lifetime, starting the chosen shell or reconnecting the saved process.
+     * @returns a detach callback that leaves the terminal process alive.
+     */
+    mount() {
+        this.mounted = true;
+        if (this.state.getSnapshot().info === undefined)
+            void this.refresh();
+        else
+            this.connect();
+        return () => {
+            this.mounted = false;
+            this.detach();
+        };
+    }
+    /**
+     * Start or recover this tab, deduplicating mounts and retries during allocation.
+     * Only a new tab may allocate a shell; listed terminals cannot be silently replaced.
+     * @returns after environment lookup and creation or recovery settle.
+     */
+    refresh() {
+        if (this.creation !== undefined)
+            return this.creation;
+        if (this.loading !== undefined)
+            return this.loading;
+        if (this.closing !== undefined || this.lifetime.signal.aborted)
+            return Promise.resolve();
+        this.patch({ phase: 'loading', error: undefined, issue: undefined });
+        this.loading = (async () => {
+            const [environment, available] = await Promise.all([
+                this.remote.environment(this.sessionId, this.lifetime.signal), this.remote.list(this.sessionId),
+            ]);
+            if (this.stopped())
+                return;
+            this.patch({ environment: valueOf(environment) });
+            const info = valueOf(available).find(item => item.id === this.id);
+            if (info !== undefined)
+                this.adopt(info);
+            else if (this.createWhenMissing) {
+                let path = this.shellPath;
+                if (path === undefined) {
+                    const shells = valueOf(await this.remote.shells(this.sessionId, this.lifetime.signal));
+                    const previous = preferredShell();
+                    path = shells.find(shell => shell.path === previous)?.path ?? shells[0]?.path;
+                }
+                if (this.stopped())
+                    return;
+                if (path !== undefined)
+                    rememberShell(path);
+                await this.create(valueOf(environment), path);
+            }
+            else
+                throw new TerminalViewError('missingTerminal');
+        })().catch((error) => { this.fail(error); }).finally(() => { this.loading = undefined; });
+        return this.loading;
+    }
+    stopped() { return this.lifetime.signal.aborted || this.closing !== undefined; }
+    async create(environment, shellPath) {
+        this.patch({ phase: 'creating', error: undefined, issue: undefined });
+        this.creation = (async () => {
+            const info = valueOf(await this.remote.create(this.sessionId, {
+                id: this.id, ...shellPath === undefined ? {} : { shellPath },
+                cols: Math.min(80, environment.maxCols), rows: Math.min(24, environment.maxRows),
+            }, this.lifetime.signal));
+            if (!this.lifetime.signal.aborted) {
+                this.adopt(info);
+            }
+        })().catch((error) => { this.fail(error); }).finally(() => { this.creation = undefined; });
+        await this.creation;
+    }
+    adopt(info) {
+        this.patch({ info, title: info.title });
+        if (this.mounted && this.closing === undefined)
+            this.connect();
+    }
+    /** Reattach with a fresh screen and regain input control. */
+    connect() {
+        const info = this.state.getSnapshot().info;
+        if (info === undefined || !this.mounted || this.closing !== undefined || this.lifetime.signal.aborted)
+            return;
+        this.detach();
+        const stream = this.gateway.$stream({
+            name: 'Browser terminal output',
+            open: (signal) => {
+                const attachmentId = randomUUID();
+                this.attachmentId = attachmentId;
+                return this.remote.follow(this.sessionId, info.id, attachmentId, signal);
+            },
+            ended: () => new TerminalViewError('attachmentEnded'),
+            carrierFailed: () => { if (this.stream === stream)
+                this.patch({ phase: 'disconnected', writable: false }); },
+        });
+        this.stream = stream;
+        this.patch({ phase: 'connecting', writable: false, error: undefined, issue: undefined, render: undefined });
+        void this.consume(stream);
+    }
+    /**
+     * Release the next stream item after xterm has parsed this frame.
+     * @param revision - locally delivered render revision.
+     */
+    acknowledge(revision) {
+        if (this.pendingRender?.revision !== revision)
+            return;
+        this.pendingRender.resolve();
+        this.pendingRender = undefined;
+    }
+    /**
+     * Serialize raw input so concurrent RPC requests cannot reorder keystrokes.
+     * @param data - input from the terminal emulator.
+     */
+    write(data) {
+        const state = this.state.getSnapshot();
+        const attachmentId = this.attachmentId;
+        if (!state.writable || state.info === undefined || attachmentId === undefined)
+            return;
+        const bytes = new TextEncoder().encode(data).byteLength;
+        if (this.queuedInput + bytes > (state.environment?.maxInputBytes ?? 0)) {
+            this.fail(new TerminalViewError('inputFull'));
+            return;
+        }
+        this.queuedInput += bytes;
+        const id = state.info.id;
+        this.writes = this.writes.then(async () => {
+            if (this.attachmentId !== attachmentId || !this.state.getSnapshot().writable)
+                return;
+            valueOf(await this.remote.write(this.sessionId, id, attachmentId, data));
+        }).catch((error) => { if (this.attachmentId === attachmentId)
+            this.fail(error); }).finally(() => { this.queuedInput -= bytes; });
+    }
+    /**
+     * Resize only from the currently writable view.
+     * @param cols - measured column count.
+     * @param rows - measured row count.
+     */
+    resize(cols, rows) {
+        const state = this.state.getSnapshot();
+        const attachmentId = this.attachmentId;
+        if (!state.writable || state.info === undefined || attachmentId === undefined)
+            return;
+        if (state.info.cols === cols && state.info.rows === rows)
+            return;
+        const id = state.info.id;
+        cols = Math.min(cols, state.environment?.maxCols ?? cols);
+        rows = Math.min(rows, state.environment?.maxRows ?? rows);
+        this.writes = this.writes.then(async () => {
+            if (this.attachmentId !== attachmentId || !this.state.getSnapshot().writable)
+                return;
+            valueOf(await this.remote.resize(this.sessionId, id, attachmentId, cols, rows));
+        }).catch((error) => { if (this.attachmentId === attachmentId)
+            this.fail(error); });
+    }
+    /**
+     * Update the Host terminal's display name.
+     * @param title - user-entered terminal title.
+     * @returns after the rename settles and its result is reflected in view state.
+     */
+    async rename(title) {
+        if (title.trim() === this.state.getSnapshot().title || this.lifetime.signal.aborted)
+            return;
+        try {
+            valueOf(await this.remote.rename(this.sessionId, this.id, title));
+            const current = this.state.getSnapshot().info;
+            this.patch({ ...(current === undefined ? {} : { info: { ...current, title: title.trim() } }), title: title.trim() });
+        }
+        catch (error) {
+            this.fail(error);
+        }
+    }
+    /**
+     * Explicitly terminate this view's process independently of its DOM lifetime.
+     * @returns after Host process cleanup succeeds; failures remain retryable by the owner.
+     */
+    close() {
+        if (this.closing !== undefined)
+            return this.closing;
+        this.patch({ phase: 'closing', writable: false, error: undefined, issue: undefined });
+        this.detach();
+        this.closing = (async () => {
+            // Even a refused or lost creation response may leave an allocation to close.
+            await this.creation;
+            valueOf(await this.remote.close(this.sessionId, this.id));
+            this.detach();
+            this.patch({ phase: 'closed', writable: false });
+        })().catch((error) => { this.closing = undefined; this.fail(error); throw error; });
+        return this.closing;
+    }
+    /**
+     * Stop Client work on plugin unload without closing Host terminals.
+     * @returns after active and previously detached stream iterators have closed.
+     */
+    async dispose() {
+        this.mounted = false;
+        this.lifetime.abort();
+        this.detach();
+        await Promise.all(this.detaching);
+    }
+    detach() {
+        const previous = this.stream;
+        this.stream = undefined;
+        this.attachmentId = undefined;
+        this.pendingRender?.resolve();
+        this.pendingRender = undefined;
+        if (previous !== undefined) {
+            const cleanup = previous.dispose().finally(() => { this.detaching.delete(cleanup); });
+            this.detaching.add(cleanup);
+        }
+    }
+    async consume(stream) {
+        let generation = 0;
+        let sequence = 0;
+        try {
+            for await (const item of stream) {
+                if (this.stream !== stream)
+                    return;
+                const frame = item.value;
+                if (generation !== item.generation) {
+                    if (frame.type !== 'snapshot')
+                        throw new TerminalViewError('invalidOutput', 'Terminal output generation is missing its screen snapshot');
+                    generation = item.generation;
+                    sequence = frame.sequence;
+                    item.accept();
+                }
+                else if (frame.type === 'output') {
+                    if (frame.sequence !== sequence + 1)
+                        throw new TerminalViewError('invalidOutput', 'Terminal output sequence has a gap');
+                    sequence = frame.sequence;
+                }
+                else if (frame.type === 'snapshot')
+                    throw new TerminalViewError('invalidOutput', 'Unexpected terminal screen snapshot');
+                if (frame.type !== 'output') {
+                    this.patch({ info: frame.info, title: frame.info.title, phase: 'connected', writable: frame.info.state === 'running' && frame.info.controllerId === this.attachmentId });
+                }
+                if (frame.type !== 'state') {
+                    const revision = ++this.revision;
+                    await new Promise((resolve) => {
+                        this.pendingRender = { revision, resolve };
+                        const aborted = () => { this.acknowledge(revision); };
+                        item.signal.addEventListener('abort', aborted, { once: true });
+                        this.pendingRender.resolve = () => { item.signal.removeEventListener('abort', aborted); resolve(); };
+                        this.patch({ render: { revision, frame } });
+                        if (item.signal.aborted)
+                            aborted();
+                    });
+                }
+            }
+        }
+        catch (error) {
+            if (this.stream === stream) {
+                if (this.state.getSnapshot().info?.state === 'exited')
+                    this.patch({ phase: 'closed', writable: false });
+                else
+                    this.fail(error);
+            }
+        }
+    }
+    patch(patch) {
+        if (this.lifetime.signal.aborted)
+            return;
+        this.state.set({ ...this.state.getSnapshot(), ...patch });
+    }
+    fail(error) {
+        const failure = remoteErrorOf(error);
+        if (failure?.code === 'terminal/control-unavailable') {
+            this.patch({ writable: false, error: undefined, issue: undefined });
+            return;
+        }
+        const issue = failure?.code === 'terminal/view' ? failure.details.issue : failure?.code === 'terminal/limit-reached' ? 'terminalLimit' : undefined;
+        this.patch({ phase: error instanceof RemoteStreamCarrierError ? 'disconnected' : 'failed', writable: false, issue, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+function valueOf(result) {
+    if (!result.ok)
+        throw result.error;
+    return result.value;
+}
+//# sourceMappingURL=model.js.map