@huanlin/dsh-plugin-input-history 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+dsh-plugin-input-history
+Copyright (C) 2026 Huanlin
+
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.

package/README.md

@@ -0,0 +1,115 @@
+<p align="center">
+  <a href="https://dshfind.com/zh/plugins/huanlinoto/dsh-plugin-input-history"><img src="https://dshfind.com/api/card/huanlinoto/dsh-plugin-input-history?lang=zh" alt="dsh-plugin-input-history card"></a>
+</p>
+
+# dsh-plugin-input-history
+
+[![npm version](https://img.shields.io/npm/v/@huanlin/dsh-plugin-input-history)](https://www.npmjs.com/package/@huanlin/dsh-plugin-input-history)
+
+> 终端式 prompt 历史导航：在 DSH 输入框按 ↑/↓ 切换最近发送过的消息。
+
+在 DSH 的 prompt 输入框中按 **↑** 方向键，自动填入上一条已发送的 prompt；继续按 ↑ 向更旧的条目回溯，按 ↓ 向更新条目前进，按到最新条目之后再按 ↓ 恢复用户原本正在编辑的草稿。历史跨会话共享、持久化到 `localStorage`，刷新浏览器后仍然保留。
+
+## 功能
+
+- **↑ / ↓ 切换历史**：在 DSH prompt 输入框（聊天页底部那个 textarea）按方向键，从最近一条 prompt 开始向旧回溯，或向新前进。
+- **草稿保留**：切到历史预览后，按 ↓ 越过最新条目会自动恢复用户原本正在编辑的草稿——不会丢失在途文本。
+- **跨会话全局持久化**：历史来自所有会话的 `user` + `steering` 消息，存到 `localStorage`（FIFO，500 条上限），刷新浏览器、新建会话、切换 workspace 都保留。
+- **多行边界触发**：ArrowUp 仅在光标位于第一行任意位置时触发；ArrowDown 仅在最后一行任意位置时触发。多行编辑时方向键仍正常移动光标，不会被劫持。
+- **IME 安全**：中文/日文输入法候选词状态按方向键不会被劫持（遵循 DSH core InputBar 的 IME 守卫约定，issue #535）。
+- **斜杠菜单兼容**：斜杠命令菜单打开时，方向键归菜单高亮导航使用，插件不动。
+- **零源码 patch**：纯插件，通过 `conversation.composer.dock` 隐藏条目挂载 `document` 级 `keydown` 监听器。不修改 DSH 源码任何文件。
+
+## 架构
+
+单 bundle 双入口（host `.` + 浏览器 `./client` + invariant `./invariant`），仿照 `dsh-spur` / `dsh-auto-blame`。
+
+- **宿主半边**（`src/index.ts`）：空 `apply`——纯客户端插件。
+- **浏览器半边**（`src/client/index.ts`）：
+  - 注册 `conversation.composer.dock` list slot（id `dsh-plugin-input-history`，order 100）。dock 条目渲染一个 `display: none` 的不可见 anchor，仅负责**历史收集**（每次 render 读 `session.nodes`，新 user/steering 文本 append 到 store）。
+  - 在 `apply` 里直接挂 `document.addEventListener('keydown', ...)` bubble-phase 监听器，负责**历史导航**。监听器放在 `apply` 而非 dock 组件里，因为 dock 是 session scope，而 DSH 把 blank session 当作 hero 渲染（`ConversationRoot.tsx:79-80`），hero 模式下 dock 不挂载（`ConversationRoot.tsx:156` 的 `!hero` 守卫）。放在 `apply` 确保健听器始终在线。
+- **纯函数模块**：
+  - `src/client/history.ts`：`appendHistory` / `nextIndex` / `entryAt` / `HistoryStore`（localStorage 后端，quota 异常降级为内存）
+  - `src/client/dom.ts`：`cursorLineInfo`（多行边界判断）/ `findComposerTextarea`（DOM 查询）
+  - `src/client/ime.ts`：`isImeComposition`（IME 守卫）
+
+### 历史回填机制：native setter + dispatch input event
+
+监听器不通过 `inputActions.setDraft`（那是 per-session 的，通过 slot provide 注入，hero/blank 模式下 dock 不挂载时拿不到）。而是用 native prototype setter 改 textarea.value + dispatch `input` event，触发 InputBar 的 `onChange` → `keyboard.setDraft`——与用户手动输入走同一路径。这是浏览器自动化库（Playwright / Testing Library）模拟用户输入的标准手法。
+
+### Slot 选择
+
+`conversation.composer.dock`（list，session 作用域）——编辑器卡片下方的条带，由 `ui-conversation` 拥有。dock 条目从框架接收 `InputZone`（owner：`session: ConversationSnapshot`）+ `SessionStandardProps`。dock 只负责历史收集；导航监听器在 `apply` 里，不依赖 dock 挂载。
+
+### 历史收集
+
+每次 render 读 `props.session.nodes`（point-in-time 快照），从尾向前找到第一个 `kind === 'user'` 或 `kind === 'steering'` 节点，提取其 `content` 中所有 `type === 'text'` 块的文本拼接。与上次看到的文本比较，不同则 `append` 到 `HistoryStore`。store 内部做去重（最新相等 no-op、旧出现移到末尾）和 FIFO 截断。
+
+### 键盘事件处理链
+
+`document.addEventListener('keydown', handler, false)`（bubble 阶段，在 React 委托的 root handler 之后触发），监听器挂在 `apply` 里（非 dock 组件）：
+
+1. **键过滤**：只处理 `ArrowUp` / `ArrowDown`。
+2. **IME 守卫**：`event.isComposing || event.keyCode === 229` → 放行。
+3. **斜杠菜单兼容**：`event.defaultPrevented` → 放行（InputBar 已消费，菜单打开中方向键移动高亮）。
+4. **textarea 定位**：从 `event.target` 向上找 `[data-composer-card]` 祖先，找其下的 `<textarea>`；找不到放行。
+5. **target 校验**：`event.target !== textarea` 放行（排除点击 composer 卡片 chrome 的情况）。
+6. **readOnly/disabled gate**：`textarea.readOnly || textarea.disabled` 放行（hero 模式 workspace picker trigger、submit 进行中）。
+7. **多行边界**：`cursorLineInfo(value, selStart, selEnd)` 计算；ArrowUp 仅 `atFirstLine` 触发，ArrowDown 仅 `atLastLine` 触发。
+8. **导航**：`nextIndex(cursor, total, dir)` 计算下一索引；`null` 表示越过最新端 → 恢复 `savedDraft`；否则 `setNativeTextareaValue(textarea, entry)` + `event.preventDefault()`。
+9. **草稿保存**：第一次从"未导航"切到"导航中"时，把当前 `textarea.value` 存到 `savedDraft`。
+
+### 历史回填：native setter
+
+`setNativeTextareaValue(textarea, value)` 用 `Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value').set` 调用原生 setter（绕过 React 的 value tracker），然后 `dispatchEvent(new Event('input', { bubbles: true }))`。React 感知到值变化，触发 InputBar 的 `onChange` → `keyboard.setDraft(next)` → input machine 更新 draft → React 重新渲染 textarea value。与用户手动输入走完全相同的路径。
+
+## 开发
+
+```sh
+pnpm install          # 安装开发依赖
+pnpm run typecheck    # tsc --noEmit（通过 ../dsh 解析 DSH 源码）
+pnpm test             # vitest run（纯函数单元测试）
+pnpm run build        # tsc + tsdown → lib/index.js, lib/invariant.js, lib/client.js
+```
+
+### 基于 DSH checkout 类型检查
+
+`tsconfig.json` 继承 `../dsh/tsconfig.base.client.json`，继承其 `paths` 映射到同级 DSH checkout 的 `packages/*/*/src`。需在 `../dsh` 是 DSH checkout 根目录的同级布局下运行 typecheck。
+
+### 预构建 lib/
+
+`lib/` 随仓库提交（与 `dsh-spur` / `dsh-auto-blame` 相同模式），git 安装时无需 `prepare` 脚本。开发时改动源码后跑 `pnpm run build`（或 `pnpm run bundle:client`）重建 `lib/`，再提交。
+
+## 安装
+
+```sh
+# 从 npm 安装（推荐）：
+dsh plugin --profile web add @huanlin/dsh-plugin-input-history
+
+# 从 GitHub 安装：
+dsh plugin --profile web add github:huanlinoto/dsh-plugin-input-history
+
+# 本地开发（link:）：
+dsh plugin --profile web add link:D:/Projects/deepseek-harness/dsh-plugin-input-history
+```
+
+安装后重启 `dsh web` 进程，浏览器硬刷新（`Ctrl+Shift+R`）。
+
+## 配置
+
+无配置。capacity 硬编码为 500 条（见已知限制）。
+
+## 已知限制
+
+- **Capacity 硬编码。** 历史上限固定为 500 条（`DEFAULT_CAPACITY` in `src/client/history.ts`）。改为 `Config` 字段需要 host-client 间 RPC 通道（client bundle 与 host bundle 是独立的模块作用域，无法直接共享 Config）。如需调整，编辑源码后重建 `lib/`。
+- **textarea DOM 句柄无私有 API。** 插件通过 `document.querySelector('[data-composer-card] textarea')` 定位 InputBar 的 textarea。`data-composer-card` 属性是 `ui-conversation` 包的内部实现（`InputBar.tsx:629`），目前稳定但无文档保证；上游若改名，定位器需要更新（单点：`findComposerTextarea`）。
+- **斜杠菜单开/关状态无私有 API。** 通过 `event.defaultPrevented` 启发式判断：InputBar 的 onKeyDown 在菜单打开时方向键已 `preventDefault`（`InputBar.tsx:316`），bubble 阶段监听器据此识别"菜单已消费"。若上游改变该逻辑，启发式可能失效。
+- **hero 模式（无 workspace 的 workspace picker）下不触发。** hero 模式的 textarea 是 readOnly 的 workspace picker trigger，`textarea.readOnly` 守卫会放行。但 blank session（有 workspace、textarea 可编辑）下正常工作——这是关键修复点，因为 DSH 把 blank session 当 hero 渲染导致 dock 不挂载，监听器放在 `apply` 里绕过了这个限制。
+- **无跨 tab 同步。** 多窗口同时发消息时 localStorage 写竞争通过 try/catch 容错；最坏丢一条，下次 append 会纠正。
+- **历史范围全局共享。** 不区分 workspace / session，所有 `user` + `steering` 消息进同一历史。如需按 workspace 隔离，需要扩展 `HistoryStore` 的 key 命名空间。
+
+## 设计参考
+
+- 插件开发规范：`plugin-development-guide.md`
+- DSH Native UI slot 速查：`DSH-Native-UI.md`
+- 范本插件：`dsh-spur`（dock + inputActions 模式）、`dsh-auto-blame`（SuggestionBubbles）、`DSH-better-sidebar`（IME 守卫）

package/cordis.patch.yml

@@ -0,0 +1,14 @@
+# Insert dsh-plugin-input-history: terminal-style prompt history navigation
+# for the DSH composer. ArrowUp cycles to the previous sent prompt,
+# ArrowDown to the next (or restores the in-progress draft when past the
+# newest entry). History is collected from user + steering messages across
+# all sessions and persisted in localStorage (FIFO, 500 entries).
+#
+# The plugin registers an invisible entry in `conversation.composer.dock`
+# and attaches a bubble-phase `keydown` listener on `document`. The
+# listener honours IME composition, the slash-menu arbitration contract
+# (defers to `event.defaultPrevented`), and a multi-line cursor boundary
+# check (ArrowUp triggers only on the first line, ArrowDown on the last).
+- insert:
+    - id: dsh-plugin-input-history
+      name: '@huanlin/dsh-plugin-input-history'

package/lib/client.js

@@ -0,0 +1,467 @@
+window.__ModuleLoader__.load({ id: "@huanlin/dsh-plugin-input-history", factory: (require) => {
+var module = { exports: {} }; var exports = module.exports;
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = __toESM(react_jsx_runtime);
+
+//#region src/client/history.ts
+/**
+* Prompt history store — pure functions over a string array.
+*
+* The store is a FIFO list of unique prompt strings, persisted to
+* `localStorage`. Newest entries are at the end of the array. The
+* navigation cursor walks backwards from the end (ArrowUp = older,
+* ArrowDown = newer).
+*
+* The functions in this module are pure (no `localStorage` access) so
+* they can be unit-tested without jsdom. The `HistoryStore` class below
+* wires them to `localStorage` with try/catch containment — a quota
+* exception or a disabled storage (private mode) degrades gracefully to
+* an in-memory list that lives for the page lifetime.
+*
+* @module @huanlin/dsh-plugin-input-history/client/history
+*/
+/** localStorage key (versioned; bump on schema changes to start fresh). */
+const STORAGE_KEY = "dsh-plugin-input-history:v1";
+/** Default capacity when none is configured. */
+const DEFAULT_CAPACITY = 500;
+/**
+* Append a prompt to the history.
+*
+* Rules:
+*   - Empty / whitespace-only strings are ignored (the InputBar already
+*     rejects them at submit, but defensive).
+*   - When the new entry equals the most recent one, it is a no-op
+*     (avoids stacking duplicates from rapid resends).
+*   - When the new entry already exists earlier in the history, that
+*     earlier occurrence is removed (recency wins; the prompt moves to
+*     the end). This mirrors terminal shell behaviour.
+*   - When the array would exceed `capacity`, the oldest entries are
+*     dropped from the front (FIFO).
+*
+* @param history - the current history array (newest at end).
+* @param prompt - the prompt to append.
+* @param capacity - the maximum number of entries to retain.
+* @returns the new history array (may be the same reference if no-op).
+*/
+function appendHistory(history, prompt, capacity = DEFAULT_CAPACITY) {
+	const trimmed = prompt.trim();
+	if (trimmed === "") return history;
+	const lastIndex = history.lastIndexOf(trimmed);
+	if (lastIndex !== -1 && lastIndex === history.length - 1 && history.indexOf(trimmed) === lastIndex) return history;
+	const filtered = history.filter((item) => item !== trimmed);
+	filtered.push(trimmed);
+	const cap = Math.max(1, capacity);
+	if (filtered.length > cap) return filtered.slice(filtered.length - cap);
+	return filtered;
+}
+/**
+* Navigation cursor for walking the history.
+*
+* The cursor is `null` when the user is not navigating (i.e. they are
+* typing a fresh draft). ArrowUp sets it to the last index, then
+* decrements; ArrowDown increments; when it would exceed `history.length
+* - 1`, it returns to `null` (meaning "restore the in-progress draft").
+*
+* @param current - the current cursor (null = not navigating).
+* @param total - the total number of history entries.
+* @param dir - `'up'` (older) or `'down'` (newer).
+* @returns the next cursor, or `null` when navigation falls off the
+*   newest end (caller should restore the saved draft).
+*/
+function nextIndex(current, total, dir) {
+	if (total === 0) return null;
+	if (dir === "up") {
+		if (current === null) return total - 1;
+		if (current <= 0) return 0;
+		return current - 1;
+	}
+	if (current === null) return null;
+	if (current >= total - 1) return null;
+	return current + 1;
+}
+/**
+* Read the history entry at a cursor, or `null` when the cursor is null.
+*
+* @param history - the history array.
+* @param cursor - the navigation cursor.
+* @returns the prompt at the cursor, or `null`.
+*/
+function entryAt(history, cursor) {
+	if (cursor === null) return null;
+	if (cursor < 0 || cursor >= history.length) return null;
+	return history[cursor] ?? null;
+}
+/**
+* History store bound to `localStorage`.
+*
+* The store reads once on construction (or on `reload()`) and keeps an
+* in-memory copy. Writes go to both memory and `localStorage` inside a
+* try/catch — a quota exception leaves the in-memory copy authoritative
+* for the rest of the page lifetime. This trades cross-tab consistency
+* for resilience: the store never throws on a write, and the worst case
+* is that a tab keeps its own view until refresh.
+*
+* Cross-tab sync is intentionally NOT implemented: prompt history is
+* append-mostly and a stale read across tabs is harmless (the next
+* append corrects it). Listening to the `storage` event would add
+* reactivity that the navigation UI does not need.
+*/
+var HistoryStore = class {
+	items;
+	storage;
+	key;
+	/**
+	* @param capacity - maximum entries to retain (FIFO).
+	* @param storage - the storage backend (defaults to `localStorage` when available).
+	* @param key - the storage key (defaults to {@link STORAGE_KEY}).
+	*/
+	constructor(capacity = DEFAULT_CAPACITY, storage, key = STORAGE_KEY) {
+		this.capacity = capacity;
+		this.storage = storage ?? safeLocalStorage();
+		this.key = key;
+		this.items = this.readFromStorage();
+	}
+	/** Current history snapshot (newest at end). */
+	get list() {
+		return this.items;
+	}
+	/** Number of entries currently stored. */
+	get length() {
+		return this.items.length;
+	}
+	/** Reload from storage (e.g. after a suspected external edit). Truncates to the current capacity. */
+	reload() {
+		const loaded = this.readFromStorage();
+		const cap = Math.max(1, this.capacity);
+		this.items = loaded.length > cap ? loaded.slice(loaded.length - cap) : loaded;
+	}
+	/**
+	* Append a prompt and persist. See {@link appendHistory} for rules.
+	* @returns the new history snapshot.
+	*/
+	append(prompt) {
+		this.items = appendHistory(this.items, prompt, this.capacity);
+		this.writeToStorage();
+		return this.items;
+	}
+	/** Clear all history (used by tests and a future "clear" UI). */
+	clear() {
+		this.items = [];
+		this.writeToStorage();
+	}
+	readFromStorage() {
+		if (this.storage === null) return [];
+		try {
+			const raw = this.storage.getItem(this.key);
+			if (raw === null) return [];
+			const parsed = JSON.parse(raw);
+			if (!Array.isArray(parsed)) return [];
+			return parsed.filter((item) => typeof item === "string");
+		} catch {
+			return [];
+		}
+	}
+	writeToStorage() {
+		if (this.storage === null) return;
+		try {
+			this.storage.setItem(this.key, JSON.stringify(this.items));
+		} catch {}
+	}
+};
+/** Safe accessor for `localStorage` that returns null on any failure. */
+function safeLocalStorage() {
+	try {
+		if (typeof localStorage === "undefined") return null;
+		return localStorage;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/client/HistoryDock.tsx
+/**
+* Module-scope history store, initialized once on first dock mount.
+* Shared with the keydown listener in `apply` via `getHistoryStore()`.
+*/
+let historyStore = null;
+/** Get the shared history store (initializes lazily on first call). */
+function getHistoryStore() {
+	if (historyStore === null) historyStore = new HistoryStore(DEFAULT_CAPACITY);
+	return historyStore;
+}
+/**
+* Render the invisible history-collection dock entry.
+*
+* @param props - dock runtime share (InputZone owner + session kit) + locale seat.
+* @returns an `aria-hidden` anchor with zero layout footprint.
+*/
+function HistoryDock({ session }) {
+	const store = getHistoryStore();
+	const lastSeenTextRef = (0, react.useRef)(null);
+	const lastText = latestUserOrSteeringText(session.nodes);
+	if (lastText !== null && lastText !== lastSeenTextRef.current) {
+		lastSeenTextRef.current = lastText;
+		store.append(lastText);
+	}
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		"aria-hidden": true,
+		style: { display: "none" },
+		"data-dsh-plugin-input-history": ""
+	});
+}
+/**
+* Extract the text of the latest `user` or `steering` node from a
+* conversation snapshot's nodes list.
+*
+* Returns the concatenated text of all `type: 'text'` content blocks.
+* Returns `null` when no user/steering node is present (e.g. a fresh
+* session with only a system/context message).
+*
+* @param nodes - the conversation snapshot's `nodes` array.
+*/
+function latestUserOrSteeringText(nodes) {
+	for (let i = nodes.length - 1; i >= 0; i--) {
+		const node = nodes[i];
+		if (node.kind !== "user" && node.kind !== "steering") continue;
+		const content = node.content;
+		if (content === void 0) continue;
+		let text = "";
+		for (const block of content) if (block.type === "text" && typeof block.text === "string") text += block.text;
+		return text;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/client/ime.ts
+/**
+* IME-composition key guard.
+*
+* While a Chinese/Japanese/Korean input method is composing (the user is
+* picking a candidate from the IME window), every pressed key BELONGS to
+* the input method: arrows move the candidate highlight, Enter/Space
+* confirm the composition, Escape cancels it. Page code must not process
+* those keys — a history-navigation handler that calls `preventDefault()`
+* on ArrowUp/ArrowDown during composition would silently break the IME:
+* candidates stop responding, the composition gets torn apart, and only
+* bare letters come out.
+*
+* The composition signal follows the DSH core convention (InputBar's IME
+* guard, issue #535): `isComposing` for modern engines, keyCode 229 as
+* the legacy signal engines emit without isComposing.
+*
+* @module @huanlin/dsh-plugin-input-history/client/ime
+*/
+/** The pure decision: is this keyboard event part of an IME composition? */
+function isImeComposition(event) {
+	return event.isComposing || event.keyCode === 229;
+}
+
+//#endregion
+//#region src/client/dom.ts
+/**
+* Compute the caret's line position in a textarea value.
+*
+* Lines are split on `\n` (the textarea's own line break character). The
+* caret must be collapsed (`selectionStart === selectionEnd`) for the
+* `atFirstLine` / `atLastLine` flags to be true — a non-collapsed
+* selection spanning multiple lines should not trigger history navigation.
+*
+* @param value - the textarea's current value.
+* @param selectionStart - the textarea's `selectionStart`.
+* @param selectionEnd - the textarea's `selectionEnd` (defaults to `selectionStart`).
+* @returns the caret's line information.
+*/
+function cursorLineInfo(value, selectionStart, selectionEnd = selectionStart) {
+	const rawStart = Math.min(selectionStart, selectionEnd);
+	const rawEnd = Math.max(selectionStart, selectionEnd);
+	const clampedStart = Math.max(0, Math.min(rawStart, value.length));
+	const collapsed = clampedStart === Math.max(clampedStart, Math.min(rawEnd, value.length));
+	const lines = value.split("\n");
+	const totalLines = lines.length;
+	let currentLine = 0;
+	let runningLength = 0;
+	for (let i = 0; i < totalLines; i++) {
+		const line = lines[i];
+		const lineEnd = runningLength + line.length;
+		const upperBound = i === totalLines - 1 ? lineEnd + 1 : lineEnd + 1;
+		if (clampedStart >= runningLength && clampedStart < upperBound) {
+			currentLine = i;
+			break;
+		}
+		runningLength = lineEnd + 1;
+	}
+	return {
+		currentLine,
+		totalLines,
+		atFirstLine: collapsed && currentLine === 0,
+		atLastLine: collapsed && currentLine === totalLines - 1
+	};
+}
+/**
+* Locate the DSH composer textarea in the current document.
+*
+* Walks from the event target up to find the closest `[data-composer-card]`
+* ancestor, then queries the descendant `<textarea>` inside it. Returns
+* `null` when the target is not inside the composer card (e.g. the user
+* is typing in another input or the textarea is momentarily absent).
+*
+* When called without an event target, falls back to a document-wide
+* query — used in tests and ad-hoc probing.
+*
+* @param from - the event target (or any node inside the composer card).
+* @returns the textarea element, or `null` when not found.
+*/
+function findComposerTextarea(from) {
+	if (typeof document === "undefined") return null;
+	if (from === void 0) return document.querySelector("[data-composer-card] textarea");
+	if (from === null) return null;
+	const card = from instanceof Element ? from.closest("[data-composer-card]") : null;
+	if (card !== null) {
+		const ta = card.querySelector("textarea");
+		if (ta !== null) return ta;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/client/locales.ts
+/** Locale namespace id (matches the cordis.patch.yml plugin id). */
+const NS = "dsh-plugin-input-history";
+/** English dictionary. */
+const en = {
+	ariaLabel: "Prompt history navigation (ArrowUp/ArrowDown)",
+	restoredDraft: "Restored in-progress draft",
+	noHistory: "No prompt history yet"
+};
+/** Chinese dictionary. */
+const zh = {
+	ariaLabel: "提示词历史导航（上/下方向键）",
+	restoredDraft: "已恢复正在编辑的草稿",
+	noHistory: "暂无提示词历史"
+};
+
+//#endregion
+//#region src/client/index.ts
+/** Required services: slots + locale. */
+const inject = ["slots", "locale"];
+/**
+* Navigation cursor + saved draft for the keydown listener. Module-scoped
+* because the listener is attached once in `apply` and must persist across
+* dock mount/unmount cycles.
+*/
+let navCursor = null;
+let savedDraft = null;
+/**
+* Client plugin body: register the dock + attach the keydown listener.
+*
+* @param ctx - client root context.
+*/
+function apply(ctx) {
+	ctx.effect(() => ctx.locale.register(NS, {
+		zh,
+		en
+	}), "dsh-plugin-input-history: dictionaries");
+	ctx.slots.inject("conversation.composer.dock", () => ctx.slots.register({
+		name: "conversation.composer.dock",
+		id: "dsh-plugin-input-history",
+		order: 100,
+		locale: NS
+	}, HistoryDock));
+	ctx.effect(() => {
+		if (typeof document === "undefined") return () => {};
+		const handler = (event) => {
+			if (event.key !== "ArrowUp" && event.key !== "ArrowDown") return;
+			if (isImeComposition(event)) return;
+			if (event.defaultPrevented) return;
+			const textarea = findComposerTextarea(event.target);
+			if (textarea === null) return;
+			if (event.target !== textarea) return;
+			if (textarea.readOnly || textarea.disabled) return;
+			const history = getHistoryStore().list;
+			const info = cursorLineInfo(textarea.value, textarea.selectionStart, textarea.selectionEnd);
+			if (event.key === "ArrowUp" && !info.atFirstLine) return;
+			if (event.key === "ArrowDown" && !info.atLastLine) return;
+			const dir = event.key === "ArrowUp" ? "up" : "down";
+			const next = nextIndex(navCursor, history.length, dir);
+			if (next === null) {
+				const saved = savedDraft;
+				navCursor = null;
+				if (saved !== null) {
+					setNativeTextareaValue(textarea, saved);
+					savedDraft = null;
+				}
+				event.preventDefault();
+				return;
+			}
+			if (navCursor === null && savedDraft === null) savedDraft = textarea.value;
+			const entry = entryAt(history, next);
+			if (entry === null) return;
+			navCursor = next;
+			setNativeTextareaValue(textarea, entry);
+			event.preventDefault();
+		};
+		document.addEventListener("keydown", handler, false);
+		return () => {
+			document.removeEventListener("keydown", handler, false);
+		};
+	}, "dsh-plugin-input-history: keydown listener");
+}
+/**
+* Set the textarea value via the native prototype setter and dispatch an
+* `input` event so React's controlled-component onChange fires.
+*
+* React 18 tracks the textarea's value internally; directly assigning
+* `textarea.value = x` does NOT trigger React's onChange because React's
+* value tracker compares against its last-seen value. Using the native
+* prototype setter bypasses React's tracker, and the dispatched `input`
+* event makes React detect the change and run InputBar's `onChange` →
+* `keyboard.setDraft(next)`. This is the same technique used by
+* browser automation libraries (Playwright, Testing Library) to simulate
+* user typing in React controlled inputs.
+*
+* @param textarea - the target textarea element.
+* @param value - the new value to set.
+*/
+function setNativeTextareaValue(textarea, value) {
+	const proto = window.HTMLTextAreaElement.prototype;
+	const descriptor = Object.getOwnPropertyDescriptor(proto, "value");
+	if (descriptor === void 0 || descriptor.set === void 0) {
+		textarea.value = value;
+		return;
+	}
+	descriptor.set.call(textarea, value);
+	textarea.dispatchEvent(new Event("input", { bubbles: true }));
+}
+
+//#endregion
+exports.apply = apply;
+exports.inject = inject;
+return module.exports; } });
+//# sourceMappingURL=client.js.map