lark-remote 0.4.3 → 0.4.4

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.4] - 2026-10-04
+
+### 修复
+
+- **opencode 的工具卡片能显示完整命令了**：opencode 的 ACP 在参数流式阶段先发 `tool_call`（参数为空、标题只回落成工具名），真正的命令/路径随后由 `tool_call_update` 携带。此前卡片只显示 `Bash` 看不到执行了什么；现在按调用 id 原地回填参数，命令与路径正常展示。顺带修掉同一命令被重复渲染成 `ls — ls` 的摘要去重问题
+- **思考内容的省略计数不再虚增**：增量刷新时，旧逻辑把「前 N 字符已省略」标记自身的文本也计进被丢弃的正文，每帧约虚增 14 字符。现在只累计真实丢弃的正文，显示量始终不超过上限
+
+### 变更
+
+- **`!` 命令失败用例去掉宿主 locale 依赖**：原先匹配 stderr 文案（`command not found`），中文 locale 下 bash 输出「未找到命令」导致用例稳定误红。改为断言确定性信号——命令名回显、非零退出码、诊断块呈现
+
 ## [0.4.3] - 2026-09-24
 
 ### 新增

package/dist/card/run-state.js

@@ -388,31 +388,67 @@ function reduceAssistantEvent(state, event) {
             // string as the old per-render parse, so truncation-broken JSON still
             // yields null (over-cap input renders no summary — behavior preserved).
             const inputStr = truncateDetail(stringifyUnknown(content.input));
-            const capped = [
-                ...markThinkingInactive(next.blocks),
-                {
-                    kind: 'tool',
-                    tool: {
-                        id: content.id,
-                        name: content.name,
-                        input: inputStr,
-                        parsedInput: tryParseRecord(inputStr),
-                        ...(content.summary !== undefined ? { summary: content.summary } : {}),
-                        status: 'running',
-                        startedAt: event.timestamp,
-                    },
-                },
-            ];
-            next = {
-                ...next,
-                blocks: keepLatestBlocks(capped),
-                omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
-                footer: 'tool_running',
+            const incomingTool = {
+                id: content.id,
+                name: content.name,
+                input: inputStr,
+                parsedInput: tryParseRecord(inputStr),
+                ...(content.summary !== undefined ? { summary: content.summary } : {}),
+                status: 'running',
+                startedAt: event.timestamp,
             };
+            const blocks = markThinkingInactive(next.blocks);
+            // A tool_use patch (same id) enriches an existing tool block in place:
+            // opencode emits the initial tool_call while args are still streaming,
+            // then re-reports the command/path in later tool_call_updates. Merging
+            // keeps one panel per tool call; a first-seen id still appends.
+            const existingIndex = blocks.findIndex((block) => block.kind === 'tool' && block.tool.id === content.id);
+            if (existingIndex >= 0) {
+                const existing = blocks[existingIndex];
+                const merged = blocks.slice();
+                merged[existingIndex] = {
+                    kind: 'tool',
+                    tool: mergeToolUse(existing.tool, incomingTool),
+                };
+                next = { ...next, blocks: keepLatestBlocks(merged), footer: 'tool_running' };
+            }
+            else {
+                const capped = [...blocks, { kind: 'tool', tool: incomingTool }];
+                next = {
+                    ...next,
+                    blocks: keepLatestBlocks(capped),
+                    omittedBlocks: (next.omittedBlocks ?? 0) + Math.max(0, capped.length - MAX_BLOCKS),
+                    footer: 'tool_running',
+                };
+            }
         }
     }
     return next;
 }
