lark-remote 0.4.1 → 0.4.3

package/dist/runner/kimi/acp/runner.js

@@ -17,7 +17,8 @@
  * - AskUserQuestion flows through elicitation forms + a request_permission
  *   question bridge (buildQuestionResponse)
  */
-import { spawnProcess, mergeProcessEnv, useDetachedProcessGroup } from '../../../platform/spawn.js';
+import { mergeProcessEnv, useDetachedProcessGroup } from '../../../platform/spawn.js';
+import { createShellBackend } from '../../../platform/shell.js';
 import { StringDecoder } from 'node:string_decoder';
 import { ConnectionManager, } from '../../common/jsonrpc/connection-manager.js';
 import { KimiAcpTranslator } from './translator.js';
@@ -26,7 +27,7 @@ import { KIMI_APPROVAL_KINDS, buildAcpPermissionOutcome, } from '../../common/ac
 import { mapAnswersByIndex } from '../../question-common.js';
 import { getLogger } from '../../../logger/index.js';
 import { BaseAcpRunner } from '../../common/acp/base-acp-runner.js';
-import { ProcessStopper } from '../../common/process-stopper.js';
+import { createTerminator } from '../../../platform/terminator.js';
 /** §5.2: compaction 等待的默认沉默超时（10 分钟，独立于 turn idle 默认 30 分钟）。 */
 const COMPACT_IDLE_TIMEOUT_MS = 10 * 60_000;
 /** Poll interval for the wire.jsonl compaction record. */
@@ -134,6 +135,7 @@ function buildQuestionResponse(action, pending, response) {
 // =============================================================================
 export class KimiAcpRunner extends BaseAcpRunner {
     permissionMode;
+    thinkingEffort;
     compactIdleTimeoutMs;
     /**
      * §5.2 compaction baseline: wire.jsonl records sampled by compactBaseline()
@@ -155,7 +157,17 @@ export class KimiAcpRunner extends BaseAcpRunner {
     bashToolCallIds = new Set();
     /** 当前 run 的 session cwd（terminal/create 未给 cwd 时回退用）。 */
     activeCwd = null;
-    processStopper = new ProcessStopper({ graceMs: 2_000 });
+    /**
+     * 终端子进程终止器（terminal/kill|release 与 dispose 清理用）。agent 必须是
+     * 'kimi'：win32 上优雅段靠协议停止通道，查错 key 会静默退化成直接树杀。
+     */
+    terminator = createTerminator({ graceMs: 2_000, agent: 'kimi' });
+    /**
+     * shell seam：terminal/create 的可执行解析走这里（design.md §7.2）。kimi 的
+     * ACP 服务端固定要 `bash -c`，win32 上没有 Git Bash 时必须在 seam 里变成
+     * 明确错误，而不是一个语焉不详的 spawn ENOENT。
+     */
+    shell = createShellBackend();
     constructor(opts) {
         const managerOpts = {
             binary: opts.binary ?? 'kimi',
@@ -189,6 +201,7 @@ export class KimiAcpRunner extends BaseAcpRunner {
             turnIdleTimeoutMs: opts.turnIdleTimeoutMs,
         }, new ConnectionManager(managerOpts));
         this.model = opts.model;
+        this.thinkingEffort = opts.thinkingEffort;
         this.permissionMode = opts.permissionMode ?? 'manual';
         this.compactIdleTimeoutMs = opts.compactIdleTimeoutMs ?? COMPACT_IDLE_TIMEOUT_MS;
     }
@@ -226,6 +239,25 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 getLogger().warn(`[${this.logTag}] set_config_option model failed (non-fatal): ${err.message}`);
             }
         }
+        // A5: 下发配置的思考强度。configId 与取值不是猜的——kimi 真机（0.43.1）
+        // `session/new` 就通告 `{id:'thinking', category:'thought_level',
+        // options:[low|high|max]}`，set 成功后响应里 `currentValue` 变成新值；
+        // 未知 configId / 非法取值回 -32602（不静默接受），所以失败告警即可判定。
+        // 换模型后新模型可能不支持当前档 → 服务端拒绝、保持其默认档，卡片侧
+        // `thinkingEffortPatchForModel` 已按 supportEfforts 预挑兼容档。
+        if (this.thinkingEffort) {
+            try {
+                await client.request('session/set_config_option', {
+                    sessionId,
+                    configId: 'thinking',
+                    value: this.thinkingEffort,
+                });
+            }
+            catch (err) {
+                getLogger().warn(`[${this.logTag}] set_config_option thinking failed (non-fatal): ` +
+                    `${err.message}`);
+            }
+        }
         // Set permission mode (§5.1): EVERY fresh ACP session starts in
         // 'default' (= manual approvals, acp-server modes.ts DEFAULT_MODE_ID),
         // so the mode must be sent unconditionally — skipping yolo leaves the
