@jinion/core 0.3.0 → 0.4.0

package/dist/api/protocol.d.ts

@@ -3,11 +3,13 @@ import { z } from 'zod';
 export type { AgentInfo, SessionFeatures } from '../agent/agent.js';
 export type { Attachment, AttachmentKind, AttachmentSource } from '../attachments/types.js';
 export type { AppInfo, PromptFill, RewindPoint, View } from '../controllers/context.js';
-export type { FileChange, GitStatus, RepoChanges } from '../git/types.js';
+export type { Blame, BlameRange, CommitDetail, CommitInfo, FileChange, GitStatus, RepoChanges } from '../git/types.js';
 export type { ClaudeSetup } from '../agent/claude/setup-info.js';
 export type { McpTransport } from '../mcp/transport.js';
-export type { DevScript, DevServer } from '../preview/types.js';
+export type { DevScript, DevServer, PreviewCapture } from '../preview/types.js';
 export type { TerminalInfo, TerminalOutput } from '../terminals/types.js';
+export type * from '../lsp/types.js';
+export type * from '../files/types.js';
 export type * from './schemas.js';
 /**
  * Raised only when a change would break a client written for the one before. Adding a method, a notification or an
@@ -28,6 +30,8 @@ export declare const ApiCode: {
     readonly unknownTerminal: -32008;
     /** The file changed since the client read it, as when the agent edited it; `data.modified` is its time now. */
     readonly fileChanged: -32009;