+/**
+ * Merge a same-id tool_use patch into the existing tool block. Only fields the
+ * patch can legitimately enrich are overwritten:
+ *   - `input`/`parsedInput` — replaced only when the patch carries a non-empty
+ *     object (an empty `{}` patch must not erase a command already rendered);
+ *   - `summary` — replaced only when the patch supplies one;
+ *   - `name` — kept from first sight (a completed opencode update has no kind,
+ *     so its patch cannot know the mapped name).
+ * Everything else (`status`, `output`, `completedAt`, `toolHint`) is preserved,
+ * so an out-of-order patch after the tool_result cannot reset status to running.
+ */
+function mergeToolUse(existing, incoming) {
+    const incomingHasInput = incoming.parsedInput !== undefined &&
+        incoming.parsedInput !== null &&
+        Object.keys(incoming.parsedInput).length > 0;
+    return {
+        ...existing,
+        input: incomingHasInput ? incoming.input : existing.input,
+        parsedInput: incomingHasInput ? incoming.parsedInput : existing.parsedInput,
+        name: existing.name || incoming.name,
+        ...(incoming.summary !== undefined ? { summary: incoming.summary } : {}),
+        startedAt: existing.startedAt ?? incoming.startedAt,
+    };
+}
 /** Handle tool_result content blocks (user message with tool results).
  *  P3-4: rebuild ONLY the block matching `tool_use_id`, copying every other
  *  block by reference. The old `.map()` recreated all block objects per
@@ -589,26 +625,40 @@ function tryParseRecord(input) {
 function keepLatestBlocks(blocks) {
     return blocks.length <= MAX_BLOCKS ? blocks : blocks.slice(-MAX_BLOCKS);
 }
+/** 截断标记前缀（`keepTailMarked` 产出，含已丢弃正文计数）。 */
+const TRUNCATION_MARKER_RE = /^…（前 (\d+) 字符已省略）\n/;
 /**
  * keepTail + 截断标记：被去头的存储内容以前缀如实标注（信息保真红线：禁止静默丢弃）。
  * 标记计入 maxChars 预算（存储总量仍 ≤ maxChars，保持既有长度不变量）。
+ *
+ * 计数口径（2026-10 修正）：只统计**真实丢弃的正文**，不含标记自身开销。
+ * 关键点是增量流下 `value` 往往已带上一次的标记（`marker + kept`）；若直接
+ * 用 `value.length - kept.length` 计费，会把上一帧的标记文本也算进「已省略」，
+ * 造成每帧显示十几字符的虚高。这里先剥离旧标记，把 N 定义为**从该块起始累计
+ * 丢弃的正文数**（单调不减），再按「marker 计入预算」的不动点求最小 N。
  */
 function keepTailMarked(value, maxChars) {
-    if (value.length <= maxChars)
+    const prior = TRUNCATION_MARKER_RE.exec(value);
+    const priorDropped = prior ? Number(prior[1]) : 0;
+    const body = prior ? value.slice(prior[0].length) : value;
+    // 从未截断且当前正文未超预算：原样返回（不误标）。
+    if (priorDropped === 0 && body.length <= maxChars)
         return value;
-    // marker 计入 maxChars 预算（总量不变量）。省略数 = value.length - kept.length，
-    // 而 kept 长度取决于 marker 长度、marker 长度又取决于省略数的位数——
-    // 不动点迭代（marker 固定部分 12 字符，位数至多几次即收敛）。
-    let dropped = value.length - maxChars + 12;
+    // 求最小累计丢弃数 N（≥ priorDropped），使 marker(N) + 保留正文 ≤ maxChars：
+    //   body.length - (N - priorDropped) + (12 + digits(N)) ≤ maxChars
+    //   ⟺ N ≥ priorDropped + body.length - maxChars + 12 + digits(N)
+    // 即 N = K + digits(N) 的不动点（K 为固定项，位数至多几次即收敛）。
+    const K = priorDropped + body.length - maxChars + 12;
+    let totalDropped = Math.max(priorDropped, K);
     for (;;) {
-        const next = value.length - maxChars + 12 + String(dropped).length;
-        if (next === dropped)
+        const next = Math.max(priorDropped, K + String(totalDropped).length);
+        if (next === totalDropped)
             break;
-        dropped = next;
+        totalDropped = next;
     }
-    const marker = `…（前 ${dropped} 字符已省略）\n`;
-    const kept = keepTail(value, Math.max(0, maxChars - marker.length));
-    return marker + kept;
+    const newlyDropped = totalDropped - priorDropped;
+    const kept = body.slice(newlyDropped);
+    return `…（前 ${totalDropped} 字符已省略）\n${kept}`;
 }
 function truncateDetail(value) {
     return value.length <= MAX_TOOL_DETAIL_CHARS

package/dist/card/tool-render.js

@@ -39,9 +39,13 @@ export function toolHeaderText(tool) {
     const blockSummary = tool.summary
         ? truncate(tool.summary.replace(/\s+/g, ' ').trim(), HEADER_SUMMARY_MAX, { suffix: '' })
         : '';
+    // opencode carries the same value in both slots (title = command/path, and
+    // the args-derived summary resolves to it too); dedupe so the header reads
+    // `✅ **Bash** — ls` instead of `✅ **Bash** — ls — ls`.
     const parts = [summary, blockSummary].filter(Boolean);
-    return parts.length > 0
-        ? `${icon} **${tool.name}** — ${parts.join(' — ')}`
+    const uniqueParts = parts.filter((part, i) => parts.indexOf(part) === i);
+    return uniqueParts.length > 0
+        ? `${icon} **${tool.name}** — ${uniqueParts.join(' — ')}`
         : `${icon} **${tool.name}**`;
 }
 /**

package/dist/runner/common/acp/base-translator.d.ts

@@ -15,6 +15,8 @@
  *   handleRequestPermission                           — approval rendering (abstract)
  *   handleOtherServerRequest                          — extra reverse RPC (kimi: elicitation)
  *   extractToolResultContent                          — tool_result content (default: rawOutput)
+ *   extractToolCallArgsText                           — streaming-args source (opencode: none)
+ *   buildToolUseUpdate                                — tool_use patch from tool_call_update
  *   onUsageSample                                     — extra usage bookkeeping (opencode: cost)
  */
 import type { AgentEvent, ApprovalRequestedEvent, ResultEvent } from '../../types.js';
@@ -69,6 +71,13 @@ export declare abstract class BaseAcpTranslator {
      * approval handler correlate by toolCallId and recover the real command.
      */
     private toolCallArgsByCallId;
+    /**
+     * tool_use name recorded at tool_call time (kind mapping wins, else title).
+     * A later tool_call_update may carry only a title (opencode's completed
+     * update has neither kind nor rawInput); pairing it with the recorded name
+     * lets a tool_use patch render the original title as a subtitle.
+     */
+    private toolCallNameByCallId;
     /**
      * Handle a notification from the ACP server and return translated events.
      * Wire envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}} — the
@@ -132,8 +141,42 @@ export declare abstract class BaseAcpTranslator {
      * command (see toolCallArgsByCallId).
      */
     protected getTrackedToolCallArgs(toolCallId: string): string | undefined;
+    /** tool_use name recorded at tool_call time (kind mapping wins, else title). */
+    protected getToolCallName(toolCallId: string): string | undefined;
+    /**
+     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * handler and the tool_call_update patch builder so both agree on the name.
+     */
+    protected toolNameFromKind(kind: string | undefined): string | undefined;
+    /**
+     * Streaming-args text carried by a tool_call/_update notification.
+     *
+     * Default: the notification's content text — kimi's events-map.ts encodes the
+     * accumulated args there (toolCallDeltaToSessionUpdate: content.text =
+     * accumulator.args), and the approval handler relies on it.
+     *
+     * opencode overrides this to return undefined: its tool_call/_update content
+     * is the shell OUTPUT snapshot (decompiled acp service `WP`), never args
+     * (args ride rawInput in `XC`/`BP`). Treating that output as args would
+     * corrupt approval command recovery — the hazard this hook exists to close.
+     */
+    protected extractToolCallArgsText(event: ToolCallEvent | ToolCallUpdateEvent): string | undefined;
+    /**
+     * tool_call_update → optional tool_use patch event. When an update carries
+     * richer identity than the initial tool_call did (opencode emits the
+     * tool_call while args are still streaming, then delivers the real title /
+     * rawInput in later updates), the returned `assistant`/`tool_use` block is
+     * merged into the existing tool block by the card reducer (matched by id)
+     * instead of creating a duplicate panel.
+     *
+     * Default: null (kimi self-produces its Bash tool_use from terminal/create
+     * with the real command, so it needs no patch). opencode overrides.
+     */
+    protected buildToolUseUpdate(_event: ToolCallUpdateEvent): AgentEvent | null;
     /** Record latest args text, bounded so a long session cannot grow it forever. */
     private trackToolCallArgs;
+    /** Record tool_use name, bounded to keep a long session from growing it. */
+    private trackToolCallName;
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi
      * semantics). opencode overrides — its rawOutput is an OBJECT

package/dist/runner/common/acp/base-translator.js

@@ -65,6 +65,13 @@ export class BaseAcpTranslator {
      * approval handler correlate by toolCallId and recover the real command.
      */
     toolCallArgsByCallId = new Map();
+    /**
+     * tool_use name recorded at tool_call time (kind mapping wins, else title).
+     * A later tool_call_update may carry only a title (opencode's completed
+     * update has neither kind nor rawInput); pairing it with the recorded name
+     * lets a tool_use patch render the original title as a subtitle.
+     */
+    toolCallNameByCallId = new Map();
     /**
      * Handle a notification from the ACP server and return translated events.
      * Wire envelope: {sessionId, update: {sessionUpdate: '<kind>', ...}} — the
@@ -231,15 +238,16 @@ export class BaseAcpTranslator {
                 // Keep raw string as-is
             }
         }
-        const argsText = extractToolCallContentText(event.content);
+        const argsText = this.extractToolCallArgsText(event);
         if (argsText !== undefined) {
             this.trackToolCallArgs(event.toolCallId, argsText);
         }
         else if (event.rawInput !== undefined && event.rawInput !== null) {
             this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
         }
-        const mapped = event.kind ? KIND_TO_TOOL[event.kind] : undefined;
+        const mapped = this.toolNameFromKind(event.kind);
         const name = mapped ?? event.title;
+        this.trackToolCallName(event.toolCallId, name);
         const summary = mapped && event.title && event.title !== name ? event.title : undefined;
         return [
             {
@@ -265,6 +273,11 @@ export class BaseAcpTranslator {
     handleToolCallUpdate(event, _sessionId) {
         const isError = event.status === 'failed';
         const content = this.extractToolResultContent(event);
+        // Patch the existing tool block with identity that was not available at the
+        // initial tool_call (opencode streams args after emitting tool_call). The
+        // reducer merges by id, so this never duplicates the panel. Built before
+        // the terminal cleanup below so it can still resolve the recorded name.
+        const useUpdate = this.buildToolUseUpdate(event);
         // Terminal updates end the args-streaming phase — drop the tracked entry.
         // In-progress delta text is cumulative (events-map.ts
         // toolCallDeltaToSessionUpdate: content.text = accumulator.args), so the
@@ -273,7 +286,7 @@ export class BaseAcpTranslator {
             this.toolCallArgsByCallId.delete(event.toolCallId);
         }
         else {
-            const argsText = extractToolCallContentText(event.content);
+            const argsText = this.extractToolCallArgsText(event);
             if (argsText !== undefined) {
                 this.trackToolCallArgs(event.toolCallId, argsText);
             }
@@ -281,22 +294,24 @@ export class BaseAcpTranslator {
                 this.trackToolCallArgs(event.toolCallId, stringifyUnknown(event.rawInput));
             }
         }
-        return [
-            {
-                type: 'user',
-                message: {
-                    content: [
-                        {
-                            type: 'tool_result',
-                            tool_use_id: event.toolCallId,
-                            content,
-                            is_error: isError,
-                        },
-                    ],
-                },
-                timestamp: new Date().toISOString(),
+        const events = [];
+        if (useUpdate)
+            events.push(useUpdate);
+        events.push({
+            type: 'user',
+            message: {
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: event.toolCallId,
+                        content,
+                        is_error: isError,
+                    },
+                ],
             },
-        ];
+            timestamp: new Date().toISOString(),
+        });
+        return events;
     }
     /**
      * Latest tracked streaming-args text for a tool call (undefined when never
@@ -307,6 +322,46 @@ export class BaseAcpTranslator {
     getTrackedToolCallArgs(toolCallId) {
         return this.toolCallArgsByCallId.get(toolCallId);
     }
+    /** tool_use name recorded at tool_call time (kind mapping wins, else title). */
+    getToolCallName(toolCallId) {
+        return this.toolCallNameByCallId.get(toolCallId);
+    }
+    /**
+     * kind → canonical tool name (信息保真 C3.1). Shared by the initial tool_call
+     * handler and the tool_call_update patch builder so both agree on the name.
+     */
+    toolNameFromKind(kind) {
+        return kind ? KIND_TO_TOOL[kind] : undefined;
+    }
+    /**
+     * Streaming-args text carried by a tool_call/_update notification.
+     *
+     * Default: the notification's content text — kimi's events-map.ts encodes the
+     * accumulated args there (toolCallDeltaToSessionUpdate: content.text =
+     * accumulator.args), and the approval handler relies on it.
+     *
+     * opencode overrides this to return undefined: its tool_call/_update content
+     * is the shell OUTPUT snapshot (decompiled acp service `WP`), never args
+     * (args ride rawInput in `XC`/`BP`). Treating that output as args would
+     * corrupt approval command recovery — the hazard this hook exists to close.
+     */
+    extractToolCallArgsText(event) {
+        return extractToolCallContentText(event.content);
+    }
+    /**
+     * tool_call_update → optional tool_use patch event. When an update carries
+     * richer identity than the initial tool_call did (opencode emits the
+     * tool_call while args are still streaming, then delivers the real title /
+     * rawInput in later updates), the returned `assistant`/`tool_use` block is
+     * merged into the existing tool block by the card reducer (matched by id)
+     * instead of creating a duplicate panel.
+     *
+     * Default: null (kimi self-produces its Bash tool_use from terminal/create
+     * with the real command, so it needs no patch). opencode overrides.
+     */
+    buildToolUseUpdate(_event) {
+        return null;
+    }
     /** Record latest args text, bounded so a long session cannot grow it forever. */
     trackToolCallArgs(toolCallId, argsText) {
         this.toolCallArgsByCallId.delete(toolCallId);
@@ -317,6 +372,16 @@ export class BaseAcpTranslator {
                 this.toolCallArgsByCallId.delete(oldest);
         }
     }
+    /** Record tool_use name, bounded to keep a long session from growing it. */
+    trackToolCallName(toolCallId, name) {
+        this.toolCallNameByCallId.delete(toolCallId);
+        this.toolCallNameByCallId.set(toolCallId, name);
+        if (this.toolCallNameByCallId.size > 100) {
+            const oldest = this.toolCallNameByCallId.keys().next().value;
+            if (oldest !== undefined)
+                this.toolCallNameByCallId.delete(oldest);
+        }
+    }
     /**
      * tool_result content extraction. Default: rawOutput passthrough (kimi
      * semantics). opencode overrides — its rawOutput is an OBJECT

package/dist/runner/opencode/acp/translator.d.ts

@@ -24,7 +24,8 @@
  *   prompt other stopReason/error  → result error
  *   session/request_permission     → approval_requested (optionId echo)
  */
-import type { RequestPermissionParams, AgentMessageChunkEvent, AgentThoughtChunkEvent, ToolCallUpdateEvent, UsageUpdateEvent } from '../../common/acp/protocol-types.js';
+import type { AgentEvent } from '../../types.js';
+import type { RequestPermissionParams, AgentMessageChunkEvent, AgentThoughtChunkEvent, ToolCallEvent, ToolCallUpdateEvent, UsageUpdateEvent } from '../../common/acp/protocol-types.js';
 import { BaseAcpTranslator, type AcpTranslatorEvent } from '../../common/acp/base-translator.js';
 export declare class OpencodeAcpTranslator extends BaseAcpTranslator {
     protected readonly logTag = "opencode-acp-translator";
@@ -36,6 +37,26 @@ export declare class OpencodeAcpTranslator extends BaseAcpTranslator {
      * content[] with shell output snapshot.
      */
     protected extractToolResultContent(event: ToolCallUpdateEvent): unknown;
+    /**
+     * opencode tool args always arrive as rawInput (`XC`/`BP`), never as content
+     * text. A tool_call_update's content is the shell OUTPUT snapshot (`WP`), so
+     * inheriting the base args-tracking would record output as if it were the
+     * command — the corruption this override prevents. Return undefined: nothing
+     * to track from content (rawInput tracking in the base still applies).
+     */
+    protected extractToolCallArgsText(_event: ToolCallEvent | ToolCallUpdateEvent): string | undefined;
+    /**
+     * opencode emits the tool_call while args are still streaming: the part is
+     * created with `state:{status:'pending',input:{}}` (decompiled acp service),
+     * so the initial title falls back to the tool name (e.g. `bash`) and the card
+     * shows no command. The real identity arrives in later tool_call_updates:
+     *   - running (`BP`): full rawInput + title = command/path
+     *   - completed (`HP`): title only (no kind, no rawInput)
+     * Emit a tool_use patch when either carries usable data; the reducer merges
+     * it into the existing block by id. Name resolves from kind (`BP`) or the
+     * name recorded at tool_call time (`HP`).
+     */
+    protected buildToolUseUpdate(event: ToolCallUpdateEvent): AgentEvent | null;
     /** opencode usage_update also carries session cost: {cost:{amount}} (USD). */
     protected onUsageSample(event: UsageUpdateEvent): void;
     protected handleRequestPermission(requestId: number | string, params: RequestPermissionParams): AcpTranslatorEvent[];

package/dist/runner/opencode/acp/translator.js

@@ -92,6 +92,66 @@ export class OpencodeAcpTranslator extends BaseAcpTranslator {
         }
         return '';
     }
+    /**
+     * opencode tool args always arrive as rawInput (`XC`/`BP`), never as content
+     * text. A tool_call_update's content is the shell OUTPUT snapshot (`WP`), so
+     * inheriting the base args-tracking would record output as if it were the
+     * command — the corruption this override prevents. Return undefined: nothing
+     * to track from content (rawInput tracking in the base still applies).
+     */
+    extractToolCallArgsText(_event) {
+        return undefined;
+    }
+    /**
+     * opencode emits the tool_call while args are still streaming: the part is
+     * created with `state:{status:'pending',input:{}}` (decompiled acp service),
+     * so the initial title falls back to the tool name (e.g. `bash`) and the card
+     * shows no command. The real identity arrives in later tool_call_updates:
+     *   - running (`BP`): full rawInput + title = command/path
+     *   - completed (`HP`): title only (no kind, no rawInput)
+     * Emit a tool_use patch when either carries usable data; the reducer merges
+     * it into the existing block by id. Name resolves from kind (`BP`) or the
+     * name recorded at tool_call time (`HP`).
+     */
+    buildToolUseUpdate(event) {
+        const raw = event.rawInput;
+        let input = {};
+        if (raw !== undefined && raw !== null) {
+            if (typeof raw === 'string') {
+                try {
+                    input = JSON.parse(raw);
+                }
+                catch {
+                    input = raw;
+                }
+            }
+            else {
+                input = raw;
+            }
+        }
+        const inputHasKeys = input !== null && typeof input === 'object' && Object.keys(input).length > 0;
+        const title = typeof event.title === 'string' && event.title.length > 0 ? event.title : undefined;
+        if (!inputHasKeys && !title)
+            return null;
+        const kind = typeof event.kind === 'string' ? event.kind : undefined;
+        const name = this.toolNameFromKind(kind) ?? this.getToolCallName(event.toolCallId) ?? '';
+        const summary = title && title !== name ? title : undefined;
+        return {
+            type: 'assistant',
+            timestamp: new Date().toISOString(),
+            message: {
+                content: [
+                    {
+                        type: 'tool_use',
+                        id: event.toolCallId,
+                        name,
+                        input: inputHasKeys ? input : {},
+                        ...(summary !== undefined ? { summary } : {}),
+                    },
+                ],
+            },
+        };
+    }
     /** opencode usage_update also carries session cost: {cost:{amount}} (USD). */
     onUsageSample(event) {
         const cost = event.cost;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",