pi-ui-extend 0.1.34 → 0.1.36

package/README.md

@@ -160,6 +160,26 @@ Before committing code changes, run:
 npm run check
 ```
 
+### Keeping the bundled extension's SDK pin in sync
+
+Pix bundles the `pi-tools-suite` extension (in `external/pi-tools-suite`), which
+runs inside the Pi host process. Its `@earendil-works/*` peerDependencies must
+match the host Pi SDK version exactly, or npm can resolve a stale copy in the
+suite's own `node_modules` and cause a double-load (e.g. `0.75.4` in the suite
+vs `0.79.4` in the host).
+
+When you bump the Pi SDK in the root `package.json`, re-pin the suite and
+reinstall it:
+
+```bash
+npm run sync:sdk-pin                                          # rewrite suite peerDeps to host version
+cd external/pi-tools-suite && npm install --ignore-scripts    # update suite lockfile/node_modules
+```
+
+`npm run check` runs `npm run sync:sdk-pin:check` first, so a stale pin fails
+the check fast. Use `npm run sync:sdk-pin:check` on its own for a drift-only
+report (non-zero exit on drift).
+
 ## Configuration
 
 Useful environment variables:

package/dist/app/app.d.ts

@@ -66,6 +66,7 @@ export declare class PiUiExtendApp {
     start(): Promise<void>;
     private checkPixUpdateOnStartup;
     private bindCurrentSession;
+    private awaitCurrentSessionExtensions;
     private activateRuntime;
     private createExtensionEventBus;
     private handleTerminalBellAttention;

package/dist/app/app.js

@@ -166,12 +166,13 @@ export class PiUiExtendApp {
             maxProjectSessions: () => this.pixConfig.maxProjectSessions,
             blinkController: this.blinkController,
             runtime: () => this.runtime,
-            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options)),
+            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options), this.runtime === undefined ? {} : { reuseServicesFrom: this.runtime }),
             createRuntimeForSession: (sessionPath) => this.createRuntime({
                 ...this.options,
                 noSession: false,
                 sessionPath,
             }),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             activateRuntime: (runtime, options) => this.activateRuntime(runtime, options),
             disposeRuntime: (runtime) => this.terminalController.disposeRuntime(runtime),
             isRunning: () => this.running,
@@ -317,6 +318,7 @@ export class PiUiExtendApp {
             isRunning: () => this.running,
             getInput: () => this.input,
             setInput: (value) => this.setInput(value),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             resetSessionView: () => this.resetSessionView(),
             loadSessionHistory: () => this.loadSessionHistory(),
             afterSessionReplacement: (message) => this.afterSessionReplacement(message),
@@ -334,12 +336,14 @@ export class PiUiExtendApp {
         });
         this.todoWidgetController = new AppTodoWidgetController({
             sessionFile: () => this.runtime?.session.sessionFile,
+            sessionId: () => this.runtime?.session.sessionId,
             isRunning: () => this.running,
             render: () => this.scheduleRender(),
         });
         this.workspaceActions = new AppWorkspaceActionsController({
             entries: this.entries,
             runtime: () => this.runtime,
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             findUserEntry: (entryId) => this.findUserEntry(entryId),
             touchEntry: (entry) => this.touchEntry(entry),
             resetSessionView: () => this.resetSessionView(),
@@ -470,6 +474,7 @@ export class PiUiExtendApp {
             showMenu: (items, options) => this.popupMenus.menuController.show(items, options),
             getModelMenuItems: (query) => this.menuItems.getModelMenuItems(query),
             getThinkingMenuItems: (query) => this.menuItems.getThinkingMenuItems(query),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             modelRef: (model) => this.menuItems.modelRef(model),
             getFavoriteScopedModels: () => this.menuItems.getFavoriteScopedModels(),
             setSessionStatus: (session) => this.setSessionStatus(session),
@@ -518,6 +523,7 @@ export class PiUiExtendApp {
             showToast: (message, kind) => this.showToast(message, kind),
             render: () => this.render(),
             resetSessionView: () => this.resetSessionView(),
+            awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
             bindCurrentSession: () => this.bindCurrentSession(),
             loadSessionHistory: () => this.loadSessionHistory(),
             scrollToConversationEntry: (entryId) => this.scrollController.scrollToConversationEntry(entryId),
@@ -761,10 +767,11 @@ export class PiUiExtendApp {
         });
         this.slashCommands = this.commandController.slashCommands;
     }
-    createRuntime(options) {
+    createRuntime(options, runtimeOptions = {}) {
         return createPixRuntime(options, {
             eventBus: this.createExtensionEventBus(),
             config: this.pixConfig,
+            ...runtimeOptions,
         });
     }
     async loadStartupConfig() {
@@ -822,6 +829,9 @@ export class PiUiExtendApp {
     async bindCurrentSession(options) {
         await this.sessionLifecycle.bindCurrentSession(options);
     }
+    async awaitCurrentSessionExtensions(runtime) {
+        await this.sessionLifecycle.awaitCurrentSessionExtensions(runtime);
+    }
     async activateRuntime(runtime, options) {
         this.runtime = runtime;
         runtime.setRebindSession(async () => {

package/dist/app/commands/command-host.d.ts

@@ -7,6 +7,7 @@ export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type CommandControllerHost = {
     readonly options: AppOptions;
     runtime(): AgentSessionRuntime | undefined;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     requestHistory(): AppRequestHistory;
     getInput(): string;
     setInput(value: string): void;

package/dist/app/commands/command-model-actions.d.ts

@@ -14,6 +14,7 @@ export declare class ModelCommandActions {
     runModelCommand(model: SessionModel): Promise<void>;
     runThinkingCommand(level: ThinkingLevel): Promise<void>;
     private addPersistentSystemEntry;
+    private reloadAfterModelChange;
     private saveDefaultModel;
     private saveDefaultThinking;
 }

package/dist/app/commands/command-model-actions.js

@@ -269,6 +269,17 @@ export class ModelCommandActions {
         this.host.render();
         await runtime.session.setModel(model);
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected model ${ref}` });
+        if (runtime.session.isStreaming) {
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: "Skipped reload because the agent is still running. Run /reload when idle to refresh model-specific tools.",
+            });
+            this.host.toast.warning("Model changed; reload skipped while the agent is running");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        await this.reloadAfterModelChange(runtime.session, ref);
         this.host.setSessionStatus(runtime.session);
     }
     async runThinkingCommand(level) {
@@ -285,6 +296,27 @@ export class ModelCommandActions {
         appendPixSystemDisplayEntry(session, text);
         this.host.addEntry({ id: createId("system"), kind: "system", text });
     }
+    async reloadAfterModelChange(session, ref) {
+        this.host.setStatus(`reloading resources for ${ref}`);
+        this.host.render();
+        try {
+            await session.reload();
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Reloaded resources after model change to ${ref}`,
+            });
+            this.host.toast.success("Model changed and resources reloaded");
+        }
+        catch (error) {
+            this.host.addEntry({
+                id: createId("error"),
+                kind: "error",
+                text: `Model changed to ${ref}, but reload failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            this.host.toast.error("Model changed, but reload failed");
+        }
+    }
     saveDefaultModel(modelRef) {
         const saved = savePixDefaultModel(modelRef);
         if (!saved)

package/dist/app/commands/command-navigation-actions.js

@@ -50,6 +50,7 @@ export class NavigationCommandActions {
             throw new Error("No user messages to fork from");
         this.host.setStatus("forking session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.fork(entryId);
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
@@ -74,6 +75,7 @@ export class NavigationCommandActions {
         }
         this.host.setStatus("cloning session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.fork(leafId, { position: "at" });
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Clone cancelled." });
@@ -228,6 +230,7 @@ export class NavigationCommandActions {
         const resolvedSessionPath = resolve(runtime.cwd, sessionPath);
         this.host.setStatus("switching session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.switchSession(resolvedSessionPath);
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });

package/dist/app/commands/command-session-actions.js

@@ -260,6 +260,7 @@ export class SessionCommandActions {
         this.host.setStatus("reloading");
         this.host.render();
         try {
+            await this.host.awaitCurrentSessionExtensions(runtime);
             await runtime.session.reload();
             this.host.setSessionStatus(runtime.session);
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Reloaded keybindings, extensions, skills, prompts, themes" });
@@ -277,6 +278,7 @@ export class SessionCommandActions {
             return;
         this.host.setStatus("starting new session");
         this.host.render();
+        await this.host.awaitCurrentSessionExtensions(runtime);
         const result = await runtime.newSession();
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });

package/dist/app/constants.d.ts

@@ -19,7 +19,8 @@ export declare const REQUEST_HISTORY_VERSION = 1;
 export declare const REQUEST_HISTORY_MAX_ENTRIES = 200;
 export declare const REQUEST_HISTORY_MAX_BYTES: number;
 export declare const REQUEST_HISTORY_MAX_ENTRY_BYTES: number;
-export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[>4;2m";
+export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[?u\u001B[c";
+export declare const ENABLE_TERMINAL_MODIFY_OTHER_KEYS = "\u001B[>4;2m";
 export declare const DISABLE_TERMINAL_KEY_REPORTING = "\u001B[<u\u001B[>4;0m";
 export declare const ENABLE_BRACKETED_PASTE = "\u001B[?2004h";
 export declare const DISABLE_BRACKETED_PASTE = "\u001B[?2004l";

package/dist/app/constants.js

@@ -52,7 +52,12 @@ export const REQUEST_HISTORY_VERSION = 1;
 export const REQUEST_HISTORY_MAX_ENTRIES = 200;
 export const REQUEST_HISTORY_MAX_BYTES = 128 * 1024;
 export const REQUEST_HISTORY_MAX_ENTRY_BYTES = 16 * 1024;
-export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[>4;2m";
+// Match pi/@earendil-works/pi-tui keyboard setup: request Kitty keyboard
+// protocol flags, query the terminal response, and use xterm modifyOtherKeys
+// only as a response-driven fallback. Enabling both protocols blindly can make
+// terminals disagree about modified Enter reporting.
+export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[?u\x1b[c";
+export const ENABLE_TERMINAL_MODIFY_OTHER_KEYS = "\x1b[>4;2m";
 export const DISABLE_TERMINAL_KEY_REPORTING = "\x1b[<u\x1b[>4;0m";
 export const ENABLE_BRACKETED_PASTE = "\x1b[?2004h";
 export const DISABLE_BRACKETED_PASTE = "\x1b[?2004l";

package/dist/app/extensions/extension-actions-controller.d.ts

@@ -4,6 +4,7 @@ export type AppExtensionActionsHost = {
     isRunning(): boolean;
     getInput(): string;
     setInput(value: string): void;
+    awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
     resetSessionView(): void;
     loadSessionHistory(): void;
     afterSessionReplacement(message?: string): void;

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

@@ -8,12 +8,14 @@ export class AppExtensionActionsController {
         return {
             waitForIdle: () => this.waitForSessionIdle(runtime),
             newSession: async (options) => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 const result = await runtime.newSession(options);
                 if (!result.cancelled)
                     this.host.afterSessionReplacement("Started a new session.");
                 return result;
             },
             fork: async (entryId, options) => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 const result = await runtime.fork(entryId, options);
                 if (!result.cancelled)
                     this.host.afterSessionReplacement("Forked to a new session.");
@@ -32,12 +34,14 @@ export class AppExtensionActionsController {
                 return result;
             },
             switchSession: async (sessionPath, options) => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 const result = await runtime.switchSession(sessionPath, options);
                 if (!result.cancelled)
                     this.host.afterSessionReplacement(`Switched session: ${sessionPath}`);
                 return result;
             },
             reload: async () => {
+                await this.host.awaitCurrentSessionExtensions(runtime);
                 await runtime.session.reload();
                 this.host.setSessionStatus(runtime.session);
                 this.host.showToast("Reloaded resources", "success");

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

@@ -35,7 +35,7 @@ export declare class AppInputController {
     private readonly pasteHandler;
     constructor(host: InputControllerHost);
     handleChunk(chunk: Buffer): void;
-    private consumeSharedEditorShiftEnter;
+    private consumeSharedEditorInput;
     private drainInputBuffer;
     private consumeBracketedPastePayload;
     private getEscapeSequences;
@@ -45,6 +45,10 @@ export declare class AppInputController {
     private consumeCommandArrowPageSequence;
     private consumeCommandArrowPageMatch;
     private consumeTerminalEditShortcutSequence;
+    private consumeIgnoredModifiedKeySequence;
+    private consumeModifiedArrowKeySequence;
+    private consumeClipboardImagePasteSequence;
+    private consumeShiftEnterSequence;
     private consumeTerminalInterruptSequence;
     private handleArrowUp;
     private handleArrowDown;

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

@@ -1,6 +1,7 @@
 import { InputPasteHandler } from "./input-paste-handler.js";
 import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
-import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, terminalEditShortcutForControlChar } from "./terminal-edit-shortcuts.js";
+import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalKeyArrowDirection, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
+const SHIFT_ENTER_ESCAPE_SEQUENCES = ["\x1b\r", "\x1b\n"];
 export class AppInputController {
     host;
     inputBuffer = "";
@@ -16,7 +17,7 @@ export class AppInputController {
             this.drainInputBuffer();
             return;
         }
-        if (this.consumeSharedEditorShiftEnter(data))
+        if (this.consumeSharedEditorInput(data))
             return;
         const extensionInput = this.host.handleExtensionTerminalInput(data);
         if (extensionInput.consume)
@@ -28,17 +29,41 @@ export class AppInputController {
         this.inputBuffer += data;
         this.drainInputBuffer();
     }
-    consumeSharedEditorShiftEnter(data) {
+    consumeSharedEditorInput(data) {
         if (this.host.extensionInputUsesEditor?.() !== true)
             return false;
         if (this.host.inputEditor.isInBracketedPaste)
             return false;
-        if (!this.isShiftPressed())
-            return false;
-        if (data !== "\r" && data !== "\n")
+        if (data === "\n") {
+            this.insertInputNewline();
+            return true;
+        }
+        if (data === "\r" && this.isShiftPressed()) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (SHIFT_ENTER_ESCAPE_SEQUENCES.includes(data)) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (data === "\x16") {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return true;
+        }
+        const modifiedKey = parseTerminalModifiedKeySequence(data);
+        if (modifiedKey.kind !== "key")
             return false;
-        this.insertInputNewline();
-        return true;
+        if (terminalKeyShouldIgnore(modifiedKey.key))
+            return true;
+        if (terminalKeyIsShiftEnter(modifiedKey.key)) {
+            this.insertInputNewline();
+            return true;
+        }
+        if (terminalKeyIsClipboardImagePaste(modifiedKey.key)) {
+            void this.pasteHandler.handleClipboardImagePaste();
+            return true;
+        }
+        return false;
     }
     drainInputBuffer() {
         while (this.inputBuffer.length > 0) {
@@ -72,11 +97,31 @@ export class AppInputController {
                 continue;
             if (terminalInterruptSequence === "pending")
                 return;
+            const shiftEnterSequence = this.consumeShiftEnterSequence();
+            if (shiftEnterSequence === "consumed")
+                continue;
+            if (shiftEnterSequence === "pending")
+                return;
+            const clipboardImagePasteSequence = this.consumeClipboardImagePasteSequence();
+            if (clipboardImagePasteSequence === "consumed")
+                continue;
+            if (clipboardImagePasteSequence === "pending")
+                return;
             const terminalEditShortcutSequence = this.consumeTerminalEditShortcutSequence();
             if (terminalEditShortcutSequence === "consumed")
                 continue;
             if (terminalEditShortcutSequence === "pending")
                 return;
+            const modifiedArrowKeySequence = this.consumeModifiedArrowKeySequence();
+            if (modifiedArrowKeySequence === "consumed")
+                continue;
+            if (modifiedArrowKeySequence === "pending")
+                return;
+            const ignoredModifiedKeySequence = this.consumeIgnoredModifiedKeySequence();
+            if (ignoredModifiedKeySequence === "consumed")
+                continue;
+            if (ignoredModifiedKeySequence === "pending")
+                return;
             if (this.consumeEscapeSequence())
                 continue;
             if (this.isPendingEscapeSequence())
@@ -106,13 +151,9 @@ export class AppInputController {
     }
     getEscapeSequences() {
         return [
-            ["\x1b[13;2u", () => this.insertInputNewline()],
-            ["\x1b[13;2~", () => this.insertInputNewline()],
-            ["\x1b[27;2;13~", () => this.insertInputNewline()],
+            ...SHIFT_ENTER_ESCAPE_SEQUENCES.map((sequence) => [sequence, () => this.insertInputNewline()]),
             ["\x1b[13u", () => this.host.handleEnter()],
             ["\x1b[13;1u", () => this.host.handleEnter()],
-            ["\x1b\r", () => this.insertInputNewline()],
-            ["\x1b\n", () => this.insertInputNewline()],
             ["\x1b[5~", () => this.host.scrollByPage(-1)],
             ["\x1b[6~", () => this.host.scrollByPage(1)],
             ["\x1b[A", () => this.handleArrowUp()],
@@ -139,8 +180,6 @@ export class AppInputController {
             ["\x1b[201~", () => this.pasteHandler.endBracketedPaste()],
             ["\x1b[1;2H", () => { this.host.inputEditor.moveToLineStartExtend(); this.host.render(); }],
             ["\x1b[1;2F", () => { this.host.inputEditor.moveToLineEndExtend(); this.host.render(); }],
-            ["\x1b[118;5u", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
-            ["\x1b[27;5;118~", () => { void this.pasteHandler.handleClipboardImagePaste(); }],
             ["\x1b[122;9u", () => this.undoInput()],
             ["\x1b[27;9;122~", () => this.undoInput()],
             ["\x1b[90;10u", () => this.redoInput()],
@@ -232,6 +271,65 @@ export class AppInputController {
         }
         return "consumed";
     }
+    consumeIgnoredModifiedKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyShouldIgnore(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        return "consumed";
+    }
+    consumeModifiedArrowKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        const direction = terminalKeyArrowDirection(result.key);
+        if (!direction)
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (terminalKeyShouldIgnore(result.key))
+            return "consumed";
+        if (direction === "up")
+            this.handleArrowUp();
+        else if (direction === "down")
+            this.handleArrowDown();
+        else if (direction === "right")
+            this.handleArrowRight();
+        else
+            this.handleArrowLeft();
+        return "consumed";
+    }
+    consumeClipboardImagePasteSequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsClipboardImagePaste(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            void this.pasteHandler.handleClipboardImagePaste();
+        return "consumed";
+    }
+    consumeShiftEnterSequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsShiftEnter(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            this.insertInputNewline();
+        return "consumed";
+    }
     consumeTerminalInterruptSequence() {
         const result = parseTerminalInterruptSequence(this.inputBuffer);
         if (result.kind === "pending")
@@ -401,7 +499,15 @@ export class AppInputController {
             this.host.toggleVoiceRecording();
             return;
         }
-        if (char === "\r" || char === "\n") {
+        if (char === "\n") {
+            if (this.host.inputEditor.isInBracketedPaste) {
+                this.pasteHandler.appendBracketedPasteText("\n");
+                return;
+            }
+            this.insertInputNewline();
+            return;
+        }
+        if (char === "\r") {
             if (this.host.inputEditor.isInBracketedPaste) {
                 this.pasteHandler.appendBracketedPasteText("\n");
                 return;

package/dist/app/input/input-paste-handler.js

@@ -92,8 +92,10 @@ export class InputPasteHandler {
         return false;
     }
     handlePasteEnd(text) {
-        if (!text)
+        if (!text) {
+            void this.handleClipboardImagePaste();
             return;
+        }
         const filePath = this.plainPasteFilePath(text);
         if (filePath) {
             if (isImagePath(filePath) && Date.now() < this.suppressImagePathPasteUntil) {

package/dist/app/input/terminal-edit-shortcuts.d.ts

@@ -1,4 +1,12 @@
 export type TerminalEditShortcut = "undo" | "redo";
+export type ParsedTerminalModifiedKeyResult = {
+    readonly kind: "key";
+    readonly key: ParsedModifiedKey;
+} | {
+    readonly kind: "pending";
+} | {
+    readonly kind: "none";
+};
 export type TerminalEditShortcutSequenceResult = {
     readonly kind: "shortcut";
     readonly shortcut: TerminalEditShortcut;
@@ -11,6 +19,14 @@ export type TerminalEditShortcutSequenceResult = {
 } | {
     readonly kind: "none";
 };
+interface ParsedModifiedKey {
+    readonly codepoint: number;
+    readonly baseLayoutKey: number | undefined;
+    readonly modifier: number;
+    readonly eventType: number | undefined;
+    readonly length: number;
+}
+export declare function parseTerminalModifiedKeySequence(input: string): ParsedTerminalModifiedKeyResult;
 export declare function parseTerminalEditShortcutSequence(input: string): TerminalEditShortcutSequenceResult;
 export declare function parseTerminalInterruptSequence(input: string): {
     readonly kind: "interrupt";
@@ -20,4 +36,9 @@ export declare function parseTerminalInterruptSequence(input: string): {
 } | {
     readonly kind: "none";
 };
+export declare function terminalKeyIsShiftEnter(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyIsClipboardImagePaste(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyShouldIgnore(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyArrowDirection(key: ParsedModifiedKey): "up" | "down" | "right" | "left" | undefined;
 export declare function terminalEditShortcutForControlChar(char: string, shiftPressed: boolean): TerminalEditShortcut | undefined;
+export {};