@@ -266,10 +298,11 @@ export class KimiAcpRunner extends BaseAcpRunner {
         // Derived from the pre-fire snapshot captured by compactBaseline() —
         // re-reading here would race the prompt fire and misclassify new records.
         const baselineTerminalCount = this.compactBaselineRecords.filter(isCompactionTerminalLike).length;
-        promptPromise.then(async (result) => {
+        let promptRejected = false;
+        // prompt 结算只供两样东西：成功 result 的翻译素材（stopReason/usage）与 §5.4
+        // 探针。终态判定不再挂在它后面（A7）。
+        const promptSettled = promptPromise.then((result) => {
             this.promptSettled = true;
-            if (this.stopRequested)
-                return; // already cancelled
             if (compactionReader) {
                 // §5.4 可选防线（日志探针）：prompt settle 后既无新 begin 也无新
                 // terminal → compact 未被引擎接受（可能已在跑或被拒绝）。不解析
@@ -278,31 +311,50 @@ export class KimiAcpRunner extends BaseAcpRunner {
                 if (totalNow === baselineTotalCount) {
                     getLogger().warn(`[${this.logTag}] compact 未被引擎接受（无新 begin/terminal 记录，可能已在跑或被拒绝）`);
                 }
-                const outcome = await this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount);
-                if (this.forceFinish)
-                    return; // stopped while polling
-                if (outcome === 'completed') {
-                    // 压缩完成：正常翻译 prompt 结果（subtype success）。
-                    const resultEvent = translator.handlePromptResponse(sessionId, result);
-                    this.pushEvents([resultEvent]);
-                }
-                else if (outcome === 'cancelled') {
-                    this.pushEvents([
-                        translator.produceErrorResult(sessionId, '压缩未完成：已被取消或压缩请求失败（可重试）'),
-                    ]);
-                }
-                else if (outcome === 'unknown') {
-                    this.pushEvents([
-                        translator.produceErrorResult(sessionId, `压缩状态未知：超过 ${formatIdleWindow(this.compactIdleTimeoutMs)} 未观察到完成/取消记录，压缩可能仍在后台进行`),
-                    ]);
-                }
-                // outcome === 'stopped'：不推 result，由 consumeTurn 的 interrupted 兜底。
             }
-            else {
-                const resultEvent = translator.handlePromptResponse(sessionId, result);
-                this.pushEvents([resultEvent]);
+            return result;
+        }, (err) => {
+            promptRejected = true;
+            this.handlePromptRejected(err, translator, sessionId, 'compact');
+            return undefined;
+        });
+        if (!compactionReader) {
+            // 读不到 compaction 记录（reader 未实现）：沿用「prompt 结算即成功」的口径。
+            void promptSettled.then((result) => {
+                if (result)
+                    this.pushEvents([translator.handlePromptResponse(sessionId, result)]);
+            });
+            return;
+        }
+        // A7：语义等待在 prompt 触发的那一刻武装。引擎静默超过 compactIdleTimeoutMs
+        // 就给出 compact 语义终态，不等 session/prompt 结算——否则挂住的 prompt 会把
+        // 用户拖到通用 turnIdleTimeout（默认 30min），拿到的还是一个语义泛化的 turn
+        // 超时，而不是「压缩状态未知 / 可重试」。
+        void this.waitForCompactionTerminal(compactionReader, opts, baselineTerminalCount).then(async (outcome) => {
+            // outcome === 'stopped'：不推 result，由 consumeTurn 的 interrupted 兜底。
+            if (outcome === 'stopped' || this.forceFinish || this.stopRequested)
+                return;
+            if (outcome === 'cancelled') {
+                this.pushEvents([
+                    translator.produceErrorResult(sessionId, '压缩未完成：已被取消或压缩请求失败（可重试）'),
+                ]);
+                return;
+            }
+            if (outcome === 'unknown') {
+                this.pushEvents([
+                    translator.produceErrorResult(sessionId, `压缩状态未知：超过 ${formatIdleWindow(this.compactIdleTimeoutMs)} 未观察到完成/取消记录，压缩可能仍在后台进行`),
+                ]);
+                return;
             }
-        }, (err) => this.handlePromptRejected(err, translator, sessionId, 'compact'));
+            // completed：成功 result 需要 prompt 的 stopReason/usage。§5.2 的正常时序里
+            // prompt 先于终态记录结算，这里通常是在等一个已完成的 promise。
+            const result = await promptSettled;
+            if (!result || promptRejected)
+                return; // handlePromptRejected 已产 error result
+            if (this.forceFinish || this.stopRequested)
+                return;
+            this.pushEvents([translator.handlePromptResponse(sessionId, result)]);
+        });
     }
     buildApprovalOutcome(action, pending, response) {
         return pending.kind === 'question'
@@ -501,17 +553,23 @@ export class KimiAcpRunner extends BaseAcpRunner {
             : undefined;
         const cwd = params.cwd ?? this.activeCwd ?? undefined;
         const outputLimit = params.outputByteLimit ?? TERMINAL_DEFAULT_OUTPUT_LIMIT;
-        const proc = spawnProcess(params.command, params.args ?? [], {
+        // 走 shell seam（design.md §7.2）：argv 逐 token 保留，只把「可执行文件在哪」
+        // 收口——win32 上 Git Bash 缺失时在这里抛 ShellUnavailableError，由
+        // handleTerminalRequest 转成明确的 Terminal request failed 回执，而不是一个
+        // 语焉不详的 spawn ENOENT。
+        const proc = this.shell.spawnArgv(params.command, params.args ?? [], {
             cwd,
-            // env 覆盖大小写不敏感合并（win32 PATH/Path 双键防护，v2 §8.3）
-            env: env ? mergeProcessEnv(process.env, env) : undefined,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            // ProcessStopper 用负 PID 杀进程组（kill(-pgid)）；子进程必须是组长
-            // 才能命中，否则 kill(-pid) 抛 ESRCH 被吞 → kill/release/清理全失效。
-            // 与 JsonlRpcTransport / spawning-runner 同模式；win32 不 detached
-            // （`.cmd` 垫片在 DETACHED_PROCESS 下丢 stdio），树杀由 taskkill /T 负责。
-            detached: useDetachedProcessGroup(),
-            windowsHide: true,
+            options: {
+                // env 覆盖大小写不敏感合并（win32 PATH/Path 双键防护，v2 §8.3）
+                env: env ? mergeProcessEnv(process.env, env) : undefined,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                // Terminator 用负 PID 杀进程组（kill(-pgid)）；子进程必须是组长
+                // 才能命中，否则 kill(-pid) 抛 ESRCH 被吞 → kill/release/清理全失效。
+                // 与 JsonlRpcTransport / spawning-runner 同模式；win32 不 detached
+                // （`.cmd` 垫片在 DETACHED_PROCESS 下丢 stdio），树杀由 taskkill /T 负责。
+                detached: useDetachedProcessGroup(),
+                windowsHide: true,
+            },
         });
         // 每个流独立 decoder：多字节字符跨 chunk 拆分时由 decoder 保留不完整
         // 序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符。
@@ -651,7 +709,7 @@ export class KimiAcpRunner extends BaseAcpRunner {
             this.currentClient?.respondError(id, RpcErrorCode.INVALID_PARAMS, `Unknown terminal: ${params.terminalId}`);
             return;
         }
-        await this.processStopper.stop(handle.proc, { immediate: true });
+        await this.terminator.stop(handle.proc, { immediate: true });
         this.currentClient?.respond(id, {});
     }
     /** terminal/release: 从 map 删除；进程仍在则一并杀，回 {}。 */
@@ -663,7 +721,7 @@ export class KimiAcpRunner extends BaseAcpRunner {
         }
         this.terminals.delete(params.terminalId);
         // stop 对已退出进程是 no-op；仍在跑则立即 SIGTERM+SIGKILL。
-        await this.processStopper.stop(handle.proc, { immediate: true });
+        await this.terminator.stop(handle.proc, { immediate: true });
         this.currentClient?.respond(id, {});
     }
     /** Kill every live terminal (dispose/connection-close 清理钩子)。 */
@@ -671,7 +729,7 @@ export class KimiAcpRunner extends BaseAcpRunner {
         const handles = [...this.terminals.values()];
         this.terminals.clear();
         for (const handle of handles) {
-            await this.processStopper.stop(handle.proc, { immediate: true });
+            await this.terminator.stop(handle.proc, { immediate: true });
         }
     }
     // =========================================================================

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

@@ -27,7 +27,6 @@
  */
 import { type RequestPermissionParams, type AgentMessageChunkEvent, type AgentThoughtChunkEvent } from '../../common/acp/protocol-types.js';
 import { BaseAcpTranslator, type AcpTranslatorEvent } from '../../common/acp/base-translator.js';
-export type { AcpTurnStartedEvent, AcpLiveUsage, AcpUsageEvent, AcpTranslatorEvent, } from '../../common/acp/base-translator.js';
 export declare class KimiAcpTranslator extends BaseAcpTranslator {
     protected readonly logTag = "kimi-acp-translator";
     /** Accumulated text per tool-call or message (keyed by a logical item id). */

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

@@ -26,7 +26,6 @@
  */
 import type { RequestPermissionParams, AgentMessageChunkEvent, AgentThoughtChunkEvent, ToolCallUpdateEvent, UsageUpdateEvent } from '../../common/acp/protocol-types.js';
 import { BaseAcpTranslator, type AcpTranslatorEvent } from '../../common/acp/base-translator.js';
-export type { AcpTurnStartedEvent as OpencodeAcpTurnStartedEvent, AcpLiveUsage as OpencodeAcpLiveUsage, AcpUsageEvent as OpencodeAcpUsageEvent, AcpTranslatorEvent as OpencodeAcpTranslatorEvent, } from '../../common/acp/base-translator.js';
 export declare class OpencodeAcpTranslator extends BaseAcpTranslator {
     protected readonly logTag = "opencode-acp-translator";
     protected handleAgentMessageChunk(event: AgentMessageChunkEvent, _sessionId: string): AcpTranslatorEvent[];

package/dist/runner/pi/rpc/protocol-types.d.ts

@@ -32,6 +32,10 @@ export type PiRpcCommand = {
 } | {
     type: 'get_state';
 };
+/**
+ * get_state 的完整返回体。桥只读 sessionId，其余字段照上游 schema 保留：当前没有
+ * consumer 是有意为之（静态扫描报的"零引用导出类型"即指此处），别据此删除。
+ */
 export interface PiRpcGetStateData {
     model?: unknown;
     sessionId: string;

package/dist/runner/pi/rpc/runner.js

@@ -53,6 +53,9 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             idleTtlMs: opts.idleTtlMs,
             logTag: 'pi-rpc-connection-manager',
         });
+        // 协议停止通道（design §3.3）：pi 的 cancel 是 `{type:'abort'}` 通知，已由
+        // cancelCurrentTurn 实现；登记后 win32 优雅停止才有通道可用（否则一路树杀）。
+        this.manager.stopper = ({ client }) => this.buildCooperativeStop(client);
     }
     get logTag() {
         return 'pi-rpc-runner';

package/dist/runner/resolve-agent-choices.js

@@ -20,11 +20,6 @@ export function resolveAgentChoices(config) {
     }
     // Clone to avoid mutation
     const resolved = structuredClone(config);
-    // agents.codex 在 schema 中必填（带默认值），此处按旧语义补空对象；
-    // 运行时只往 [agent] 槽位写字段，不依赖 codex 默认值。
-    if (!resolved.agents) {
-        resolved.agents = {};
-    }
     const agents = resolved.agents;
     const target = (agents[agent] ??= {});
     const source = agentChoices;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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",
@@ -94,7 +94,7 @@
   "type": "module",
   "dependencies": {
     "@iarna/toml": "^2.2.5",
-    "@larksuite/channel": "^0.3.0",
+    "@larksuite/channel": "^0.7.1",
     "axios": "^1.18.0",
     "cross-spawn": "^7.0.6",
     "form-data": "^4.0.6",

package/dist/runner/common/process-stopper.d.ts

@@ -1,7 +0,0 @@
-/**
- * 已迁移到平台 seam：`src/platform/terminator-posix.ts`（design.md §3.2）。
- *
- * 本文件只保留 re-export，使既有调用方（bash runner、jsonrpc transport 等）
- * 与既有测试不受影响；M2 调用点迁移时逐个换成 `createTerminator()` 后删除。
- */
-export { ProcessStopper } from '../../platform/terminator-posix.js';

package/dist/runner/common/process-stopper.js

@@ -1,8 +0,0 @@
-/**
- * 已迁移到平台 seam：`src/platform/terminator-posix.ts`（design.md §3.2）。
- *
- * 本文件只保留 re-export，使既有调用方（bash runner、jsonrpc transport 等）
- * 与既有测试不受影响；M2 调用点迁移时逐个换成 `createTerminator()` 后删除。
- */
-export { ProcessStopper } from '../../platform/terminator-posix.js';
-//# sourceMappingURL=process-stopper.js.map

package/dist/runner/dsh/fake-dsh-server.d.ts

@@ -1,60 +0,0 @@
-/**
- * Fake DSH Web Host HTTP server for agent-dsh tests.
- *
- * Mimics the real DSH wire protocol (deepseek-harness apiproxy handler.ts):
- *   - POST /api/<method>: body {type:'client-request',rpcId,method,payload},
- *     response {type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}.
- *   - SSE GET /api/events.mux: frames `data: {type:'server-request',rpcId,
- *     method:<frame.type>, payload:<frame>}\n\n`.
- *
- * The mux frame queue is consumed ACROSS connections (shared pointer): the
- * first connection drains a prefix then closes; a reconnect drains the rest —
- * which is exactly how a server that drops mid-turn is modelled. Unary
- * handlers and the history value are registered by the test.
- */
-import { type Server } from 'node:http';
-export interface FakeRpcResult {
-    ok: true;
-    value: unknown;
-}
-export interface FakeRpcError {
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-}
-export type FakeUnaryHandler = (payload: unknown, rpcId: string) => FakeRpcResult | FakeRpcError;
-export interface DshServerRequestRecord {
-    method: string;
-    rpcId: string;
-    payload: unknown;
-}
-export declare class FakeDshServer {
-    readonly server: Server;
-    private readonly unaryHandlers;
-    private muxFrames;
-    private historyValue;
-    private port;
-    private closedConnections;
-    readonly requests: DshServerRequestRecord[];
-    constructor();
-    get baseUrl(): string;
-    get connectionCount(): number;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    register(method: string, handler: FakeUnaryHandler): void;
-    setMuxFrames(frames: Array<object | {
-        close: true;
-    }>): void;
-    setHistoryValue(value: unknown): void;
-    /** Synchronous unary dispatch (no HTTP) — used by tests that inject the
-     *  reader's sync transport to avoid the spawnSync-in-process deadlock. */
-    dispatchSync(method: string, payload: unknown, rpcId?: string): {
-        type: string;
-        rpcId: string;
-        result: FakeRpcResult | FakeRpcError;
-    };
-    private handleMux;
-}

package/dist/runner/dsh/fake-dsh-server.js

@@ -1,156 +0,0 @@
-/**
- * Fake DSH Web Host HTTP server for agent-dsh tests.
- *
- * Mimics the real DSH wire protocol (deepseek-harness apiproxy handler.ts):
- *   - POST /api/<method>: body {type:'client-request',rpcId,method,payload},
- *     response {type:'server-response',rpcId,result:{ok:true,value}|{ok:false,error}}.
- *   - SSE GET /api/events.mux: frames `data: {type:'server-request',rpcId,
- *     method:<frame.type>, payload:<frame>}\n\n`.
- *
- * The mux frame queue is consumed ACROSS connections (shared pointer): the
- * first connection drains a prefix then closes; a reconnect drains the rest —
- * which is exactly how a server that drops mid-turn is modelled. Unary
- * handlers and the history value are registered by the test.
- */
-import { createServer } from 'node:http';
-import { randomUUID } from 'node:crypto';
-export class FakeDshServer {
-    server;
-    unaryHandlers = new Map();
-    muxFrames = [];
-    historyValue = { events: [] };
-    port = 0;
-    closedConnections = 0;
-    requests = [];
-    constructor() {
-        this.server = createServer((req, res) => {
-            const url = req.url ?? '';
-            const path = url.split('?')[0];
-            if (req.method === 'GET' && path === '/api/events.mux') {
-                this.closedConnections++;
-                this.handleMux(res);
-                return;
-            }
-            if (req.method !== 'POST' || !path.startsWith('/api/')) {
-                res.writeHead(404);
-                res.end('not found');
-                return;
-            }
-            let raw = '';
-            req.on('data', (c) => (raw += c));
-            req.on('end', () => {
-                let body = {};
-                try {
-                    body = JSON.parse(raw);
-                }
-                catch {
-                    res.writeHead(400);
-                    res.end('bad request');
-                    return;
-                }
-                const method = path.slice('/api/'.length);
-                if (body.type !== 'client-request' || !body.rpcId || body.method !== method) {
-                    res.writeHead(400);
-                    res.end('bad request');
-                    return;
-                }
-                const rpcId = body.rpcId;
-                this.requests.push({ method, rpcId, payload: body.payload });
-                const handler = this.unaryHandlers.get(method);
-                let result;
-                if (handler) {
-                    result = handler(body.payload, rpcId);
-                }
-                else if (method === 'session.history') {
-                    result = { ok: true, value: this.historyValue };
-                }
-                else if (method === 'session.list') {
-                    result = { ok: true, value: { items: [] } };
-                }
-                else {
-                    result = { ok: true, value: {} };
-                }
-                res.writeHead(200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ type: 'server-response', rpcId, result }));
-            });
-        });
-    }
-    get baseUrl() {
-        return `http://127.0.0.1:${this.port}`;
-    }
-    get connectionCount() {
-        return this.closedConnections;
-    }
-    async start() {
-        await new Promise((resolve) => this.server.listen(0, '127.0.0.1', resolve));
-        const addr = this.server.address();
-        this.port = addr.port;
-    }
-    async stop() {
-        await new Promise((resolve) => this.server.close(() => resolve()));
-    }
-    register(method, handler) {
-        this.unaryHandlers.set(method, handler);
-    }
-    setMuxFrames(frames) {
-        this.muxFrames = frames;
-    }
-    setHistoryValue(value) {
-        this.historyValue = value;
-    }
-    /** Synchronous unary dispatch (no HTTP) — used by tests that inject the
-     *  reader's sync transport to avoid the spawnSync-in-process deadlock. */
-    dispatchSync(method, payload, rpcId = `rpc-${randomUUID()}`) {
-        this.requests.push({ method, rpcId, payload });
-        const handler = this.unaryHandlers.get(method);
-        let result;
-        if (handler) {
-            result = handler(payload, rpcId);
-        }
-        else if (method === 'session.history') {
-            result = { ok: true, value: this.historyValue };
-        }
-        else if (method === 'session.list') {
-            result = { ok: true, value: { items: [] } };
-        }
-        else {
-            result = { ok: true, value: {} };
-        }
-        return { type: 'server-response', rpcId, result };
-    }
-    handleMux(res) {
-        res.writeHead(200, {
-            'content-type': 'text/event-stream',
-            'cache-control': 'no-cache',
-            connection: 'keep-alive',
-        });
-        // Drain the SHARED script (shift): the first connection consumes a prefix
-        // then closes (a {close:true} marker or an exhausted queue); a reconnect
-        // continues from where it left off — the natural model of a mid-turn drop.
-        const timer = setInterval(() => {
-            const item = this.muxFrames.shift();
-            if (item === undefined) {
-                clearInterval(timer);
-                res.end();
-                return;
-            }
-            if ('close' in item && item.close === true) {
-                clearInterval(timer);
-                res.end();
-                return;
-            }
-            const frame = item;
-            res.write(`data: ${JSON.stringify({
-                type: 'server-request',
-                rpcId: `mux-${randomUUID()}`,
-                method: frame.type,
-                payload: frame,
-            })}\n\n`);
-        }, 5);
-        reqClose(res, timer);
-    }
-}
-function reqClose(res, timer) {
-    res.on('close', () => clearInterval(timer));
-}
-//# sourceMappingURL=fake-dsh-server.js.map