+    /** A file or folder is already where one was to go; `data.path` is it, in the session's folder. */
+    readonly fileExists: -32010;
 };
 /** Every method the server answers: what a client sends, checked where it comes in, and what it gets back. */
 export declare const requests: {
@@ -42,6 +46,8 @@ export declare const requests: {
                 bell: "bell";
                 desktop: "desktop";
             }>>;
+            preview: z.ZodOptional<z.ZodBoolean>;
+            terminal: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
         result: z.ZodObject<{
             sessions: z.ZodArray<z.ZodObject<{
@@ -65,6 +71,7 @@ export declare const requests: {
                 description: z.ZodString;
                 aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 argumentHint: z.ZodOptional<z.ZodString>;
+                terminalOnly: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
             app: z.ZodObject<{
                 agents: z.ZodArray<z.ZodObject<{
@@ -139,6 +146,7 @@ export declare const requests: {
                     activated: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strip>>>;
                 signals: z.ZodOptional<z.ZodBoolean>;
+                notifications: z.ZodOptional<z.ZodBoolean>;
                 claudeSetupOffered: z.ZodOptional<z.ZodBoolean>;
                 announcements: z.ZodOptional<z.ZodArray<z.ZodObject<{
                     id: z.ZodNumber;
@@ -461,6 +469,7 @@ export declare const requests: {
                     size: z.ZodNumber;
                     reading: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>>;
+                folder: z.ZodOptional<z.ZodString>;
                 wantsWorktree: z.ZodBoolean;
                 working: z.ZodBoolean;
                 ratings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
@@ -797,6 +806,22 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodNull;
     };
+    /**
+     * Takes files of the last `git/changes`, by their absolute paths, back to HEAD, staged or not; one HEAD doesn't have
+     * is gone after. What was on disk goes to the Trash first, so `files/restore` puts it back.
+     */
+    'git/discard': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            trashed: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
     /** What is staged in the repository whose root is `repo`; the new commit, short. */
     'git/commit': {
         params: z.ZodObject<{
@@ -808,6 +833,22 @@ export declare const requests: {
             commit: z.ZodString;
         }, z.core.$strip>;
     };
+    /** Brings the upstream of `repo`'s branch in, only when it fast-forwards; git's own words when it doesn't. */
+    'git/pull': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            repo: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
+    /** Sends `repo`'s branch to its upstream, setting one on `origin` for a branch that has none. */
+    'git/push': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            repo: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
     /** A file from the session's last `git/changes`, by its absolute path. */
     'git/diff': {
         params: z.ZodObject<{
@@ -816,6 +857,62 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodString;
     };
+    /** The same file as `git/diff` compares it against, whole: empty for a file that is new. */
+    'git/before': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            file: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodString;
+    };
+    /**
+     * Who last changed each line of a file in the session's folder, by its path there; with `text`, of the text as the
+     * client holds it, its unsaved lines not committed. `null` for a file git doesn't know.
+     */
+    'git/blame': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        result: z.ZodNullable<z.ZodObject<{
+            repo: z.ZodString;
+            you: z.ZodOptional<z.ZodString>;
+            ranges: z.ZodArray<z.ZodObject<{
+                start: z.ZodNumber;
+                lines: z.ZodNumber;
+                commit: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            commits: z.ZodRecord<z.ZodString, z.ZodObject<{
+                sha: z.ZodString;
+                author: z.ZodString;
+                email: z.ZodString;
+                time: z.ZodNumber;
+                summary: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    };
+    /** A commit of `repo`, the root a blame names, with each file it changed. */
+    'git/show': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            repo: z.ZodString;
+            commit: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            sha: z.ZodString;
+            author: z.ZodString;
+            email: z.ZodString;
+            time: z.ZodNumber;
+            summary: z.ZodString;
+            body: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                patch: z.ZodString;
+                binary: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
     /** What the project map read; `reading` while it is read the first time. With `session`, the folder that session works in. */
     'map/overview': {
         params: z.ZodObject<{
@@ -920,6 +1017,532 @@ export declare const requests: {
             modified: z.ZodNumber;
         }, z.core.$strip>;
     };
+    /** Text in the folder's files that git doesn't ignore; a regular expression that isn't one is refused as invalid params. */
+    'files/search': {
+        params: z.ZodObject<{
+            query: z.ZodString;
+            caseSensitive: z.ZodOptional<z.ZodBoolean>;
+            wholeWord: z.ZodOptional<z.ZodBoolean>;
+            regex: z.ZodOptional<z.ZodBoolean>;
+            include: z.ZodOptional<z.ZodString>;
+            exclude: z.ZodOptional<z.ZodString>;
+            session: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            files: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                matches: z.ZodArray<z.ZodObject<{
+                    line: z.ZodNumber;
+                    text: z.ZodString;
+                    ranges: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    /** Replaces what `files/search` finds, in every file it finds it in or in `paths` of them, and writes them. */
+    'files/replace': {
+        params: z.ZodObject<{
+            query: z.ZodString;
+            caseSensitive: z.ZodOptional<z.ZodBoolean>;
+            wholeWord: z.ZodOptional<z.ZodBoolean>;
+            regex: z.ZodOptional<z.ZodBoolean>;
+            include: z.ZodOptional<z.ZodString>;
+            exclude: z.ZodOptional<z.ZodString>;
+            session: z.ZodString;
+            replacement: z.ZodString;
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            files: z.ZodNumber;
+            replacements: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    /** The files of the session's folder this client has open, which `files/changed` tells of from now on; the ones before are let go. */
+    'files/watch': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            paths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
+    /** A file, empty or with `content`, or with `folder` a folder; the folders it is in are made as needed. */
+    'files/create': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            folder: z.ZodOptional<z.ZodBoolean>;
+            content: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                text: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                base64: z.ZodString;
+            }, z.core.$strip>]>>;
+            replace: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            path: z.ZodString;
+            replaced: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /** Another name for a file or folder, where it is: `name` alone, not a path. */
+    'files/rename': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            name: z.ZodString;
+            replace: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            moved: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>>;
+            replaced: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Files and folders into a folder of the session's (`''` for the folder itself), each keeping its name; with
+     * `keepBoth`, one whose name is taken there takes the next free one, as the Finder's Keep Both names it, `box 2.tsx`.
+     */
+    'files/move': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            paths: z.ZodArray<z.ZodString>;
+            into: z.ZodString;
+            replace: z.ZodOptional<z.ZodBoolean>;
+            keepBoth: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            moved: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>>;
+            replaced: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * The same, copied: from the folder by their paths there, or from anywhere by their whole paths, as files dropped from
+     * the Finder. Copied into the folder it is in, a copy is named as the Finder names one, `box copy.tsx`.
+     */
+    'files/copy': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            paths: z.ZodArray<z.ZodString>;
+            into: z.ZodString;
+            replace: z.ZodOptional<z.ZodBoolean>;
+            keepBoth: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            copied: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>>;
+            replaced: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /** Files and folders to the Trash, never deleted for good; refused with `unsupported` where there is no Trash Jinion can reach. */
+    'files/delete': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            paths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            trashed: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /** What `files/delete` or a replace sent to the Trash, put back at its path, while this Jinion runs. */
+    'files/restore': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            trashed: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+            replace: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            restored: z.ZodArray<z.ZodString>;
+            replaced: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                trash: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    'lsp/open': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
+    /** The whole text as it is now. */
+    'lsp/change': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
+    'lsp/close': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
+    'lsp/hover': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            position: z.ZodObject<{
+                line: z.ZodNumber;
+                character: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        result: z.ZodNullable<z.ZodObject<{
+            contents: z.ZodString;
+            range: z.ZodOptional<z.ZodObject<{
+                start: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+                end: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    };
+    'lsp/definition': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            position: z.ZodObject<{
+                line: z.ZodNumber;
+                character: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        result: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            range: z.ZodObject<{
+                start: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+                end: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    };
+    'lsp/references': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            position: z.ZodObject<{
+                line: z.ZodNumber;
+                character: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        result: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            range: z.ZodObject<{
+                start: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+                end: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    };
+    /** `trigger` is the character typed that asked for them, such as `.`; left out when the user asked. */
+    'lsp/completion': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            position: z.ZodObject<{
+                line: z.ZodNumber;
+                character: z.ZodNumber;
+            }, z.core.$strip>;
+            trigger: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            incomplete: z.ZodBoolean;
+            items: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                kind: z.ZodOptional<z.ZodNumber>;
+                detail: z.ZodOptional<z.ZodString>;
+                documentation: z.ZodOptional<z.ZodString>;
+                insertText: z.ZodString;
+                snippet: z.ZodOptional<z.ZodBoolean>;
+                range: z.ZodOptional<z.ZodObject<{
+                    start: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                    end: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                sortText: z.ZodOptional<z.ZodString>;
+                filterText: z.ZodOptional<z.ZodString>;
+                preselect: z.ZodOptional<z.ZodBoolean>;
+                commitCharacters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                additionalEdits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    range: z.ZodObject<{
+                        start: z.ZodObject<{
+                            line: z.ZodNumber;
+                            character: z.ZodNumber;
+                        }, z.core.$strip>;
+                        end: z.ZodObject<{
+                            line: z.ZodNumber;
+                            character: z.ZodNumber;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                    text: z.ZodString;
+                }, z.core.$strip>>>;
+                data: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /** An item of `lsp/completion` with what was left out of the list, such as its documentation. */
+    'lsp/completion-detail': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            item: z.ZodObject<{
+                label: z.ZodString;
+                kind: z.ZodOptional<z.ZodNumber>;
+                detail: z.ZodOptional<z.ZodString>;
+                documentation: z.ZodOptional<z.ZodString>;
+                insertText: z.ZodString;
+                snippet: z.ZodOptional<z.ZodBoolean>;
+                range: z.ZodOptional<z.ZodObject<{
+                    start: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                    end: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                sortText: z.ZodOptional<z.ZodString>;
+                filterText: z.ZodOptional<z.ZodString>;
+                preselect: z.ZodOptional<z.ZodBoolean>;
+                commitCharacters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                additionalEdits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    range: z.ZodObject<{
+                        start: z.ZodObject<{
+                            line: z.ZodNumber;
+                            character: z.ZodNumber;
+                        }, z.core.$strip>;
+                        end: z.ZodObject<{
+                            line: z.ZodNumber;
+                            character: z.ZodNumber;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                    text: z.ZodString;
+                }, z.core.$strip>>>;
+                data: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            label: z.ZodString;
+            kind: z.ZodOptional<z.ZodNumber>;
+            detail: z.ZodOptional<z.ZodString>;
+            documentation: z.ZodOptional<z.ZodString>;
+            insertText: z.ZodString;
+            snippet: z.ZodOptional<z.ZodBoolean>;
+            range: z.ZodOptional<z.ZodObject<{
+                start: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+                end: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            sortText: z.ZodOptional<z.ZodString>;
+            filterText: z.ZodOptional<z.ZodString>;
+            preselect: z.ZodOptional<z.ZodBoolean>;
+            commitCharacters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            additionalEdits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                range: z.ZodObject<{
+                    start: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                    end: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                text: z.ZodString;
+            }, z.core.$strip>>>;
+            data: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>;
+    };
+    'lsp/signature-help': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            position: z.ZodObject<{
+                line: z.ZodNumber;
+                character: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        result: z.ZodNullable<z.ZodObject<{
+            signatures: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                documentation: z.ZodOptional<z.ZodString>;
+                parameters: z.ZodArray<z.ZodObject<{
+                    label: z.ZodUnion<readonly [z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+                    documentation: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            activeSignature: z.ZodNumber;
+            activeParameter: z.ZodNumber;
+        }, z.core.$strip>>;
+    };
+    /**
+     * Renames what is at the position wherever it is used. The files nobody has open are changed on disk; the edits to
+     * those open come back, for the client to make as unsaved changes.
+     */
+    'lsp/rename': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            position: z.ZodObject<{
+                line: z.ZodNumber;
+                character: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            edits: z.ZodArray<z.ZodObject<{
+                range: z.ZodObject<{
+                    start: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                    end: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    };
+    /** The edits that format the file as it is open, for the client to make. */
+    'lsp/format': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+            tabSize: z.ZodNumber;
+            insertSpaces: z.ZodBoolean;
+        }, z.core.$strip>;
+        result: z.ZodArray<z.ZodObject<{
+            range: z.ZodObject<{
+                start: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+                end: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    };
+    /** Every error and warning known in the session's folder, by file; `lsp/diagnostics` tells what changes after. */
+    'lsp/problems': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            diagnostics: z.ZodArray<z.ZodObject<{
+                range: z.ZodObject<{
+                    start: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                    end: z.ZodObject<{
+                        line: z.ZodNumber;
+                        character: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                severity: z.ZodEnum<{
+                    error: "error";
+                    hint: "hint";
+                    info: "info";
+                    warning: "warning";
+                }>;
+                message: z.ZodString;
+                source: z.ZodOptional<z.ZodString>;
+                code: z.ZodOptional<z.ZodString>;
+                unnecessary: z.ZodOptional<z.ZodBoolean>;
+                deprecated: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    };
+    /** How the server that reads the file stands, as a status bar shows it; null for a file none reads. `lsp/server` tells what changes. */
+    'lsp/server': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNullable<z.ZodObject<{
+            server: z.ZodEnum<{
+                css: "css";
+                html: "html";
+                json: "json";
+                typescript: "typescript";
+            }>;
+            state: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                starting: "starting";
+                stopped: "stopped";
+            }>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+    /** Starts the file's server again, as after it failed; it has to be open. */
+    'lsp/restart': {
+        params: z.ZodObject<{
+            session: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
     /**
      * A file to go with the session's messages, kept out of the project where the agent can read it. Answered once it is
      * kept; reading it, such as transcribing a recording, goes on after, told in the session's `attachments` field. A
@@ -971,10 +1594,11 @@ export declare const requests: {
             urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
     };
-    /** A shell in the folder `session` works in, its worktree or the project, or in the project without one. */
+    /** A shell in the folder `session` works in, its worktree or the project, or in the project without one; with `folder`, in that folder of it. */
     'terminals/open': {
         params: z.ZodObject<{
             session: z.ZodOptional<z.ZodString>;
+            folder: z.ZodOptional<z.ZodString>;
             cols: z.ZodOptional<z.ZodNumber>;
             rows: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
@@ -1048,6 +1672,23 @@ export declare const requests: {
             command: z.ZodString;
         }, z.core.$strip>>;
     };
+    /** The HTML files of the folder `session` works in, or of the project without one, by their path there. */
+    'preview/pages': {
+        params: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        result: z.ZodArray<z.ZodString>;
+    };
+    /** The address a preview opens a file of that folder at, served as it is, with no dev server. */
+    'preview/file': {
+        params: z.ZodObject<{
+            session: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>;
+    };
     'accounts/list': {
         params: z.ZodObject<{
             agent: z.ZodOptional<z.ZodString>;
@@ -1075,7 +1716,7 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodNull;
     };
-    /** Answered once signing in ends; meanwhile the link and what to type come as notifications. */
+    /** Answered once signing in ends, with why when it failed; meanwhile the link and what to type come as notifications. */
     'accounts/sign-in': {
         params: z.ZodObject<{
             name: z.ZodString;
@@ -1083,6 +1724,7 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodObject<{
             signedIn: z.ZodBoolean;
+            problem: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     };
     'accounts/sign-in-answer': {
@@ -1121,6 +1763,7 @@ export declare const requests: {
                 elsewhere: "elsewhere";
                 jinion: "jinion";
             }>>;
+            signedIn: z.ZodOptional<z.ZodBoolean>;
             removable: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
     };
@@ -1158,6 +1801,13 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodNull;
     };
+    /** Connects a server that failed again, now; `mcp/servers` says how it went. */
+    'mcp/reconnect': {
+        params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
     /** How long the agent's answers run, from the next prompt on, in every session. */
     'preferences/answers': {
         params: z.ZodObject<{
@@ -1176,6 +1826,13 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodNull;
     };
+    /** Whether the user is notified when the agent waits for them or ends a long turn, from now on, as `/notifications` sets it. */
+    'preferences/notifications': {
+        params: z.ZodObject<{
+            notifications: z.ZodBoolean;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
     /** Puts an announcement away for good, on every machine of its user. */
     'announcements/dismiss': {
         params: z.ZodObject<{
@@ -1183,13 +1840,14 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodNull;
     };
-    /** Opens the browser and is answered once signing in ends; meanwhile its link comes as `mcp/sign-in-link`. */
+    /** Opens the browser and is answered once signing in ends, with why when it failed; meanwhile its link comes as `mcp/sign-in-link`. */
     'mcp/sign-in': {
         params: z.ZodObject<{
             name: z.ZodString;
         }, z.core.$strip>;
         result: z.ZodObject<{
             signedIn: z.ZodBoolean;
+            problem: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     };
     'mcp/sign-in-cancel': {
@@ -1198,6 +1856,13 @@ export declare const requests: {
         }, z.core.$strip>;
         result: z.ZodNull;
     };
+    /** Drops Jinion's sign-in to a server `mcp/servers` says is `signedIn`; it asks to sign in again from the next turn. */
+    'mcp/sign-out': {
+        params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodNull;
+    };
     /** Emails a code that `jinion/sign-in-email` takes, for 10 minutes. */
     'jinion/send-code': {
         params: z.ZodObject<{
@@ -1799,6 +2464,9 @@ export declare const notificationsToClient: {
             }, z.core.$strip>, z.ZodObject<{
                 type: z.ZodLiteral<"turn-start">;
                 reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"picked">;
+                text: z.ZodString;
             }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"compaction">;
                 state: z.ZodLiteral<"running">;
@@ -1926,6 +2594,7 @@ export declare const notificationsToClient: {
             size: number;
             reading?: string | undefined;
         }[] | undefined;
+        folder?: string | undefined;
         wantsWorktree: boolean;
         working: boolean;
         ratings?: Record<string, "disliked" | "liked"> | undefined;
@@ -2005,6 +2674,7 @@ export declare const notificationsToClient: {
             size: number;
             reading?: string | undefined;
         }[] | undefined;
+        folder?: string | undefined;
         wantsWorktree: boolean;
         working: boolean;
         ratings?: Record<string, "disliked" | "liked"> | undefined;
@@ -2067,6 +2737,7 @@ export declare const notificationsToClient: {
             activated?: boolean | undefined;
         } | null | undefined;
         signals?: boolean | undefined;
+        notifications?: boolean | undefined;
         claudeSetupOffered?: boolean | undefined;
         announcements?: {
             id: number;
@@ -2132,6 +2803,7 @@ export declare const notificationsToClient: {
             activated?: boolean | undefined;
         } | null | undefined;
         signals?: boolean | undefined;
+        notifications?: boolean | undefined;
         claudeSetupOffered?: boolean | undefined;
         announcements?: {
             id: number;
@@ -2253,6 +2925,83 @@ export declare const notificationsToClient: {
         seq: z.ZodNumber;
         data: z.ZodString;
     }, z.core.$strip>;
+    /** A file `files/watch` named changed on disk, by the agent, a save or another program. */
+    'files/changed': z.ZodObject<{
+        session: z.ZodString;
+        path: z.ZodString;
+        modified: z.ZodOptional<z.ZodNumber>;
+        movedTo: z.ZodOptional<z.ZodString>;
+        by: z.ZodOptional<z.ZodEnum<{
+            agent: "agent";
+            other: "other";
+        }>>;
+    }, z.core.$strip>;
+    /** A file's errors and warnings changed: all of them as they are now, none once it has none. */
+    'lsp/diagnostics': z.ZodObject<{
+        path: z.ZodString;
+        diagnostics: z.ZodArray<z.ZodObject<{
+            range: z.ZodObject<{
+                start: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+                end: z.ZodObject<{
+                    line: z.ZodNumber;
+                    character: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            severity: z.ZodEnum<{
+                error: "error";
+                hint: "hint";
+                info: "info";
+                warning: "warning";
+            }>;
+            message: z.ZodString;
+            source: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+            unnecessary: z.ZodOptional<z.ZodBoolean>;
+            deprecated: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        session: z.ZodString;
+    }, z.core.$strip>;
+    /** A server of the folder of a file the client has open started, ended or couldn't start. */
+    'lsp/server': z.ZodObject<{
+        server: z.ZodEnum<{
+            css: "css";
+            html: "html";
+            json: "json";
+            typescript: "typescript";
+        }>;
+        state: z.ZodEnum<{
+            failed: "failed";
+            running: "running";
+            starting: "starting";
+            stopped: "stopped";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        session: z.ZodString;
+    }, z.core.$strip>;
+};
+/** What the server asks a client and waits on, only of a client that said at `initialize` it can. */
+export declare const requestsToClient: {
+    /** Opens `url` in the Preview beside the thread the user looks at; answered once the page loaded, or with why it didn't. */
+    'preview/open': {
+        params: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>;
+        result: z.ZodObject<{
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    /** The page the Preview shows, as drawn now; `null` when it shows none. */
+    'preview/capture': {
+        params: z.ZodObject<{}, z.core.$strip>;
+        result: z.ZodNullable<z.ZodObject<{
+            url: z.ZodString;
+            data: z.ZodString;
+            mediaType: z.ZodLiteral<"image/png">;
+        }, z.core.$strip>>;
+    };
 };
 /** The params of everything a client sends, as the server's peer checks them. */
 export declare const clientSchemas: Record<string, z.ZodType>;
@@ -2270,9 +3019,15 @@ export type ServerContract = {
     };
     notifications: Inferred<typeof notificationsToServer>;
 };
-/** What a client answers: for now only what the server tells it. */
+type RequestsToClient = typeof requestsToClient;
+/** What a client answers. */
 export type ClientContract = {
-    requests: Record<never, never>;
+    requests: {
+        [M in keyof RequestsToClient]: {
+            params: z.infer<RequestsToClient[M]['params']>;
+            result: z.infer<RequestsToClient[M]['result']>;
+        };
+    };
     notifications: Inferred<typeof notificationsToClient>;
 };
 //# sourceMappingURL=protocol.d.ts.map