@neosh/api 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neosh/api",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "The neosh plugin API. Types are generated from the Rust side and drift-checked in CI.",
   "license": "MIT",
   "type": "module",

package/src/generated/ApiCall.ts

@@ -5,6 +5,7 @@ import type { Capability } from "./Capability";
 import type { CursorMotion } from "./CursorMotion";
 import type { CursorShape } from "./CursorShape";
 import type { DiffTarget } from "./DiffTarget";
+import type { Direction } from "./Direction";
 import type { DriverKind } from "./DriverKind";
 import type { ExtmarkId } from "./ExtmarkId";
 import type { ExtmarkOpts } from "./ExtmarkOpts";
@@ -25,17 +26,20 @@ import type { NodeId } from "./NodeId";
 import type { NoticeKind } from "./NoticeKind";
 import type { OptionSpec } from "./OptionSpec";
 import type { OptionValue } from "./OptionValue";
+import type { PaneId } from "./PaneId";
 import type { PermissionMode } from "./PermissionMode";
 import type { ProjectKey } from "./ProjectKey";
 import type { ProviderEvent } from "./ProviderEvent";
 import type { QuotaSnapshot } from "./QuotaSnapshot";
 import type { Rect } from "./Rect";
+import type { ScrollAmount } from "./ScrollAmount";
 import type { SelectShape } from "./SelectShape";
 import type { SessionId } from "./SessionId";
 import type { StatusSegment } from "./StatusSegment";
 import type { StreamId } from "./StreamId";
 import type { SurfaceCell } from "./SurfaceCell";
 import type { SurfaceId } from "./SurfaceId";
+import type { TabId } from "./TabId";
 import type { TextEdit } from "./TextEdit";
 import type { ToolDef } from "./ToolDef";
 import type { UsageResolution } from "./UsageResolution";
@@ -55,6 +59,7 @@ export type ApiCall =
      */
     kind?: string | null;
   }
