pi-ui-extend 0.1.70 → 0.1.71

package/dist/app/extensions/extension-ui-controller.js

@@ -75,6 +75,9 @@ export class ExtensionUiController {
             this.extensionWidgets.delete(key);
         }
     }
+    cancelCustomUi(scopeKey = this.activeScopeKey()) {
+        this.cancelActiveCustomUi(this.normalizeScopeKey(scopeKey));
+    }
     suppressWidget(key) {
         const scopedKey = this.scopedWidgetKey(this.activeScopeKey(), key);
         const widget = this.extensionWidgets.get(scopedKey);
@@ -85,7 +88,7 @@ export class ExtensionUiController {
     }
     handleTerminalInput(data) {
         const active = this.activeCustomUiForActiveScope();
-        if (active) {
+        if (active?.component) {
             if (data === "\u0003")
                 return { consume: false };
             try {
@@ -117,7 +120,7 @@ export class ExtensionUiController {
     }
     renderActiveCustomUi(width) {
         const active = this.activeCustomUiForActiveScope();
-        if (!active)
+        if (!active?.component)
             return undefined;
         try {
             return active.component.render(width);
@@ -128,7 +131,7 @@ export class ExtensionUiController {
     }
     activeCustomUiUsesEditor() {
         const active = this.activeCustomUiForActiveScope();
-        if (!active)
+        if (!active?.component)
             return false;
         try {
             return active.component.usesEditor?.() === true;
@@ -139,7 +142,7 @@ export class ExtensionUiController {
     }
     handleCustomUiMouse(event) {
         const active = this.activeCustomUiForActiveScope();
-        if (!active)
+        if (!active?.component)
             return false;
         try {
             return active.component.handleMouse?.(event) === true;
@@ -149,17 +152,18 @@ export class ExtensionUiController {
             return true;
         }
     }
-    widgetTuiHandle() {
-        const activeScopeToastNotifier = this.host.toastNotifierForScope?.(this.activeScopeKey()) ?? this.host.toastNotifier;
+    widgetTuiHandle(scopeKey = this.activeScopeKey()) {
+        const activeScopeToastNotifier = this.host.toastNotifierForScope?.(scopeKey) ?? this.host.toastNotifier;
+        const menuController = this.scopedMenuController(scopeKey);
         return {
             requestRender: () => {
-                if (this.host.isRunning())
+                if (this.host.isRunning() && this.isScopeActive(scopeKey))
                     this.host.render();
             },
             showToast: activeScopeToastNotifier.show,
             toast: activeScopeToastNotifier,
-            showMenu: this.host.menuController.show,
-            menu: this.host.menuController,
+            showMenu: menuController.show,
+            menu: menuController,
             pix: {
                 delegatedEditorInput: true,
                 inputMouse: true,
@@ -173,13 +177,14 @@ export class ExtensionUiController {
             this.host.showToast(message, isToastKind(type) ? type : "info", { scopeKey: contextScopeKey });
         };
         const extensionTheme = this.createExtensionTheme();
+        const menuController = this.scopedMenuController(contextScopeKey);
         const renderIfRunning = () => {
-            if (this.host.isRunning())
+            if (this.host.isRunning() && this.isScopeActive(contextScopeKey))
                 this.host.render();
         };
         return {
-            select: async (title, options, opts) => await this.selectDialog(title, options, opts),
-            confirm: async (title, message, opts) => await this.confirmDialog(title, message, opts),
+            select: async (title, options, opts) => await this.selectDialog(title, options, opts, contextScopeKey),
+            confirm: async (title, message, opts) => await this.confirmDialog(title, message, opts, contextScopeKey),
             input: async (title, placeholder, opts) => await this.inputDialog(title, placeholder, opts, contextScopeKey),
             notify,
             toast: scopedToastNotifier,
@@ -194,8 +199,8 @@ export class ExtensionUiController {
             renderAboveInput: (key, content) => {
                 this.setAboveInputWidget(key, content, contextScopeKey);
             },
-            showMenu: this.host.menuController.show,
-            menu: this.host.menuController,
+            showMenu: menuController.show,
+            menu: menuController,
             onTerminalInput: (handler) => {
                 const terminalInputHandler = { scopeKey: contextScopeKey, handler: handler };
                 this.terminalInputHandlers.add(terminalInputHandler);
@@ -204,12 +209,16 @@ export class ExtensionUiController {
                 };
             },
             setStatus: (_key, text) => {
+                if (!this.isScopeActive(contextScopeKey))
+                    return;
                 if (text)
                     this.host.showToast(text, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
                 renderIfRunning();
             },
             setWorkingMessage: (message) => {
+                if (!this.isScopeActive(contextScopeKey))
+                    return;
                 if (message)
                     this.host.showToast(message, "info", { scopeKey: contextScopeKey });
                 this.host.restoreSessionStatus();
@@ -224,19 +233,25 @@ export class ExtensionUiController {
             setFooter: () => undefined,
             setHeader: () => undefined,
             setTitle: (title) => {
+                if (!this.isScopeActive(contextScopeKey))
+                    return;
                 process.title = title;
                 renderIfRunning();
             },
             custom: (async (factory) => await this.showCustomUi(factory, { scopeKey: contextScopeKey })),
             pasteToEditor: (text) => {
+                if (!this.isScopeActive(contextScopeKey))
+                    return;
                 this.host.setInput(text);
                 renderIfRunning();
             },
             setEditorText: (text) => {
+                if (!this.isScopeActive(contextScopeKey))
+                    return;
                 this.host.setInput(text);
                 renderIfRunning();
             },
-            getEditorText: () => this.host.getInput(),
+            getEditorText: () => this.isScopeActive(contextScopeKey) ? this.host.getInput() : "",
             editor: async (title, prefill) => await this.editorDialog(title, prefill, contextScopeKey),
             addAutocompleteProvider: () => undefined,
             setEditorComponent: () => undefined,
@@ -247,8 +262,10 @@ export class ExtensionUiController {
             getAllThemes: () => Object.keys(THEMES).map((themeName) => ({ name: themeName, path: undefined })),
             getTheme: () => undefined,
             setTheme: () => ({ success: false, error: "Theme switching is not implemented in pix extension UI yet." }),
-            getToolsExpanded: () => this.host.entries.some((entry) => entry.kind === "tool" && entry.expanded),
+            getToolsExpanded: () => this.isScopeActive(contextScopeKey) && this.host.entries.some((entry) => entry.kind === "tool" && entry.expanded),
             setToolsExpanded: (expanded) => {
+                if (!this.isScopeActive(contextScopeKey))
+                    return;
                 for (const entry of this.host.entries) {
                     if (entry.kind === "tool") {
                         entry.expanded = expanded;
@@ -265,21 +282,23 @@ export class ExtensionUiController {
     clearAboveInputWidget(key, scopeKey = this.activeScopeKey()) {
         this.setWidget(key, undefined, { placement: "aboveEditor", scopeKey });
     }
-    async selectDialog(title, options, opts) {
-        if (opts?.signal?.aborted)
+    async selectDialog(title, options, opts, scopeKey = this.activeScopeKey()) {
+        if (opts?.signal?.aborted || !this.isScopeActive(scopeKey))
             return undefined;
         return await this.withDialogAutoDismiss(this.host.menuController.select(title, options, { preserveStatus: true }), opts, () => {
-            this.host.menuController.close();
+            if (this.isScopeActive(scopeKey))
+                this.host.menuController.close();
         });
     }
-    async confirmDialog(title, message, opts) {
-        if (opts?.signal?.aborted)
+    async confirmDialog(title, message, opts, scopeKey = this.activeScopeKey()) {
+        if (opts?.signal?.aborted || !this.isScopeActive(scopeKey))
             return false;
         const selected = await this.withDialogAutoDismiss(this.host.menuController.show([
             { value: true, label: "Yes", description: message },
             { value: false, label: "No" },
         ], { title, searchable: false, preserveStatus: true }), opts, () => {
-            this.host.menuController.close();
+            if (this.isScopeActive(scopeKey))
+                this.host.menuController.close();
         });
         return selected === true;
     }
@@ -306,10 +325,10 @@ export class ExtensionUiController {
             return undefined;
         if (!this.host.isRunning())
             return undefined;
+        if (!this.isScopeActive(scopeKey))
+            return undefined;
         if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
-        const savedInput = this.host.getInput();
-        this.host.setInput(options.initialValue);
         const promise = this.showCustomUi((_tui, _theme, _keybindings, done) => {
             let settled = false;
             const finish = (value) => {
@@ -333,7 +352,7 @@ export class ExtensionUiController {
                     return { consume: false, data };
                 },
             };
-        }, { savedInput, scopeKey });
+        }, { editorInput: options.initialValue, scopeKey });
         return await this.withDialogAutoDismiss(promise, options.opts, () => {
             this.cancelActiveCustomUi(scopeKey);
         });
@@ -375,79 +394,76 @@ export class ExtensionUiController {
         if (!this.host.isRunning())
             return undefined;
         const scopeKey = this.normalizeScopeKey(options.scopeKey);
+        if (!this.isScopeActive(scopeKey))
+            return undefined;
         if (this.activeCustomUis.has(scopeKey))
             throw new Error("Another extension custom UI is already active.");
         const savedInput = options.savedInput ?? this.host.getInput();
         return await new Promise((resolve, reject) => {
-            let settled = false;
+            const active = {
+                key: CUSTOM_UI_WIDGET_KEY,
+                scopeKey,
+                savedInput,
+                settled: false,
+                resolve: (value) => resolve(value),
+                reject,
+            };
+            this.activeCustomUis.set(scopeKey, active);
+            if (options.editorInput !== undefined)
+                this.host.setInput(options.editorInput);
             const done = (value) => {
-                if (settled)
+                if (active.settled || this.activeCustomUis.get(scopeKey) !== active)
                     return;
-                settled = true;
-                this.finishActiveCustomUi(scopeKey, value, { resolve: true });
-                resolve(value);
+                this.finishActiveCustomUi(active, this.isScopeActive(scopeKey) ? value : undefined, { resolve: true });
             };
             void (async () => {
                 try {
-                    const component = await factory(this.widgetTuiHandle(), this.createExtensionTheme(), {}, done);
-                    if (settled) {
+                    const component = await factory(this.widgetTuiHandle(scopeKey), this.createExtensionTheme(), {}, done);
+                    if (active.settled || this.activeCustomUis.get(scopeKey) !== active || !this.isScopeActive(scopeKey)) {
                         component.dispose?.();
+                        if (!active.settled && this.activeCustomUis.get(scopeKey) === active) {
+                            this.finishActiveCustomUi(active, undefined, { resolve: true });
+                        }
                         return;
                     }
-                    this.activeCustomUis.set(scopeKey, {
-                        key: CUSTOM_UI_WIDGET_KEY,
-                        scopeKey,
-                        component,
-                        savedInput,
-                        resolve: (value) => {
-                            if (settled)
-                                return;
-                            settled = true;
-                            resolve(value);
-                        },
-                        reject: (error) => {
-                            if (settled)
-                                return;
-                            settled = true;
-                            reject(error);
-                        },
-                    });
+                    active.component = component;
                     if (this.host.isRunning())
                         this.host.render();
                 }
                 catch (error) {
-                    if (settled)
+                    if (active.settled || this.activeCustomUis.get(scopeKey) !== active)
                         return;
-                    settled = true;
-                    reject(error);
+                    this.finishActiveCustomUi(active, error, { resolve: false });
                 }
             })();
         });
     }
     cancelActiveCustomUi(scopeKey = this.activeScopeKey()) {
-        this.finishActiveCustomUi(scopeKey, undefined, { resolve: true });
+        const active = this.activeCustomUis.get(scopeKey);
+        if (active)
+            this.finishActiveCustomUi(active, undefined, { resolve: true });
     }
     rejectActiveCustomUi(error) {
         const active = this.activeCustomUiForActiveScope();
         if (!active)
             return;
-        this.finishActiveCustomUi(active.scopeKey, error, { resolve: false });
+        this.finishActiveCustomUi(active, error, { resolve: false });
     }
-    finishActiveCustomUi(scopeKey, value, options) {
-        const active = this.activeCustomUis.get(scopeKey);
-        if (!active)
+    finishActiveCustomUi(active, value, options) {
+        if (active.settled || this.activeCustomUis.get(active.scopeKey) !== active)
             return;
-        this.activeCustomUis.delete(scopeKey);
-        if (this.host.getInput() !== active.savedInput)
+        active.settled = true;
+        this.activeCustomUis.delete(active.scopeKey);
+        if (this.isScopeActive(active.scopeKey) && this.host.getInput() !== active.savedInput)
             this.host.setInput(active.savedInput);
         try {
-            active.component.dispose?.();
+            active.component?.dispose?.();
         }
         catch {
             // Ignore extension cleanup failures while closing focused UI.
         }
         try {
-            active.component.invalidate?.();
+            active.component?.invalidate?.();
         }
         catch {
             // Ignore extension invalidation failures while closing focused UI.
@@ -456,11 +472,35 @@ export class ExtensionUiController {
             active.resolve(value);
         else
             active.reject(value);
-        if (this.host.isRunning())
+        if (this.host.isRunning() && this.isScopeActive(active.scopeKey))
             this.host.render();
     }
     activeCustomUiForActiveScope() {
-        return this.activeCustomUis.get(this.activeScopeKey());
+        const scopeKey = this.activeScopeKey();
+        if (!this.isScopeActive(scopeKey))
+            return undefined;
+        return this.activeCustomUis.get(scopeKey);
+    }
+    isScopeActive(scopeKey) {
+        return this.host.isExtensionUiScopeActive?.(scopeKey) ?? this.activeScopeKey() === scopeKey;
+    }
+    scopedMenuController(scopeKey) {
+        return {
+            show: async (items, options) => {
+                if (!this.isScopeActive(scopeKey))
+                    return undefined;
+                return await this.host.menuController.show(items, options);
+            },
+            select: async (title, options, menuOptions) => {
+                if (!this.isScopeActive(scopeKey))
+                    return undefined;
+                return await this.host.menuController.select(title, options, menuOptions);
+            },
+            close: () => {
+                if (this.isScopeActive(scopeKey))
+                    this.host.menuController.close();
+            },
+        };
     }
     activeScopeKey() {
         return this.normalizeScopeKey(this.host.activeExtensionUiScope?.());

package/dist/app/input/input-action-controller.d.ts

@@ -8,6 +8,7 @@ import { type InteractiveShellCommandResult } from "../commands/shell-command.js
 import type { Entry, SessionActivity } from "../types.js";
 export type AppInputActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
+    inputScopeKey?(): string | undefined;
     isRunning(): boolean;
     isSessionSwitching(): boolean;
     inputEditor(): InputEditor;
@@ -35,7 +36,7 @@ export declare class AppInputActionController {
     private readonly popupMenus;
     private readonly popupActions;
     private readonly queuedMessages;
-    private abortInFlight;
+    private readonly abortsInFlight;
     constructor(host: AppInputActionControllerHost, popupMenus: AppPopupMenuController, popupActions: AppPopupActionController, queuedMessages: AppQueuedMessageController);
     handleEnter(): void;
     queueInputFromEditor(): Promise<void>;
@@ -48,4 +49,6 @@ export declare class AppInputActionController {
     private submitInput;
     private submitShellInput;
     private submitShellCommand;
+    private isInputScopeActive;
+    private isSessionScopeActive;
 }

package/dist/app/input/input-action-controller.js

@@ -7,7 +7,7 @@ export class AppInputActionController {
     popupMenus;
     popupActions;
     queuedMessages;
-    abortInFlight = false;
+    abortsInFlight = new Set();
     constructor(host, popupMenus, popupActions, queuedMessages) {
         this.host = host;
         this.popupMenus = popupMenus;
@@ -22,7 +22,10 @@ export class AppInputActionController {
         void this.submitInput();
     }
     async queueInputFromEditor() {
+        const inputScopeKey = this.host.inputScopeKey?.();
         await this.host.stopVoiceInput();
+        if (this.host.inputScopeKey && this.host.inputScopeKey() !== inputScopeKey)
+            return;
         if (this.popupMenus.syncActivePopupMenu())
             this.popupMenus.cancelActivePopupMenu();
         const inputEditor = this.host.inputEditor();
@@ -36,9 +39,8 @@ export class AppInputActionController {
         const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
         this.host.requestHistory().add(message.displayText);
         inputEditor.clear();
-        await this.host.clearPersistedInputDraft();
-        this.host.render();
         this.queuedMessages.deferUserMessage(message);
+        await this.host.clearPersistedInputDraft();
         if (this.host.isRunning())
             this.host.render();
     }
@@ -91,7 +93,7 @@ export class AppInputActionController {
         // Relay the user-initiated abort to extensions (e.g. the terminal-bell
         // extension) so they can suppress the attention bell for this turn.
         this.host.emitSessionAborted();
-        if (this.abortInFlight) {
+        if (this.abortsInFlight.has(session)) {
             session.agent.abort();
             if (options.stopIfAlreadyAborting)
                 await this.host.stop();
@@ -99,13 +101,13 @@ export class AppInputActionController {
                 this.host.render();
             return;
         }
-        this.abortInFlight = true;
+        this.abortsInFlight.add(session);
         this.queuedMessages.restoreQueuedMessagesToEditorForAbort();
         this.host.setStatus("aborting");
         this.host.addSessionAbortedEntry();
         this.host.render();
         let restoreTimer = setTimeout(() => {
-            if (!this.abortInFlight || this.host.runtime()?.session !== session || !this.host.isRunning())
+            if (!this.abortsInFlight.has(session) || this.host.runtime()?.session !== session || !this.host.isRunning())
                 return;
             this.restoreSessionState(session);
             this.host.render();
@@ -116,16 +118,23 @@ export class AppInputActionController {
             await session.abort();
         }
         catch (error) {
-            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            if (this.host.runtime()?.session === session) {
+                this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            }
+            else {
+                this.host.showToast(`Abort failed in a background tab: ${stringifyUnknown(error)}`, "error");
+            }
         }
         finally {
             if (restoreTimer)
                 clearTimeout(restoreTimer);
             restoreTimer = undefined;
-            this.abortInFlight = false;
-            this.restoreSessionState(this.host.runtime()?.session);
-            if (this.host.isRunning())
-                this.host.render();
+            this.abortsInFlight.delete(session);
+            if (this.host.runtime()?.session === session) {
+                this.restoreSessionState(session);
+                if (this.host.isRunning())
+                    this.host.render();
+            }
         }
     }
     restoreSessionState(session) {
@@ -136,7 +145,11 @@ export class AppInputActionController {
         return session?.isStreaming || session?.isCompacting ? "running" : "idle";
     }
     async submitInput() {
+        const inputScopeKey = this.host.inputScopeKey?.();
         await this.host.stopVoiceInput();
+        if (this.host.inputScopeKey && this.host.inputScopeKey() !== inputScopeKey)
+            return;
+        const runtime = this.host.runtime();
         const inputEditor = this.host.inputEditor();
         const rawPromptText = inputEditor.promptText;
         const rawDisplayText = inputEditor.expandedText;
@@ -144,14 +157,14 @@ export class AppInputActionController {
         const displayText = rawDisplayText.trimEnd();
         const images = [...inputEditor.images];
         if (this.host.isShellCommandRunning()) {
-            await this.submitShellInput(rawDisplayText, images.length);
+            await this.submitShellInput(rawDisplayText, images.length, inputScopeKey);
             return;
         }
         if (!promptText && images.length === 0)
             return;
         const shellCommand = bangShellCommandFromInput(promptText);
         if (shellCommand !== undefined) {
-            await this.submitShellCommand(shellCommand.command, displayText, images.length, shellCommand.interactive ? "interactive" : "chat");
+            await this.submitShellCommand(shellCommand.command, displayText, images.length, shellCommand.interactive ? "interactive" : "chat", inputScopeKey);
             return;
         }
         if (this.host.isSessionSwitching()) {
@@ -166,18 +179,24 @@ export class AppInputActionController {
         const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
         this.host.requestHistory().add(message.displayText);
         inputEditor.clear();
-        await this.host.clearPersistedInputDraft();
+        const clearPersistedDraft = this.host.clearPersistedInputDraft();
         this.host.render();
         try {
-            await this.queuedMessages.submitUserMessage(message);
+            await this.queuedMessages.submitUserMessage(message, runtime?.session);
         }
         catch (error) {
-            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            if (!runtime || this.host.runtime() === runtime) {
+                this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            }
+            else {
+                this.host.showToast(`Prompt failed in a background tab: ${stringifyUnknown(error)}`, "error");
+            }
         }
+        await clearPersistedDraft;
         if (this.host.isRunning())
             this.host.render();
     }
-    async submitShellInput(text, imageCount) {
+    async submitShellInput(text, imageCount, inputScopeKey) {
         if (imageCount > 0) {
             this.host.showToast("Shell stdin cannot include pasted images", "warning");
             this.host.render();
@@ -185,12 +204,17 @@ export class AppInputActionController {
         }
         const inputEditor = this.host.inputEditor();
         inputEditor.clear();
-        await this.host.clearPersistedInputDraft();
-        if (!this.host.sendShellInput(text))
+        const clearPersistedDraft = this.host.clearPersistedInputDraft();
+        const sent = this.host.sendShellInput(text);
+        await clearPersistedDraft;
+        if (!this.isInputScopeActive(inputScopeKey))
+            return;
+        if (!sent)
             this.host.showToast("No shell command is waiting for input", "info");
-        this.host.render();
+        if (this.host.isRunning())
+            this.host.render();
     }
-    async submitShellCommand(command, displayText, imageCount, mode) {
+    async submitShellCommand(command, displayText, imageCount, mode, inputScopeKey) {
         if (!command) {
             this.host.showToast(`Enter a shell command after ${mode === "interactive" ? "!!" : "!"}`, "info");
             this.host.render();
@@ -206,7 +230,8 @@ export class AppInputActionController {
             this.host.render();
             return;
         }
-        const session = this.host.runtime()?.session;
+        const runtime = this.host.runtime();
+        const session = runtime?.session;
         if (session?.isStreaming || session?.isCompacting) {
             this.host.showToast("Wait for the current session turn to finish before running shell commands", "info");
             this.host.render();
@@ -215,26 +240,42 @@ export class AppInputActionController {
         const inputEditor = this.host.inputEditor();
         this.host.requestHistory().add(displayText);
         inputEditor.clear();
-        await this.host.clearPersistedInputDraft();
+        const clearPersistedDraft = this.host.clearPersistedInputDraft();
         this.host.setStatus(`shell: ${command}`);
         this.host.render();
         try {
             if (mode === "chat") {
-                await this.host.runChatShellCommand(command);
+                const result = this.host.runChatShellCommand(command);
+                await clearPersistedDraft;
+                await result;
             }
             else {
-                const result = await this.host.runInteractiveShellCommand(command);
+                const runningCommand = this.host.runInteractiveShellCommand(command);
+                await clearPersistedDraft;
+                const result = await runningCommand;
+                if (!this.isSessionScopeActive(runtime, session, inputScopeKey))
+                    return;
                 const entryKind = result.error ? "error" : "system";
                 this.host.addEntry({ id: createId(entryKind), kind: entryKind, text: formatShellCommandEntry(command, result, "!!") });
             }
         }
         catch (error) {
+            await clearPersistedDraft;
+            if (!this.isSessionScopeActive(runtime, session, inputScopeKey))
+                return;
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Shell command failed: ${stringifyUnknown(error)}` });
         }
         finally {
-            this.restoreSessionState(this.host.runtime()?.session);
+            if (this.isSessionScopeActive(runtime, session, inputScopeKey))
+                this.restoreSessionState(session);
         }
-        if (this.host.isRunning())
+        if (this.host.isRunning() && this.isSessionScopeActive(runtime, session, inputScopeKey))
             this.host.render();
     }
+    isInputScopeActive(inputScopeKey) {
+        return !this.host.inputScopeKey || this.host.inputScopeKey() === inputScopeKey;
+    }
+    isSessionScopeActive(runtime, session, inputScopeKey) {
+        return this.isInputScopeActive(inputScopeKey) && this.host.runtime() === runtime && runtime?.session === session;
+    }
 }

package/dist/app/input/input-controller.d.ts

@@ -5,6 +5,7 @@ type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type InputControllerHost = {
     readonly inputEditor: InputEditor;
     readonly cwd: string;
+    inputScopeKey?(): string | undefined;
     handleExtensionTerminalInput(data: string): ExtensionTerminalInputResult;
     extensionInputUsesEditor?(): boolean;
     isShiftPressed?(): boolean;
@@ -32,12 +33,14 @@ export type InputControllerHost = {
 export declare class AppInputController {
     private readonly host;
     private inputBuffer;
+    private readonly inputDecoder;
     private readonly pasteHandler;
     constructor(host: InputControllerHost);
     handleChunk(chunk: Buffer): void;
     private consumeBufferedSharedEditorInput;
     private consumeSharedEditorInput;
     private drainInputBuffer;
+    private consumePrintableRun;
     private consumeBracketedPastePayload;
     private getEscapeSequences;
     private isPendingEscapeSequence;