@plumeai/plugin-sdk 0.0.0-stage → 0.1.3

package/dist/client/ui/src/lib/tiling.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 平铺树的几何：几棵平铺树（停靠面板、对话分屏）共用的那一半。
+ *
+ * 两棵树叶子不同——一个是面板种类，一个是会话——但分支长得一样：方向、每个孩子的份额、孩子。
+ * 分隔条在哪、拖到某个像素时近侧该占多少，只看分支，所以只写一份。叶子怎么排
+ * 各自留在自己的域里，那部分才真的不同。
+ */
+export type Axis = "row" | "col";
+/**
+ * 容器里的一个矩形，两个轴都按 0 到 1 的比例算。
+ *
+ * 用比例不用像素，这里才能保持纯函数：不要元素、不要测量、不要排版，首帧之前和之后算出来一样。
+ * 百分比直接写到元素上，窗口缩放由浏览器处理，这里不用重算。
+ */
+export interface Box {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/** 两棵树共有的形状：只要分支，叶子长什么样这里不关心。 */
+type Tiling = {
+    type: "leaf";
+} | {
+    type: "split";
+    dir: Axis;
+    sizes: readonly number[];
+    children: readonly Tiling[];
+};
+/**
+ * 两个窗格之间一条能拖的边界。
+ *
+ * 用它所属的分支和近侧的那个孩子来标识，这正是每棵树的 `resize` 要的参数——分隔条可以直接动手，
+ * 中间不用有谁再去推算它是「哪条边」的分隔条。
+ */
+export interface SplitterBox extends Box {
+    path: number[];
+    index: number;
+    dir: Axis;
+    /** 近侧窗格现在的份额，拖动从分隔条实际所在的地方开始。 */
+    share: number;
+    /** 两侧窗格份额之和，也就是这条分隔条能拖动的范围。 */
+    pair: number;
+    /**
+     * 这条分隔条所分开的那个分支的框。
+     *
+     * 带在这里而不是之后再查：拖这条分隔条时就是在这个参照系里量的，而产出分隔条的那一刻它已经知道了。
+     */
+    split: Box;
+}
+export declare const FULL: Box;
+/**
+ * 分隔条的抓取区，跨在两个窗格的边界上。
+ *
+ * 和侧栏的 `ResizeHandle` 一样是 9px，理由也一样：能稳稳点中、又不至于成为一条看得见的边框的最窄宽度。
+ */
+export declare const SPLITTER_HIT = 9;
+/** 键盘每按一下调多少，按份额算。按住 Shift 翻倍。 */
+export declare const SPLITTER_STEP = 0.02;
+/** 分隔条上那段握把多长：够长才读得出是握把，够短才不像边框。 */
+export declare const GRIP_SPAN = 30;
+/**
+ * 比例转成 CSS。
+ *
+ * 要取整，但故意不取到整百分比。框是按精确的比例算的，正好铺满；低精度写进 CSS 会把算术刚合上的
+ * 两格之间的缝又撑开，窗格旁边露出一道亚像素宽的窗口底色。六位小数远超任何屏幕的分辨率，又短到
+ * 帧与帧之间字符串不变——这一点要紧：每帧都变的样式字符串会打断它本该在过渡的那个过渡。
+ */
+export declare const pct: (fraction: number) => string;
+/** 给定在轴上从哪开始、占多少，从父框里切出孩子的框。 */
+export declare function slice(rect: Box, dir: Axis, offset: number, share: number): Box;
+/**
+ * 所有能拖的边界。
+ *
+ * n 个孩子的分支有 n−1 条——分支的外沿是包着它的东西的边，不是两个窗格之间的边界。
+ *
+ * 每条都画成零厚度的线；抓取区由组件加，只有组件知道九个像素是多宽。
+ */
+export declare function layoutSplitters(tree: Tiling, within?: Box): SplitterBox[];
+/**
+ * 把指针位置换算成分隔条近侧窗格该占的份额。
+ *
+ * 参照系是分支自己的框，不是容器的。嵌套分支里的分隔条在**那个**分支的长度里移动，按整个窗口量的话
+ * 速度就不对——窄列里拖不动，宽列里两头都冲出去。
+ *
+ * `position` 是拖动轴上的客户区坐标：横向分支是 `clientX`，纵向是 `clientY`。
+ */
+export declare function shareFromPointer(handle: SplitterBox, position: number, container: Box): number;
+export {};

package/dist/client/ui/src/lib/typing.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 一个字符串一个字一个字地改写成另一个。
+ *
+ * 一段对话在运行时读完第一条消息之前，标题是「新对话」，之后真标题才落下来。一帧之内直接替换，是侧栏里
+ * 唯一一处「行变了，却和你刚做的事无关」的时刻；硬切的话读起来像列表在指针底下自己重排了一次。改写一遍
+ * 传达的是同一件事，只是成了一个看得见过程的事件。
+ *
+ * 共同前缀保留不删，于是「查一下依赖」→「查一下依赖为什么装不上」不会先退回到空，而是只打出尾巴。
+ * 这种情况很常见：存下的标题是从提示词里取的，它和替换它的那个往往开头一样。
+ *
+ * 按码点而不是 UTF-16 单元：`[...text]` 让 emoji 和其他星际字符保持完整，`slice` 会把代理对切成两半，
+ * 有一帧画出替换字形。
+ */
+/**
+ * `from` 到 `to` 之间的每个中间字符串，按顺序，最后一个是 `to`。
+ *
+ * 没什么可演的时候是空的——两个字符串相同，或者原来没有值、第一个值刚到——调用方读作「不演，直接画」。
+ */
+export declare function typingFrames(from: string, to: string, maxFrames?: number): string[];

package/dist/client/ui/src/motion/RollWords.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+/**
+ * 一行流水行里换掉的那句话：新的从一道缝里落进来，词框的宽度跟着平滑地变。
+ *
+ * 只滚字、不管宽的话，一句短的换成一句长的那一帧，后面的箭头、+N -M 直接被顶出去一截——字在滚，
+ * 行尾在跳，看上去比不滚还生硬。宽度在换的那一下钉成像素：量出新宽，先钉回旧宽、再设新宽，过渡走完
+ * 就放回 auto。一直钉着的话，网页字体晚到、改字号之后词框还是旧的宽度，字会被截掉。
+ *
+ * 扫光（`glide`）挂在字自己身上，不挂在外层：滚进来的那层带着 transform 被单独合成，外层的
+ * `background-clip: text` 裁不到它，滚动那一下字会整个消失。所以用它的行，外层不要再挂一道扫光。
+ *
+ * 只是往后长的一句（`text` 变了、`rollKey` 没变）不滚，只缓宽度：前面的字原地不动，新接上的那截随着框
+ * 变宽从句尾露出来。
+ */
+export declare function RollWords({ rollKey, text, from, glide, enter, children, }: {
+    /** 换了它才算换了一句；同一句里参数还在流进来，不重新滚。 */
+    rollKey: string;
+    /** 这句话现在的字。给了它，字变了也缓宽度，但不滚。 */
+    text?: string;
+    /** 挂上时从这个宽度缓过来：这一行接替了原地另一行的字（比如一列步骤里后一步接替前一步那一行）。 */
+    from?: number;
+    glide?: boolean;
+    /** 挂上的时候也滚：这一行接替了原地的另一行。 */
+    enter?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/client/ui/src/motion/RollingText.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 装着值的那个框——滚动的是它，溢出的也是它。
+ *
+ * 导出是因为要截断的父元素得找得到它：外层的宽度受它的父元素约束，所以外层永远不溢出，任何要量「这个是不是
+ * 被截了」的东西都得去问里面这个框。
+ */
+export declare const ROLL_VALUE = "plume-roll-value";
+/**
+ * 一个值替换另一个值，不管发生在哪里。
+ *
+ * 原地变化的字——输入框里的推理强度、刚选的模型、权限模式、「展开显示」变成「收起」——不滚的话，眼睛除了
+ * 字形不同以外收不到任何「发生了什么」的信号：在正拖着的控件上读起来像渲染瑕疵，在刚点过的控件上读起来像
+ * 那一下点了没用。
+ *
+ * 动作是 `ui/motion.css` 里的 `.plume-roll`——总是往下，一连串的变化读起来是一个东西在被拨动，而不是字在闪。
+ * 有了这个组件，用上它就是选对元素的事，而不必记住一个两步的写法（`key={value}` 加 `plume-roll`）。
+ *
+ * 给标签用，不给读数用。会跳的数——token 数、计时器、百分比——是在连续变化而不是被替换，每跳一下滚一次，
+ * 一块安静的仪表就成了整轮里一直在余光里动的东西。那些用 `tabular-nums` 定住。
+ */
+export declare function RollingText({ children, className, rollKey, }: {
+    children: string | number;
+    /** 落在外层元素上，它默认是 `inline`——需要的地方给它 `block`。 */
+    className?: string;
+    /** 改写什么算「换了一个值」，给带着一段总在变的部分的文字用。 */
+    rollKey?: string | number;
+}): import("react").JSX.Element;
+/**
+ * 这个值是否被替换过——首次绘制时是 false，从第一次变化起是 true。
+ *
+ * 有两件事靠它做对，而它们往相反的方向拉。
+ *
+ * 首次绘制不能动。挂上就滚的话，菜单一打开每个标签都落进位，叠在菜单自己的进场上——两个不同方向的动作，
+ * 读起来像面板在你面前被拼起来。
+ *
+ * 可类也不能来来去去，这一点更隐蔽：给元素加上 `animation` 就会**开始**那个动画。一个在下一次无关渲染时
+ * 退回 false 的标记，会在再下一次渲染时把类加回来，于是输入框里任何一个标签一变，所有标签都滚一遍。所以它
+ * 是锁存的：一旦为 true 就一直是 true，此后动画完全由 `key` 变化引起的重新挂载来驱动。
+ *
+ * 在渲染期间调整状态，是从一个变了的 prop 推导状态的官方做法——React 丢掉这一遍、立刻重跑组件，于是类和新
+ * key 落在同一次提交里，元素挂上时就已经在动。
+ */
+export declare function useRolled(value: string | number): boolean;

package/dist/client/ui/src/motion/TypedText.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 一个字符串一个字一个字地改写成下一个。
+ *
+ * 返回这一帧该显示的东西。第一个值不演——原来那里什么都没有，谈不上替换——关掉动效时的任何变化也不演。
+ *
+ * 做成 hook 而不是组件，因为这段字通常另有去处：侧栏把它交给 `ScrollText`，由它量字符串决定这一行悬停时
+ * 滚不滚。交给它一个渲染好的元素，就是在量一个正在动的目标。
+ */
+export declare function useTypedText(text: string): string;

package/dist/client/ui/src/motion/freeze.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 拖动期间一动不动。
+ *
+ * 有几个元素会缓动到新的几何位置上，布局自己变的时候这是对的，指针在拖边界的时候就错了：每一帧开始的
+ * 过渡都被下一帧盖掉，窗格追着指针跑而不是跟着它，永远落不稳。
+ *
+ * 冻结原先是 `<html>` 上的一个标记加上以它为键的规则——`:root[data-resizing] *`。读起来顺，却是拖动时
+ * 最贵的一件事。在一个 8,948 条消息、屏上 8,585 个元素的真实会话里量的：
+ *
+ *   设 data-dock-dragging   94ms      （通配选择器）
+ *   设 data-dock-dragging   44ms      （收窄到 `:root[data-…] .plume-dock-pane` 之后）
+ *   设一个无关属性            0ms      （对照）
+ *
+ * 收窄选择器不够，中间那行就是原因。祖先上的属性仍然要对它下面的整棵子树求一遍，所以根上的标记是对整份
+ * 文档提的问题，不管答案最后多具体——而一次拖动进出各要翻两三个这样的标记。抓住东西那一刻的卡顿就是它：
+ * 不是布局，不是 React，是一个属性。
+ *
+ * 所以改成点名。`.plume-freeze` 标出拖动真正会改变几何的那些元素——窗格、侧栏所在的框、高度跟着放得下
+ * 多少走的折叠组——这里只给它们加标记，样式引擎经类索引就能找到，不用遍历任何东西。
+ */
+export declare function freezeMotion(): () => void;
+export declare function inertPanes(): () => void;

package/dist/client/ui/src/motion/held.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 一句话至少挂多久才换下一句。
+ *
+ * 一段探索里 read、grep 常常一两百毫秒就来一次，来一次换一句的话，字还没读完就滚走了，整行一直在抖。
+ * 650ms 是 OpenClaude Desktop（照官方 Claude 桌面端）的取值。它必须比滚进来的那段动画（`DURATION.slow`）
+ * 长，否则上一句还没落定下一句就开始滚。
+ */
+export declare const HOLD_MS = 650;
+/**
+ * `key` 换了之后，返回的那个至少要在屏幕上待满 `ms` 才跟着换。
+ *
+ * 待满以前新来的几个 key 不排队：到点时直接换成那一刻最新的那个，中间的跳过。要的是每一句都读得完，
+ * 不是每一句都出现过。
+ *
+ * 用布局副作用换，不用普通副作用：已经待满的那一下当场换掉，不先把旧的那句再画一帧。
+ */
+export declare function useHeldKey(key: string, ms?: number): string;

package/dist/client/ui/src/motion/loaders.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 「正在忙」的三个记号，以及它们各管哪里。
+ *
+ * 分成两个而不是一个，是因为「正在忙」其实是两句话：
+ *
+ * `StatusSpinner` 说的是**这一条正在跑**。它是某个对象的状态值，出现在一列同族状态记号中间
+ * ——上下左右是 ✓、✗、时钟、待办圆点——同屏可能好几个在跑，你是旁观者。任务清单的每一步、
+ * 流水线的每一行、工具卡的运行中都是它。
+ *
+ * `ActionSpinner` 说的是**你按的那下正在回来**。它顶替的是一个刚被按下的动作图标（刷新、保存、
+ * 下载、发布），或者填在一个刚被清空的角标位上；同屏通常只有一个，你在等它。按钮上的忙碌
+ * 都是它。
+ *
+ * 判据是可以机械执行的：把这个记号删掉，原地会出现什么。是状态图标就用 `StatusSpinner`，是
+ * 一个可点的动作图标（或一个计数）就用 `ActionSpinner`。
+ *
+ * `BreatheLoader` 只说「这个会话在跑」：侧栏的会话行，和替一个会话报状态的地方（定时任务卡片上那次运行），
+ * 那一处问的不是同一个问题，见它自己的注释。
+ *
+ * 前两个都是 r=10 的描边圆，和 lucide 的 `CheckCircle2`、`XCircle`、`Clock` 精确重合——它们
+ * 就是那一列里的邻居。换成星芒之类的别的形状，一列圆里混一个星，每次都会从队列里跳出来一次。
+ * 几何和那些数字怎么定的，写在 `@plume/styles` 的 `ui/motion.css` 的加载记号一节。
+ */
+/**
+ * 一圈虚线，匀速转。
+ *
+ * 六段等分，所以转过 60° 就回到自身：没有可追踪的端点，眼睛抓不到锚点。这是它敢转、而一段
+ * 弧不敢的原因——一段弧有头，十几个同时在屏幕上，每一个都在自己的相位上把视线勾一下。
+ *
+ * 颜色走 `currentColor`，默认跟着周围的文字走。要它说话大声一点的地方（任务清单里正在跑的
+ * 那一步、流水线里排队的那一条）自己传 `text-accent`、`text-warning`。
+ */
+export declare function StatusSpinner({ size, className }: {
+    size?: number;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * 一段亮弧沿着一圈淡轨道跑。
+ *
+ * 轨道是这个记号的重点，不是装饰：亮弧单独转的话，图形的轮廓跟着弧一起走，在按钮那个方寸
+ * 之间会读成「有东西在里面甩」。垫一圈淡的，形状就恒定是一个完整的圆，动的只有亮处。
+ *
+ * 轨道浓度走 `--plume-track`，默认 0.18。实心底的按钮（`bg-ink`、`bg-accent`）上 `currentColor`
+ * 是底色的反色，0.18 基本看不见，那几处传 `onFill`——见 `ui/motion.css` 里那一档的注释。
+ */
+export declare function ActionSpinner({ size, className, onFill, }: {
+    size?: number;
+    className?: string;
+    /** 画在实心底的按钮上（`bg-ink` / `bg-accent`），轨道要更浓才看得见。 */
+    onFill?: boolean;
+}): import("react").JSX.Element;
+/**
+ * 一圈波纹离开静止的中心，颜色一路走过调色板。
+ *
+ * 给侧栏的会话行（替一个会话报状态的地方也用它，同一个会话在两处是同一个记号）。那一列可能同时有好几行在跑，而你还要用它读标题——所以这里连「亮处在走」都不
+ * 要：什么都不旋转、什么都不位移，余光里它只是缓缓涨落的一团。换成上面那两个的话，一列里并排
+ * 三四个各自明灭，读标题时总有东西在旁边闪。
+ *
+ * 颜色走完 accent → violet 的那 2.4 秒，是它说「跑了多久」的方式：扫一眼知道它活着，
+ * 多看一会儿知道它**还**活着，而没有任何东西变快或变响。
+ */
+export declare function BreatheLoader({ size, className }: {
+    size?: number;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/client/ui/src/motion/reduced.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 动效该不该停住。
+ *
+ * 放在这里而不是和主题放在一起，因为这是**动画**要问的事，而动画都在 `motion` 里。它只读文档，不读别的——
+ * 没有 store、没有设置模块——所以 `@plume/ui` 里的组件用它不必伸手到某个功能里去。
+ *
+ * 给 CSS 表达不了的那些动画问的：此刻是不是关掉了动效。
+ *
+ * 样式表自己的动画由全局的 `:root[data-reduce-motion]` 规则管，可一段一步步走过中间字符串的改写是状态，
+ * 不是样式——没有时长可以压短，只有帧可以不跑。在要用的那一刻读，不订阅：这些都是一次性的动画，已经开始的
+ * 那个可以跑完。
+ */
+export declare function motionReduced(): boolean;

package/dist/client/ui/src/motion/ticked.d.ts

@@ -0,0 +1,24 @@
+import { type RefObject } from "react";
+/** 运行行上扫过摘要的那道光，见 `ui/motion.css` 的 `.plume-glide`。 */
+export declare const GLIDE: ReadonlySet<string>;
+/**
+ * 没有终点的装饰动画（侧栏的呼吸点、运行行上的扫光）改成按拍走：关键帧和曲线还在 CSS 里，只是
+ * 不再由浏览器每帧推，而是暂停住、每拍把 `currentTime` 往前拨一次（`ticker.ts`）。
+ *
+ * 为什么不留给浏览器：呼吸点动 `border-color` / `background`、扫光动 `background-position`，都只能
+ * 在主线程逐帧重绘；120Hz 屏上只要一个会话在跑，整页就每秒重画 120 次，哪怕正文一个字没动。量过：
+ * 模型还没出字时 GPU 进程 34%、渲染进程 25%，单关呼吸点降到 25% / 18%，两样都在才降不下去——
+ * 和正文那边是同一回事，见 `ticker.ts`。`steps()` 也救不了：浏览器对不能合成的动画每帧都要服务一次，
+ * 不看曲线是不是阶梯。
+ *
+ * 改成只动透明度和缩放、交给合成器也试过（变色换成叠一层 violet 淡入淡出）：主线程是不管了，可
+ * 合成器照样每个 vsync 出一帧，模型挂住时 GPU 进程 22.6%、渲染进程 11.2%，按拍走是 11.9% / 10.4%。
+ * 一秒 120 帧再便宜，也比 30 帧贵。
+ *
+ * 窗口最小化时停在原处，失焦时照走（跟着拍子降到每秒 10 次）。不在失焦时停：并排摆着的窗口人还看得见，
+ * 扫光一定住就像这一轮卡死了。最小化才是真没人看——而主窗口关了 `backgroundThrottling`，页面自己
+ * 察觉不到（`visibilityState` 仍是 visible，rAF 照跑 120 帧），只能由主进程告诉它，见 `windowMinimized`。
+ *
+ * 只认 `names` 里点名的：同一个元素上可能还有要跟手的动画（摘要悬停时的滚动），那些照常逐帧。
+ */
+export declare function useTickedAnimations(ref: RefObject<HTMLElement | null>, names: ReadonlySet<string>, active?: boolean): void;

package/dist/client/ui/src/motion/ticker.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 流式输出期间会动的东西共用的一拍：放字、淡入、数字爬升、思考球。用法和
+ * `requestAnimationFrame` 一样，只是回调不在每一帧来，而是约 30 次每秒（窗口最小化时 10 次）、
+ * 并且同一拍里的全部一起来。
+ *
+ * 为什么要一拍：120Hz 屏上，这几样东西各开一个 rAF，只要其中一个这一帧改了页面，整条样式、布局、
+ * 绘制、合成就得为这一帧跑一遍。正文其实每秒只长三四十次，剩下的帧全是这几个循环各自撑起来的。
+ * 量过：主会话加三个侧边聊天同时输出，渲染进程 105–114%、GPU 53%；把 rAF 合到 30Hz 并停掉
+ * CSS 动画后 44% / 17%。只做其中一样只降两成——另一样还在每帧弄脏页面。
+ *
+ * 同一拍一起跑也是要点：几个面板各自放字、各自淡入，挤进同一个 rAF 回调里，React 把它们的
+ * setState 合成一次提交，页面也只脏这一帧。
+ *
+ * 用户直接操作的动画（拖动、点「回到底部」的那一下滑行）不走这里，它们要跟手。贴底跟随的弹簧也不走：
+ * 试过按拍走，视口每四帧才挪一次，量到相邻帧速度差 p95 从 1px 涨到 10.5px，
+ * 就是 `useFollowBottom` 专门要避开的那种「一顿一顿」。正文按拍长、视口逐帧追，台阶由弹簧抹平。
+ * 折中成最多 60Hz 也试过：每秒只省下约 28ms 主线程（滚动位置更新加悬停命中测试），速度差 p95 照样
+ * 涨到 8.5px，不值。
+ */
+/** 一拍多长。 */
+export declare const TICK_MS: number;
+/**
+ * 窗口是不是最小化了。页面自己察觉不到（`visibilityState` 仍是 visible、rAF 照跑），由产品接主进程的
+ * 最小化通知，经 `setWindowMinimized` 喂进来。最小化时拍子放慢，`ticked.ts` 的装饰动画停住，
+ * 贴底跟随不滑。
+ */
+export declare function windowMinimized(): boolean;
+export declare function setWindowMinimized(value: boolean): void;
+/** 下一拍调用 `callback`，参数和 rAF 一样是帧时间戳。隔了一阵没人要拍时，第一拍就在下一帧。 */
+export declare function requestTick(callback: (now: number) => void): number;
+export declare function cancelTick(id: number): void;

package/dist/client/ui/src/motion/tokens.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 时长和曲线，给读不到 CSS 变量的代码用。
+ *
+ * 以 CSS 为准——`@plume/styles` 的 theme.css 定义它们，每张样式表都读那里。这个文件是给少数几个由
+ * JavaScript 驱动的动画的：一个要比过渡活得久的 `setTimeout`，一次要缓动字符串的 Web Animations 调用。
+ *
+ * 一个数写两份恰恰是最会漂开的安排，所以改了一处，另一处必须一起改。
+ *
+ * 档位按**什么在动**分，不按它有多重要：
+ *
+ *   quick   一个状态，不是一个位置——悬停、按下、手指底下变的颜色
+ *   base    在移动或改变大小的东西：一个窗格、滑块的把手、一列让出宽度
+ *   slow    原来不在、现在到来的东西——一段展开
+ *
+ * 曲线说的是东西往哪个方向去。`out` 减速落定，到来的东西看上去是停稳了而不是被卡住；`in` 是它的镜像，
+ * 给离开的东西。
+ */
+/** 毫秒。和 `--plume-t-*` 同一组数。 */
+export declare const DURATION: {
+    readonly quick: 150;
+    readonly base: 220;
+    readonly slow: 340;
+};
+/** 和 `--plume-e-*` 同一组字符串。 */
+export declare const EASING: {
+    readonly out: "cubic-bezier(0.22, 1, 0.36, 1)";
+    readonly in: "cubic-bezier(0.55, 0, 1, 0.45)";
+    readonly soft: "cubic-bezier(0.4, 0, 0.2, 1)";
+};

package/dist/client/ui/src/motion/useNow.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 此刻的时间，`active` 时每 `every` 毫秒重画一次：给秒表、倒计时这类在走的读数用，不走的时候一次也不重画。
+ *
+ * 变成 `active` 的那一下先对一次表：不对的话，挂上以后过了很久才开始走的读数，头一拍显示的是挂上那一刻。
+ */
+export declare function useNow(active: boolean, every: number): number;

package/dist/client/ui/src/overlay/Confirm.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 在拿不回来的事情之前先问一句。
+ *
+ * 应用里很多东西一次点击就删掉了——插件的目录、模型、MCP 服务、文件、整个会话——而每一个都离你本来
+ * 就要点的某个控件只有一次点击的距离。
+ *
+ * 它们共用一个样子，居中在窗口上、压着遮罩。如果锚在弹出它的控件上（理由是按钮和问题之间的联系值得
+ * 保留），实际会在应用的每个角落得到不同的答案：这里是挂在菜单上的卡片，那里是指针旁的卡片，在全屏
+ * 打开的面板里，问题出现在那一行碰巧在的位置而不是你正看着的地方。一个让一切停下来的问题就该长成
+ * 那个样子，而模态框只有一个该在的地方。
+ *
+ * 两个入口，一个样子，一个位置：
+ *
+ *   - `useConfirmer()` 给满是删除按钮的页面——包住处理函数，`element` 渲染一次；
+ *   - `useConfirmGate()` 给要在循环里等回答的地方。
+ *
+ * 只用于撤销不了的事。归档、停用、取消置顶都能自己放回去，在这些上面确认，等于教人对真正要紧的那些
+ * 也一路点过去。
+ */
+export interface ConfirmOptions {
+    /** 问题，说出是哪个东西。「卸载 Chrome？」——而不是「确定吗？」。 */
+    title: string;
+    /** 代价是什么，一行。标题已经说全了就省掉。 */
+    detail?: React.ReactNode;
+    /** 动词，写在做这件事的按钮上。 */
+    confirmLabel: string;
+    /** 取消按钮上的字，默认「取消」。 */
+    cancelLabel?: string;
+    /**
+     * `danger` 是默认，因为这个东西本来是给删除用的。
+     *
+     * `normal` 留给另一类问题：不是「这个删了拿不回来」，而是「以后要不要自动做这件事」。
+     * 两种都该停下一切来问，但只有前一种该是红的——把每个问题都画成危险，等于没画过危险。
+     */
+    tone?: "danger" | "normal";
+    onConfirm: () => void;
+    /**
+     * 取消也要做点什么的时候。
+     *
+     * 绝大多数确认框的取消就是「什么都别发生」，所以这是可选的。但有一种问题不是这样：
+     * 「以后要不要自动做这件事」——那里的取消是一个回答（不要），把它当成没问过，
+     * 意思就是下次还问。
+     */
+    onCancel?: () => void;
+    /**
+     * 同一个动词的另一种做法，比如「删除此会话」旁边的「删除 3 个会话」。
+     *
+     * 画成次要按钮，放在主按钮左边；有它的时候「取消」挪到最左，三颗按钮不挤成一排。
+     */
+    alternate?: {
+        label: string;
+        onConfirm: () => void;
+    };
+    /** 说明和按钮之间的那一块，比如「不再询问」。大多数问题用不着。 */
+    children?: React.ReactNode;
+}
+/**
+ * 问题，和两条出路。
+ *
+ * 焦点特意放在取消上：这个面之所以存在，是因为一件不可逆的事只差一次点击，把键盘放在不可逆的那一半上
+ * 等于把问题原样还回去。
+ */
+export declare function ConfirmBody({ title, detail, confirmLabel, cancelLabel, tone, onConfirm, onCancel, alternate, children, }: ConfirmOptions & {
+    onCancel: () => void;
+}): import("react").JSX.Element;
+/**
+ * 放在应用模态面上的问题：居中、压着遮罩、Escape 或点遮罩关掉。
+ *
+ * 这三样都由 `Overlay` 提供，而且和应用里其它对话框拿到的方式一样——这正是通过它来问、而不是在每个
+ * 调用处各拼一个的意义。
+ */
+export declare function Confirm({ onCancel, ...options }: ConfirmOptions & {
+    onCancel: () => void;
+}): import("react").JSX.Element;
+/**
+ * 给满是删除按钮的页面用的一个确认。
+ *
+ * 每颗按钮交出自己的问题和自己的后果；面、两颗按钮的措辞、取消是安全的那个，这些在这里定。否则一个
+ * 有六行可删除内容的页面要带着同一份状态的六个副本。
+ */
+export declare function useConfirmer(): {
+    /** 从会删除东西的那颗按钮的点击处理里调用。 */
+    ask: (options: ConfirmOptions) => void;
+    /** 在组件里任意位置渲染一次。 */
+    element: import("react").JSX.Element | null;
+};
+/**
+ * 同一个问题，可以 await。
+ *
+ * 给在循环里问的调用方——粘贴五个文件，其中两个重名——回答得先回来，下一步才能定。写成 promise，
+ * 读起来就是普通的顺序代码，而不是每个分支一个回调。
+ */
+export declare function useConfirmGate(): {
+    ask: (options: Omit<ConfirmOptions, "onConfirm">) => Promise<boolean>;
+    element: import("react").JSX.Element | null;
+};

package/dist/client/ui/src/overlay/ContextMenu.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 在右键的位置打开的菜单。
+ *
+ * Electron 没有默认的右键菜单，没有这个的话，在应用里任何地方右键都什么也不发生——文件上、编辑器里、
+ * 输入框里都是。`Popover` 已经会把面挂在一个点上而不是元素上；缺的是围绕它的一点约定：菜单是关于
+ * 哪个目标的，以及选中任何一行都会关掉它。在这里写一次，文件树、编辑器和普通输入框就不会各走各的。
+ */
+import { type PopoverWidth } from "./Popover.tsx";
+/**
+ * 记下一次右键：发生的位置，和发生在什么东西上。
+ *
+ * 目标跟着一起记，因为右键菜单几乎总是关于某一行的，而之后再从事件里读出「哪一行」是不可能的——
+ * 菜单渲染时指针早就移走了。带类型，菜单就不会为错误种类的东西搭起来。
+ */
+export declare function useContextMenu<T = void>(): {
+    anchor: {
+        x: number;
+        y: number;
+    } | null;
+    /** 右键之前是 null；渲染菜单前先用它收窄类型。 */
+    target: T | null;
+    open: boolean;
+    show: (event: React.MouseEvent, target: T) => void;
+    close: () => void;
+};
+/**
+ * 面本身。
+ *
+ * 每一行都会关掉它，在这里处理而不是每一项各自记得：右键菜单里没有不是动作的行，点完还开着的那个会是
+ * 应用里唯一这样的菜单。监听在冒泡阶段，所以行自己的处理已经先运行了。
+ */
+export declare function ContextMenu({ anchor, onClose, width, children, }: {
+    anchor: {
+        x: number;
+        y: number;
+    } | null;
+    onClose: () => void;
+    width?: PopoverWidth;
+    children: React.ReactNode;
+}): import("react").JSX.Element | null;

package/dist/client/ui/src/overlay/Dialog.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 居中对话框的里面：标题、可选的状态、两端渐隐的正文、按钮。
+ *
+ * 卡片归 Overlay 管——圆角、遮罩、Escape。各功能自己重搭一遍的话，会发明第二种圆角，在标题和按钮之间
+ * 画一道细线，两者读起来就不再是一家。这里只有内边距和几个槽位，不画分隔线。这里的边界是留白。
+ */
+import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from "react";
+import { type Dismiss } from "./Overlay.tsx";
+/**
+ * 对话框底下的那一颗按钮。上面写着它会做的那件事。
+ *
+ * **写字，不画图标。** 这些按钮曾经有好几处只放一个 ✕ 和一个 ✓，名字挂在 tooltip 上。工具栏
+ * 里的图标按钮可以这么省——周围一排东西替它说明它属于哪一类；对话框底下这两颗没有这个周围，
+ * 它们是这次操作的结论本身，一个要说清按下去会发生什么，另一个要说清不按会怎样。一个勾在
+ * 「删除会话」「卸载插件」「导入 33 个模型」上长得一模一样，而读出区别的唯一办法是把鼠标停
+ * 上去等一个 tooltip——这正是一个「停下一切来问」的界面最不该要求的动作。
+ *
+ * `label` 留着，但只当 tooltip 用：可见的字已经是它的名字了。
+ */
+export declare function DialogAction({ children, onClick, tone, disabled, autoFocus, label, className, ...rest }: {
+    children: ReactNode;
+    onClick?: () => void;
+    tone?: "secondary" | "primary" | "danger";
+    disabled?: boolean;
+    autoFocus?: boolean;
+    /** 只当悬停提示。可见的字已经是按钮的名字。 */
+    label?: string;
+    className?: string;
+} & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "onClick" | "type">): import("react").JSX.Element;
+export declare function DialogFrame({ title, icon, detail, status, children, actions, height, bodyClassName, className, ...rest }: {
+    title: ReactNode;
+    icon?: ReactNode;
+    detail?: ReactNode;
+    /** 放在正文里、滚动区上方——进度、警告，任何不能被滚走的东西。 */
+    status?: ReactNode;
+    children?: ReactNode;
+    actions: ReactNode;
+    height?: number;
+    /**
+     * 滚动的正文最高能长到多高。只给是表单而不是问题的对话框用——默认值按一段话加一个列表定的，
+     * 设置表单放在它下面一次只能滚出三个字段。
+     */
+    bodyClassName?: string;
+    className?: string;
+} & Omit<HTMLAttributes<HTMLDivElement>, "title" | "children">): import("react").JSX.Element;
+/**
+ * 里面放着 `DialogFrame` 的 `Overlay`。
+ *
+ * `actions` 和 `children` 可以是 `dismiss` 的函数，关对话框的按钮应该用它：`dismiss()` 播完退场再运行
+ * `onClose`，`dismiss(after)` 改为运行 `after`。按钮直接调用 `onClose` 会在那一帧卸掉对话框——那样
+ * 只有 Escape 和点遮罩是怎么来的就怎么走。
+ */
+export declare function Dialog({ onClose, width, label, returnFocus, actions, children, ...frame }: {
+    onClose: () => void;
+    width?: number;
+    label?: string;
+    returnFocus?: HTMLElement;
+    actions: ReactNode | ((dismiss: Dismiss) => ReactNode);
+    children?: ReactNode | ((dismiss: Dismiss) => ReactNode);
+} & Omit<Parameters<typeof DialogFrame>[0], "actions" | "children">): import("react").JSX.Element;