+  | { "call": "buf_delete"; buf: BufferId }
   | { "call": "buf_line_count"; buf: BufferId }
   | {
     "call": "buf_get_lines";
@@ -109,7 +114,40 @@ export type ApiCall =
   | { "call": "win_set_cursor"; win: WindowId; row: number; col: number }
   | { "call": "win_get_viewport"; win: WindowId }
   | { "call": "win_scroll_to"; win: WindowId; top_line: number | null }
+  | { "call": "win_scroll"; win: WindowId; amount: ScrollAmount }
   | { "call": "win_list" }
+  | {
+    "call": "pane_split";
+    pane: PaneId;
+    /**
+     * Which side of `pane` the new one takes. `Right` and `Down` put it after `pane` in the
+     * split; `Left` and `Up` put it before.
+     */
+    dir: Direction;
+  }
+  | { "call": "pane_close"; pane: PaneId }
+  | { "call": "pane_focus"; pane: PaneId }
+  | { "call": "pane_focus_dir"; view?: ViewId | null; dir: Direction }
+  | { "call": "pane_resize"; pane: PaneId; dir: Direction; delta: number }
+  | { "call": "pane_swap"; pane: PaneId; with: PaneId }
+  | { "call": "pane_move_edge"; pane: PaneId; dir: Direction }
+  | { "call": "pane_equalize"; view?: ViewId | null }
+  | {
+    "call": "tab_new";
+    view?: ViewId | null;
+    title?: string | null;
+    /**
+     * Whether to go to it. A tab opened by a key is; a tab opened by an orchestrator putting
+     * work somewhere is not, for the same reason `SessionNew { activate: false }` exists.
+     */
+    activate: boolean;
+  }
+  | { "call": "tab_close"; tab: TabId }
+  | { "call": "tab_select"; tab: TabId }
+  | { "call": "tab_step"; view?: ViewId | null; delta: number }
+  | { "call": "tab_move"; tab: TabId; to: number }
+  | { "call": "tab_rename"; tab: TabId; title: string | null }
+  | { "call": "tab_list"; view?: ViewId | null }
   | {
     "call": "win_motion";
     win: WindowId;
@@ -370,6 +408,7 @@ export type ApiCall =
   | { "call": "swarm_reconnect"; node: NodeId }
   | { "call": "swarm_disconnect"; node: NodeId }
   | { "call": "swarm_strangers" }
+  | { "call": "swarm_browse"; node: NodeId; prefix: string }
   | { "call": "quota_list" }
   | { "call": "quota_refresh"; instance?: InstanceId | null }
   | { "call": "quota_report"; snapshot: QuotaSnapshot }
@@ -441,12 +480,37 @@ export type ApiCall =
   | { "call": "git_stage"; paths: Array<string> }
   | { "call": "git_unstage"; paths: Array<string> }
   | { "call": "git_commit"; message: string }
+  | {
+    "call": "git_fetch";
+    /**
+     * The repository to fetch in. The conversation's own when absent.
+     */
+    cwd?: string | null;
+  }
   | {
     "call": "git_pull";
     /**
      * The repository to pull in. The conversation's own when absent.
      */
     cwd?: string | null;
+    /**
+     * Replay this branch's own commits on top of what arrived, rather than merging.
+     *
+     * A flag rather than a call of its own because it is one argument to one command, and the
+     * caller that needs it is the one that has just been told the branch diverged — at which
+     * point "rebase or merge" is the question being answered, and two entry points for the two
+     * answers would be two things to keep in step for no gain.
+     *
+     * It rewrites local commits, which is why nothing sets it without asking first.
+     */
+    rebase: boolean;
+  }
+  | {
+    "call": "forge_pulls";
+    /**
+     * The repository to ask about. The conversation's own when absent.
+     */
+    cwd?: string | null;
   }
   | {
     "call": "git_add_worktree";
@@ -470,6 +534,32 @@ export type ApiCall =
      */
     cwd?: string | null;
   }
+  | {
+    "call": "git_clone";
+    /**
+     * Anything `git clone` takes: an `https://` or `git@` URL, or a local path.
+     */
+    url: string;
+    /**
+     * Where the working tree lands, in full. The caller resolved the root and the name, so
+     * that a picker can *show* the destination on the row before anything is written.
+     */
+    path: string;
+  }
+  | {
+    "call": "git_move_worktree";
+    path: string;
+    /**
+     * Where it lands, in full. The leaf must not exist; the parent is created.
+     */
+    dest: string;
+    /**
+     * The repository it belongs to. `git worktree move` runs from a checkout, and the
+     * conversation the caller is in may be standing in the one being moved — the same reason
+     * [`Self::GitRemoveWorktree`] takes one.
+     */
+    cwd?: string | null;
+  }
   | {
     "call": "gen_complete";
     prompt: string;
@@ -478,6 +568,30 @@ export type ApiCall =
      * Ask for JSON and parse it host-side, tolerating the code fences models wrap it in.
      */
     json: boolean;
+    /**
+     * The one key the answer is *about*, when the whole answer is one value.
+     *
+     * A prompt that says "return `{"branch": …}`" is answered with the object most of the
+     * time and with a bare `fix/composer-paste` the rest of it — the model did the work and
+     * skipped the envelope, and a caller that only accepts the envelope throws a correct
+     * answer away. Measured on this workspace's own history it was two runs in twenty-two:
+     * twice a branch was never named, silently, and both times the name was sitting in the
+     * reply.
+     *
+     * So: extraction first, exactly as before, and this is what a *bare* answer means. Named
+     * rather than inferred, because only the caller knows which key one value belongs under
+     * — and absent, nothing changes, which is what every existing caller wants.
+     *
+     * Only for a one-value answer. A commit message is a subject *and* a body, and guessing
+     * which half a bare paragraph is would be inventing the other one.
+     *
+     * And only for a value a *wrong* answer is recognisable in. A branch name is checkable
+     * and one `git branch -m` from being fixed; a thread title is any short line, which is
+     * also what a refusal and a driver's own error message look like — there the envelope is
+     * the only evidence the question was answered rather than commented on, and it is worth
+     * the one reply in ten that arrives without it.
+     */
+    field?: string | null;
     /**
      * Defaults to `gen.model` if set, else the session's own selection.
      */

package/src/generated/ApiOk.ts

@@ -20,10 +20,12 @@ import type { ModelSelection } from "./ModelSelection";
 import type { NamespaceId } from "./NamespaceId";
 import type { NodeInfo } from "./NodeInfo";
 import type { OptionEntry } from "./OptionEntry";
+import type { PaneId } from "./PaneId";
 import type { PermissionDecision } from "./PermissionDecision";
 import type { PermissionMode } from "./PermissionMode";
 import type { PluginInfo } from "./PluginInfo";
 import type { PointInfo } from "./PointInfo";
+import type { PullRequest } from "./PullRequest";
 import type { QuestionAnswer } from "./QuestionAnswer";
 import type { QuotaSample } from "./QuotaSample";
 import type { QuotaSnapshot } from "./QuotaSnapshot";
@@ -34,6 +36,8 @@ import type { SurfaceId } from "./SurfaceId";
 import type { SwarmAgent } from "./SwarmAgent";
 import type { SwarmNode } from "./SwarmNode";
 import type { SwarmStranger } from "./SwarmStranger";
+import type { TabId } from "./TabId";
+import type { TabInfo } from "./TabInfo";
 import type { ToolDef } from "./ToolDef";
 import type { UpdateOutcome } from "./UpdateOutcome";
 import type { UpdateStatus } from "./UpdateStatus";
@@ -56,6 +60,9 @@ export type ApiOk =
   | { "ok": "views"; views: Array<ViewInfo> }
   | { "ok": "ns"; ns: NamespaceId }
   | { "ok": "mark"; id: ExtmarkId }
+  | { "ok": "pane"; pane: PaneId | null }
+  | { "ok": "tab"; tab: TabId }
+  | { "ok": "tabs"; tabs: Array<TabInfo>; active: TabId }
   | { "ok": "surface"; surface: SurfaceId }
   | { "ok": "lines"; lines: Array<string> }
   | { "ok": "count"; n: number }
@@ -76,7 +83,7 @@ export type ApiOk =
   | { "ok": "focused_win"; win: WindowId | null }
   | { "ok": "option"; entry: OptionEntry | null }
   | { "ok": "options"; options: Array<OptionEntry> }
-  | { "ok": "paths"; paths: Array<string> }
+  | { "ok": "paths"; paths: Array<string>; denied?: string | null }
   | { "ok": "viewport"; viewport: Viewport | null }
   | { "ok": "sessions"; sessions: Array<SessionInfo> }
   | { "ok": "credentials"; credentials: Array<CredentialInfo> }
@@ -86,6 +93,7 @@ export type ApiOk =
   | { "ok": "status"; status: RepoStatus }
   | { "ok": "branches"; branches: Array<BranchInfo> }
   | { "ok": "worktrees"; worktrees: Array<WorktreeInfo> }
+  | { "ok": "pulls"; pulls: Array<PullRequest> }
   | { "ok": "commits"; commits: Array<CommitInfo> }
   | { "ok": "commit"; commit: CommitInfo }
   | { "ok": "text"; text: string }
@@ -107,6 +115,7 @@ export type ApiOk =
   | { "ok": "swarm_nodes"; nodes: Array<SwarmNode> }
   | { "ok": "swarm_agents"; agents: Array<SwarmAgent> }
   | { "ok": "swarm_strangers"; strangers: Array<SwarmStranger> }
+  | { "ok": "swarm_commanded"; session?: SessionId | null }
   | { "ok": "quotas"; quotas: Array<QuotaSnapshot> }
   | { "ok": "quota_history"; samples: Array<QuotaSample> }
   | { "ok": "usage_history"; history: UsageHistory }

package/src/generated/AscpMessage.ts

@@ -70,4 +70,6 @@ export type AscpMessage =
     session?: SessionId | null;
   }
   | { "type": "refused"; id: string; refusal: Refusal }
+  | { "type": "browse"; id: string; prefix: string }
+  | { "type": "browsed"; id: string; paths: Array<string> }
   | { "type": "goodbye"; message?: string | null };

package/src/generated/AuthRef.ts

@@ -9,6 +9,11 @@
 export type AuthRef =
   | { "kind": "env"; var: string }
   | { "kind": "command"; argv: Array<string> }
-  | { "kind": "cli"; program: string; login?: string | null }
+  | {
+    "kind": "cli";
+    program: string;
+    login?: string | null;
+    retired?: string | null;
+  }
   | { "kind": "inherited" }
   | { "kind": "none" };

package/src/generated/ChecksState.ts

@@ -0,0 +1,14 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * What the forge's checks say, folded to the one thing a row has room for.
+ *
+ * Folded here rather than on the wire as a list, because the question a project row answers is
+ * "is anything wrong" and the answer is one glyph. The counts travel beside it for whoever wants
+ * to say `✗2`; the full list of check names is a panel's job and a different call.
+ *
+ * `Pending` and `None` are deliberately different. Nothing has run yet is a state that resolves on
+ * its own in a few minutes; there are no checks configured at all is permanent, and drawing a
+ * spinner over it for ever is the failure this distinction avoids.
+ */
+export type ChecksState = "none" | "pending" | "passing" | "failing";

package/src/generated/CredentialSource.ts

@@ -9,6 +9,7 @@
 export type CredentialSource =
   | { "kind": "plan"; via: string }
   | { "kind": "plan_missing"; program: string; hint?: string | null }
+  | { "kind": "plan_retired"; program: string; note: string }
   | { "kind": "env"; var: string }
   | { "kind": "keychain" }
   | { "kind": "session" }

package/src/generated/Direction.ts

@@ -0,0 +1,6 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Which way to go, for moving between panes and for growing one.
+ */
+export type Direction = "left" | "right" | "up" | "down";

package/src/generated/Dock.ts

@@ -1,9 +1,15 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
 /**
- * Where a non-floating window sits.
+ * Which edge of a rectangle a non-floating window sits against.
  *
- * Deliberately *not* an arbitrary split tree: agent UIs do not need one, and a split tree creates
- * layout ambiguity that every plugin then has to reason about.
+ * The rectangle is the screen, or — when the window names a [`PaneId`] — one pane of the main
+ * region. That is the only difference between the two, and it is what let splitting arrive without
+ * a second geometry vocabulary: a composer docked `Bottom` in a pane is the same call as a
+ * composer docked `Bottom` on the screen, asked about a smaller rectangle.
+ *
+ * Still not an arbitrary split tree *here*: a window says which edge of which rectangle it wants,
+ * and the tree that makes those rectangles is [`PaneNode`], one level up. Keeping the two apart is
+ * what stops every plugin from having to reason about nesting to place a status line.
  */
-export type Dock = "left" | "right" | "bottom" | "main";
+export type Dock = "left" | "right" | "top" | "bottom" | "main";

package/src/generated/FloatConfig.ts

@@ -23,6 +23,17 @@ export type FloatConfig = {
    */
   border_hl?: string | null;
   title?: string | null;
+  /**
+   * A strip on the bottom border: what the keys here do.
+   *
+   * On the border rather than in the buffer, because a key strip written as a row of content is
+   * one that scrolls away exactly when it is wanted, and is the first thing clipped on a terminal
+   * too short for the panel. Both of those happened: the picker's strip is the row that says how
+   * to get out, and on a sixteen-row screen it was the row that did not fit.
+   *
+   * Clipped to the border's width like the title, so it is for a legend and not for prose.
+   */
+  footer?: string | null;
   /**
    * Close automatically when focus moves elsewhere. The right default for pickers and hovers.
    */
@@ -60,4 +71,26 @@ export type FloatConfig = {
    * characters through to the composer would be typing into a field you cannot see.
    */
   modal: boolean;
+  /**
+   * This panel is a place you can move in when it does not fit.
+   *
+   * A float asks for a height and the frontend gives it what there is — so on a short terminal
+   * every row past the bottom edge is content that exists, is drawn nowhere, and has no key
+   * pointed at it. `height: Max { n: 30 }` on a twenty-row screen is not thirty rows of panel, it
+   * is ten rows of panel and twenty rows nobody can reach.
+   *
+   * Setting this adds one scope to the keymap chain while this float has focus —
+   * `BufKind { name: "neosh.scroll" }` — which is where the workspace binds the reader's motions:
+   * `j`/`k`, `<C-d>`/`<C-u>`, `<C-f>`/`<C-b>`, `gg`/`G`, the arrows and the paging keys. A scope
+   * rather than a capture, so all three of the usual rules hold: `^Z` lists the keys, `init.ts`
+   * moves them, and a panel that wants `j` for something of its own binds it on *its* kind, which
+   * is nearer and wins. It sits below the panel's own kind and above `Global`, so it is a default
+   * that never takes a key away from the thing it is scrolling.
+   *
+   * Off by default, and not for want of ambition: a picker whose filter takes printable
+   * characters through a capture would have `j` and `G` resolved out from under it by a scope, so
+   * typing a model's name would scroll instead of filtering. A panel that already moves in itself
+   * says so by staying quiet here.
+   */
+  scroll: boolean;
 };

package/src/generated/ModelInfo.ts

@@ -27,4 +27,20 @@ export type ModelInfo = {
    * numbers are already columns.
    */
   tagline?: string | null;
+  /**
+   * Why this one cannot be chosen here, in a sentence, or nothing when it can.
+   *
+   * A model a driver lists but will not run — the vendor CLI on this machine is too old for it,
+   * most often. Said rather than filtered out, for the reason a missing provider is listed
+   * rather than dropped: nothing there and not allowed are the same empty list, and only one of
+   * them is fixed by doing something. A model that silently vanishes from the picker is a
+   * question with nowhere to ask it — you go looking for the release notes, or for our bug
+   * tracker, and the answer was one `claude update` away the whole time.
+   *
+   * The sentence carries the fix, not just the diagnosis: "needs claude 2.1.251 — run `claude
+   * update`" is actionable and "unsupported model" is not. Anything reading a catalogue to
+   * *choose* — the startup default, `model.upgrade`, `model.line` — skips these; only a picker
+   * draws them, and draws them disabled.
+   */
+  unavailable?: string | null;
 };

package/src/generated/NodeCapabilities.ts

@@ -23,6 +23,17 @@ export type NodeCapabilities = {
    * Whether [`AscpMessage::Subscribe`] will produce anything.
    */
   streams: boolean;
+  /**
+   * Whether [`AscpMessage::Browse`] will be answered.
+   *
+   * Not a permission — it follows `accepts_commands`, for the reason written on `Browse` — but a
+   * *compatibility* flag, and that is why it is here rather than derived. A node built before
+   * `Browse` existed cannot skip a message it has never heard of: the frame parses or the
+   * connection fails, so a new node that sent one on spec would drop an old peer's link every
+   * time somebody opened a directory picker. It defaults to `false`, which is exactly what an
+   * older node's handshake decodes to, so "does not say" and "cannot" are the same answer.
+   */
+  browse: boolean;
   /**
    * The checkouts this node has, for starting something on it.
    */

package/src/generated/PaneChild.ts

@@ -0,0 +1,18 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { PaneNode } from "./PaneNode";
+
+/**
+ * One child of a split, and how much of the axis it gets.
+ */
+export type PaneChild = {
+  node: PaneNode;
+  /**
+   * Share of the parent's axis, relative to its siblings.
+   *
+   * A weight rather than cells, because the terminal is resized by somebody dragging its corner
+   * and a layout stored in cells has to be recomputed — badly, and with rounding that
+   * accumulates — every time that happens. Weights survive a resize by meaning the same thing at
+   * every size. [`WEIGHT`] is what an even split is made of.
+   */
+  weight: number;
+};

package/src/generated/PaneId.ts

@@ -0,0 +1,15 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * One rectangle of the main region, and everything docked inside it.
+ *
+ * A pane is *where* rather than *what*: it owns no buffer and draws nothing. A chat pane is a
+ * transcript window docked `Main` in it plus a composer docked `Bottom` in it; a pane showing
+ * one thing is one window docked `Main`. That is the whole of why splitting did not need a
+ * second dock vocabulary — [`Dock`](crate::Dock) already answers "where inside this rectangle",
+ * and a pane is just a smaller rectangle to ask it about.
+ *
+ * Panes live in a tree per tab ([`PaneNode`](crate::PaneNode)). The tree says how the main
+ * region is divided; the frontend turns it into rectangles, exactly as it does for docks.
+ */
+export type PaneId = number;

package/src/generated/PaneNode.ts

@@ -0,0 +1,17 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { PaneChild } from "./PaneChild";
+import type { PaneId } from "./PaneId";
+import type { SplitDir } from "./SplitDir";
+
+/**
+ * How the main region of one tab is divided.
+ *
+ * A tree rather than a list because a split of a split is the thing people actually build — a chat
+ * on the left, and on the right a chat above a terminal — and a flat list of rectangles cannot say
+ * that without every consumer re-deriving the nesting from coordinates.
+ */
+export type PaneNode = { "kind": "leaf"; pane: PaneId } | {
+  "kind": "split";
+  dir: SplitDir;
+  children: Array<PaneChild>;
+};

package/src/generated/PluginEvent.ts

@@ -63,6 +63,7 @@ export type PluginEvent =
   | { "type": "composer_changed"; text: string }
   | { "type": "event"; name: string; data?: unknown; from: string }
   | { "type": "var_changed"; scope: VarScope; key: string; value?: unknown }
+  | { "type": "project_moved"; from: string; to: string }
   | { "type": "highlight_changed"; names: Array<string> }
   | { "type": "contributions_changed"; point: string }
   | { "type": "swarm_changed" }

package/src/generated/PullRequest.ts

@@ -0,0 +1,30 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { ChecksState } from "./ChecksState";
+import type { PullState } from "./PullState";
+
+/**
+ * One pull request, as much of it as a row can use.
+ *
+ * **Keyed by `branch`**, which is what makes one call answer for every worktree at once: a
+ * repository's pull requests come back together and each checkout finds its own by the branch it
+ * has out. Asking per branch would be one network round trip per row in the panel.
+ */
+export type PullRequest = {
+  number: number;
+  title: string;
+  /**
+   * For opening it. The forge's own URL, so nothing here has to know how to build one.
+   */
+  url: string;
+  /**
+   * The head branch. What a checkout matches itself against.
+   */
+  branch: string;
+  state: PullState;
+  checks: ChecksState;
+  /**
+   * How many checks have failed, for a row that wants to say `✗2` rather than `✗`.
+   */
+  checks_failed: number;
+  checks_total: number;
+};

package/src/generated/PullState.ts

@@ -0,0 +1,11 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Where a pull request has got to.
+ *
+ * Four states because that is what a person means by "what happened to it": one is a review you
+ * are waiting for, one is a review you have not asked for yet, one is done, and one is not going
+ * to happen. Draft is its own state rather than a flag on `Open` because on a row it is the whole
+ * difference between "somebody should look at this" and "I am still writing it".
+ */
+export type PullState = "open" | "draft" | "merged" | "closed";

package/src/generated/RemoteProject.ts

@@ -14,6 +14,24 @@ export type RemoteProject = {
   cwd: string;
   /**
    * Whether this node has a conversation open in it now.
+   *
+   * Meant something for exactly as long as this list was derived from live conversations: every
+   * project on it had one, so every one of them said `true` and a board drawing the flag drew
+   * one colour. A node now advertises the places it *works in* — which is the list its own panel
+   * shows, and includes the project you cleared out this morning — so the two states exist and
+   * the flag is worth reading.
    */
   active: boolean;
+  /**
+   * How many conversations are open in it there.
+   */
+  sessions: number;
+  /**
+   * How many of those are mid-turn.
+   *
+   * Separate from `sessions` because they are different questions and a board answers both in
+   * one row: `3 conversations · 1 working` is what the sidebar says about a local project, and a
+   * remote one should not have to say less.
+   */
+  running: number;
 };

package/src/generated/ScrollAmount.ts

@@ -0,0 +1,16 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * How far to move a window's scroll. See [`crate::ApiCall::WinScroll`].
+ *
+ * Verbs rather than a row number, for the reason [`CursorMotion`] is: only the core knows how many
+ * buffer rows the frontend last drew, so "half a screen" is a question the caller cannot answer and
+ * a caller that tried would answer it with a height. Signed, so one variant covers both directions
+ * and a binding for `<C-d>` is the binding for `<C-u>` with the sign flipped.
+ */
+export type ScrollAmount =
+  | { "kind": "lines"; n: number }
+  | { "kind": "half"; n: number }
+  | { "kind": "page"; n: number }
+  | { "kind": "top" }
+  | { "kind": "bottom" };

package/src/generated/SplitDir.ts

@@ -0,0 +1,12 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * Which way a split lays its children out.
+ *
+ * Named for what it does to the screen rather than for the key that made it, because those two
+ * disagree in every editor that has ever shipped one: Vim's `:vsplit` produces panes side by side,
+ * and a `Vertical` that means "stacked" to the layout code and "side by side" to the user is a
+ * bug waiting for its first off-by-one. `Row` is a row of panes; `Column` is a column of them.
+ * The *commands* say `right` and `down`, which is the one description nobody can misread.
+ */
+export type SplitDir = "row" | "column";

package/src/generated/TabId.ts

@@ -0,0 +1,10 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+/**
+ * One tab of one view: a title, and a tree of panes.
+ *
+ * Per view rather than per workspace, for the same reason a window is: what the agent produced
+ * is the workspace's, and where you are looking is yours. Two terminals attached to one
+ * workspace have their own tabs over the same conversations.
+ */
+export type TabId = number;

package/src/generated/TabInfo.ts

@@ -0,0 +1,27 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { PaneId } from "./PaneId";
+import type { PaneNode } from "./PaneNode";
+import type { TabId } from "./TabId";
+
+/**
+ * One tab of one view.
+ */
+export type TabInfo = {
+  id: TabId;
+  /**
+   * What the tab bar calls it.
+   *
+   * `None` is "name it after what is in it" — the conversation's title, the terminal's command —
+   * which is what a tab nobody has renamed should say, and it has to stay `None` to keep saying
+   * it: a title resolved once and stored is a tab still called `main` three conversations later.
+   */
+  title?: string | null;
+  root: PaneNode;
+  /**
+   * Which pane in this tab has the keyboard when the tab does.
+   *
+   * Per tab rather than per view, so that leaving a tab and coming back puts you where you were
+   * rather than in whichever pane happens to be first.
+   */
+  active_pane: PaneId;
+};

package/src/generated/UiEvent.ts

@@ -8,6 +8,8 @@ import type { NoticeKind } from "./NoticeKind";
 import type { Rect } from "./Rect";
 import type { SurfaceCell } from "./SurfaceCell";
 import type { SurfaceId } from "./SurfaceId";
+import type { TabId } from "./TabId";
+import type { TabInfo } from "./TabInfo";
 import type { WindowId } from "./WindowId";
 import type { WindowLayout } from "./WindowLayout";
 
@@ -45,7 +47,9 @@ export type UiEvent =
   | { "type": "surface_claimed"; surface: SurfaceId; win: WindowId; rect: Rect }
   | { "type": "surface_cells"; surface: SurfaceId; cells: Array<SurfaceCell> }
   | { "type": "surface_released"; surface: SurfaceId }
+  | { "type": "panes_changed"; tabs: Array<TabInfo>; active: TabId }
   | { "type": "focus_changed"; win: WindowId | null }
+  | { "type": "home_changed"; win: WindowId | null }
   | {
     "type": "message";
     level: MessageLevel;