lark-remote 0.1.5 → 0.1.6

package/dist/router/index.d.ts

@@ -60,6 +60,18 @@ export interface CardActionPayload {
     /** CardKit 2.0 input 组件自带提交图标触发回调时回传的输入值 */
     inputValue?: string;
     orderId?: string;
+    /** Approval request ID for approval card actions. */
+    requestId?: number | string;
+    /** Decision for approval.respond (e.g. 'accept', 'decline', 'cancel'). */
+    decision?: string;
+    /** Scope for acceptForSession: 'turn' | 'session'. */
+    scope?: 'turn' | 'session';
+    /** Unique nonce to prevent duplicate processing. */
+    nonce?: string;
+    /** Permission item ID for approval.toggle. */
+    permId?: string;
+    /** Desired selection state for approval.toggle (card renders !current). */
+    selected?: boolean;
 }
 /**
  * Response a cardAction handler may return to give the clicking user native
@@ -173,6 +185,12 @@ export declare class CommandRouter {
      * Validates payload and dispatches to the corresponding command.
      */
     handleCardAction(value: CardActionPayload, ctx: CommandContext): Promise<CardActionResponse | void>;
+    /**
+     * Handle approval-related card actions.
+     * Routes to the appropriate bridge method based on value.cmd.
+     * Returns a toast response for immediate user feedback.
+     */
+    private handleApprovalAction;
     /**
      * Handle queue.cancel: remove this message from the queue.
      */
@@ -341,8 +359,7 @@ export declare class CommandRouter {
      * /update: check for newer version and upgrade if available.
      * /update check: only check, don't upgrade.
      *
-     * Flow: check version → if newer, install → spawn replacement bridge → exit.
-     * Reuses /restart's restartSpawner + pendingExit mechanism.
+     * Flow: check version → if newer, install → report success (no auto-restart).
      */
     private cmdUpdate;
     private cmdNew;
@@ -365,6 +382,14 @@ export declare class CommandRouter {
      * When the session was cleared, renders a compact notice card instead.
      */
     private buildConfigSwitchCard;
+    /**
+     * Whether a session of the given agent kind can be compacted from a resume
+     * card. Compact (thread/compact/start) is only implemented by the codex
+     * app-server runner (`runCompact`), so the button is gated on
+     * `serviceMode === 'app-server'` — exec mode spawns a fresh CLI per message
+     * and has no persistent session to compact.
+     */
+    private canCompactSession;
     private static readonly LS_PAGE_SIZE;
     private cmdLs;
     private cmdWs;

package/dist/router/index.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import YAML from 'yaml';
-import { getConfigDir, getConfigValue, setConfigValue, setConfigValues, mapAgentKey, assertSafeKeyPart, } from '../config/index.js';
+import { getConfigDir, getConfigValue, setConfigValue, setConfigValues, getAgentConfig, mapAgentKey, assertSafeKeyPart, } from '../config/index.js';
 import { syncAgentChoices } from '../runner/index.js';
 import { WorkspaceStore } from '../workspace/index.js';
 import { OrderStore } from '../order/index.js';
@@ -45,7 +45,7 @@ const RESUME_CONTENT_PREFETCH = 5;
  * `New Session`、空串），都不是真实输入，不得渲染成行标题。
  */
 const RESUME_SUMMARY_PLACEHOLDERS = new Set(['', '(no user message)', '(无摘要)', 'New Session']);
-import { newSessionButton, agentDisplayName } from '../card/card-shared.js';
+import { newSessionButton, resumeCompactButton, agentDisplayName } from '../card/card-shared.js';
 /**
  * Card-action commands that must run with enqueue({ immediate: true }).
  * These bypass the serial queue and execute immediately.
@@ -96,7 +96,12 @@ export function isImmediateAction(cmd) {
         cmd === 'config.toggle' ||
         cmd === 'config.set' ||
         cmd === 'config.input' ||
-        cmd === 'config.save');
+        cmd === 'config.save' ||
+        // 审批响应/权限切换必须即时触达在途 run（同 stop 类控制动作）。若走串行
+        // 队列会排在等待审批的 run 之后形成死锁：run 不结束审批不执行，run 结束
+        // coordinator 已删响应空转（线上复现：approval.respond 排队卡、审批永不生效）。
+        cmd === 'approval.respond' ||
+        cmd === 'approval.toggle');
 }
 export class CommandRouter {
     /** Valid agent kinds — single source of truth for resume.use / resume.page / cmdResume. */
@@ -237,12 +242,12 @@ export class CommandRouter {
                 return;
             case 'ls.page':
                 return this.handleLsPage(value, ctx);
+            case 'ws.page':
+                return this.handleWsPage(value, ctx);
             case 'ws.use':
                 return await this.handleWsUse(value, ctx);
             case 'ws.sort':
                 return await this.handleWsSort(value, ctx);
-            case 'ws.page':
-                return await this.handleWsPage(value, ctx);
             case 'ws.remove':
                 return await this.handleWsRemove(value, ctx);
             case 'resume.use': {
@@ -319,6 +324,15 @@ export class CommandRouter {
                 // 调 updateCardInPlace → Feishu API 乱序到达导致 toggle 卡死。
                 // 2026-07-18: 返回 enqueueConfigAction 的结果以支持 toast 响应
                 return this.enqueueConfigAction(value, ctx);
+            case 'approval.respond':
+            case 'approval.toggle':
+                return this.handleApprovalAction(value, ctx);
+            case 'codex.compact':
+                await this.bridge.handleCodexCompact(value, ctx);
+                return;
+            case 'resume.compact':
+                await this.bridge.handleResumeCompact(value, ctx);
+                return;
             default: {
                 // Help card buttons: help.<cmd> → execute /<cmd>
                 if (value.cmd.startsWith('help.')) {
@@ -344,6 +358,57 @@ export class CommandRouter {
             }
         }
     }
+    /**
+     * Handle approval-related card actions.
+     * Routes to the appropriate bridge method based on value.cmd.
+     * Returns a toast response for immediate user feedback.
+     */
+    async handleApprovalAction(value, _ctx) {
+        const { runId, requestId, decision, scope, nonce, permId } = value;
+        if (value.cmd === 'approval.respond') {
+            if (!runId || requestId === undefined || !decision || !nonce) {
+                return { toast: { type: 'error', content: '缺少审批响应参数' } };
+            }
+            try {
+                await this.bridge.handleApprovalRespond({
+                    runId,
+                    requestId,
+                    decision,
+                    scope,
+                    nonce,
+                });
+                return { toast: { type: 'success', content: '审批已提交' } };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // 审批已过期：给用户明确反馈，不静默不误导（2026-08-12 事故：点了允许无任何反馈）。
+                const content = /state=expired/.test(msg)
+                    ? '⏰ 审批已过期，无法响应'
+                    : `审批响应失败：${msg}`;
+                return { toast: { type: 'error', content } };
+            }
+        }
+        if (value.cmd === 'approval.toggle') {
+            if (!runId || requestId === undefined || !permId || !nonce) {
+                return { toast: { type: 'error', content: '缺少权限切换参数' } };
+            }
+            try {
+                await this.bridge.handleApprovalToggle({
+                    runId,
+                    requestId,
+                    permId,
+                    nonce,
+                    selected: value.selected ?? true,
+                });
+                return { toast: { type: 'info', content: '已切换' } };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { toast: { type: 'error', content: `权限切换失败：${msg}` } };
+            }
+        }
+        return { toast: { type: 'error', content: '未知的审批操作' } };
+    }
     /**
      * Handle queue.cancel: remove this message from the queue.
      */
@@ -984,9 +1049,19 @@ export class CommandRouter {
         if (useResult.text && !useResult.text.includes('已切换')) {
             return { toast: { type: 'error', content: useResult.text } };
         }
-        // Success: if auto-resume produced a card, send it as a reply
-        if (useResult.card) {
-            await this.bridge.sendResult(useResult, ctx);
+        // Success: send auto-resume card, or a persistent text confirmation when
+        // there is no history session. Toast alone is insufficient: for this
+        // immediate action the callback response is swallowed by enqueueImmediate
+        // (fire-and-forget), and even if delivered it is transient — the user gets
+        // no perceivable feedback on the switch. Same rationale as config.save
+        // agent-switch notice: persistent message first, toast only as a
+        // fallback if sendResult fails.
+        let fallbackToast;
+        if (useResult.card || useResult.text) {
+            const sent = await this.bridge.sendResult(useResult, ctx);
+            if (!sent && useResult.text) {
+                fallbackToast = useResult.text;
+            }
         }
         // Refresh the /ws list card in place so "recent" sort is immediately visible
         const currentOffset = Math.max(0, Math.trunc(Number(value.offset) || 0));
@@ -994,11 +1069,11 @@ export class CommandRouter {
         if (refreshed.card) {
             await this.bridge.updateCardInPlace(refreshed.card, ctx);
         }
-        // Toast feedback (suppress text when auto-resume card was already sent)
+        // Toast feedback (suppress text when a persistent message was already sent)
         return {
             toast: {
                 type: 'success',
-                content: useResult.card ? '' : (useResult.text ?? `已切换到 workspace "${name}"`),
+                content: fallbackToast ?? '',
             },
         };
     }
@@ -1667,8 +1742,7 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
      * /update: check for newer version and upgrade if available.
      * /update check: only check, don't upgrade.
      *
-     * Flow: check version → if newer, install → spawn replacement bridge → exit.
-     * Reuses /restart's restartSpawner + pendingExit mechanism.
+     * Flow: check version → if newer, install → report success (no auto-restart).
      */
     async cmdUpdate(args, ctx) {
         const checkOnly = args[0] === 'check';
@@ -1702,21 +1776,8 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
         if (!installResult.success) {
             return { text: `❌ 升级失败: ${installResult.error}` };
         }
-        // 4. Restart (reuse /restart's restartSpawner + pendingExit)
-        if (!this.restartSpawner) {
-            return { text: `✅ 已升级到 ${latest}，请手动 /restart 重启 bridge` };
-        }
-        try {
-            const pid = this.restartSpawner();
-            this.pendingExit = true;
-            return { text: `✅ 升级成功 (${current} → ${latest})，正在重启（新进程 pid ${pid}）…` };
-        }
-        catch (err) {
-            getLogger().error('[router] update restart spawn failed:', err);
-            return {
-                text: `✅ 已升级到 ${latest}，但重启失败：${err.message}，请手动 /restart`,
-            };
-        }
+        // 4. Report success (no auto-restart — user decides when to /restart)
+        return { text: `✅ 升级成功 (${current} → ${latest})，发送 /restart 重启后生效` };
     }
     cmdNew(ctx) {
         // 只清 sessionId 保留 cwd — 否则 /new 之后 /resume 会提示"请先 /cd
@@ -1876,6 +1937,11 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                 ],
             });
         }
+        // Compact 按钮：仅 codex app-server 模式（runner 有 runCompact）且会话未在跑。
+        // 在途 run 会占住 app-server runner，压缩必然失败，此时不渲染。
+        if (!isActive && this.canCompactSession(this.config.defaultAgent)) {
+            actions.push(resumeCompactButton(session.sessionId, this.config.defaultAgent));
+        }
         // New session button always shown (use shared function for consistency)
         actions.push(newSessionButton());
         // Use column_set+column for 2.0 (action tag not supported in 2.0)
@@ -2030,6 +2096,16 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
             },
         };
     }
+    /**
+     * Whether a session of the given agent kind can be compacted from a resume
+     * card. Compact (thread/compact/start) is only implemented by the codex
+     * app-server runner (`runCompact`), so the button is gated on
+     * `serviceMode === 'app-server'` — exec mode spawns a fresh CLI per message
+     * and has no persistent session to compact.
+     */
+    canCompactSession(agentKind) {
+        return (agentKind === 'codex' && getAgentConfig(this.config, 'codex')?.serviceMode === 'app-server');
+    }
     static LS_PAGE_SIZE = 30;
     cmdLs(args, ctx, offset = 0) {
         const cwd = this.sessionStore.getCwd(ctx.userId);
@@ -2551,7 +2627,7 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                 }
                 const card = {
                     schema: '2.0',
-                    config: { wide_screen_mode: true },
+                    config: { wide_screen_mode: true, update_multi: true },
                     header: { title: { tag: 'plain_text', content: 'Workspaces' } },
                     body: { elements: bodyElements },
                 };
@@ -2666,6 +2742,11 @@ ${sessionCwdLine}${agentLines.map((l) => `- ${l}`).join('\n')}
                     behaviors: [{ type: 'callback', value: { cmd: 'stop', runId: activeRunRunId, cwd } }],
                 });
             }
+            // Compact 按钮：仅 codex app-server 模式（runner 有 runCompact）且会话未在跑。
+            // agentKind 来自 /resume [agent] <id> / resume.use 卡片值，非 defaultAgent。
+            if (!isActive && this.canCompactSession(agentKind)) {
+                buttons.push(resumeCompactButton(sessionIdArg, agentKind));
+            }
             if (buttons.length > 0) {
                 elements.push({
                     tag: 'column_set',

package/dist/router/utils.d.ts

@@ -22,6 +22,8 @@ export declare function formatUsageStats(usage?: {
     contextLength?: number;
     contextLimit?: number;
     compactCount?: number;
+    /** 压缩前上下文水位；与 contextLength（压缩后）成对出现在 Compact 卡上。 */
+    compactPreContextLength?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
     /** Agent-declared total; when present the display uses max(total, sum of parts). */

package/dist/router/utils.js

@@ -46,13 +46,16 @@ export function formatUsageStats(usage, options) {
     if (options?.showResult && options?.result) {
         lines.push(`结果 - ${options.result}`);
     }
-    // 2. Context 长度
+    // 2. Context 长度（compact 卡同时展示压缩前水位）
     if (usage?.contextLength !== undefined) {
         const ctxLimit = usage.contextLimit;
         const ctxPercent = ctxLimit !== undefined && ctxLimit > 0
             ? ` (${Math.round((usage.contextLength / ctxLimit) * 100)}%)`
             : '';
-        lines.push(`Context - ${formatTokenK(usage.contextLength)}${ctxPercent}`);
+        const preCompact = usage.compactPreContextLength !== undefined
+            ? `（压缩前 ${formatTokenK(usage.compactPreContextLength)}）`
+            : '';
+        lines.push(`Context - ${formatTokenK(usage.contextLength)}${ctxPercent}${preCompact}`);
     }
     // 3. Compact 次数
     if (usage?.compactCount) {

package/dist/runner/codex/app-server/client.d.ts

@@ -0,0 +1,82 @@
+/**
+ * JSON-RPC client for the Codex App Server protocol.
+ *
+ * Manages the handshake, request/response matching, notification dispatch,
+ * and timeout handling over a JsonlRpcTransport.
+ */
+import type { JsonlRpcTransport } from './transport.js';
+import { type InitializeResult } from './protocol-types.js';
+export declare class RpcError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+export declare class RpcTimeoutError extends Error {
+    constructor(message: string);
+}
+export declare class ConnectionLostError extends Error {
+    constructor(message?: string);
+}
+export interface ClientHooks {
+    onNotification(method: string, params: unknown): void;
+    onServerRequest(id: number | string, method: string, params: unknown): void;
+    onClose(): void;
+}
+export declare class CodexAppServerClient {
+    private transport;
+    /**
+     * Lifecycle hooks owned by the connection layer (ConnectionManager): slot
+     * cleanup + onConnectionLost. These must survive runner's setHooks().
+     */
+    private baseHooks;
+    /** Per-run hooks from the runner, layered over baseHooks via setHooks(). */
+    private runHooks;
+    private requestTimeoutMs;
+    private pendingRequests;
+    private nextId;
+    private _ready;
+    private _disposed;
+    constructor(transport: JsonlRpcTransport, hooks: ClientHooks, requestTimeoutMs?: number);
+    /**
+     * Replace the per-run hooks (used by the runner to bridge
+     * notifications/server requests into the active turn's translator).
+     * Connection-layer hooks (slot cleanup / onConnectionLost) are preserved:
+     * review P2-1 — an overwrite here previously silenced onClose slot cleanup,
+     * leaving dead slots behind after the app-server process was killed.
+     */
+    setHooks(hooks: ClientHooks): void;
+    get ready(): boolean;
+    /**
+     * Whether the underlying transport is still alive (not disposed and not
+     * closed). Used by the connection manager to avoid handing out a cached
+     * client whose child process was killed externally.
+     */
+    get healthy(): boolean;
+    /**
+     * Connect and perform the initialize handshake.
+     * Returns the InitializeResult on success.
+     */
+    connect(): Promise<InitializeResult>;
+    /**
+     * Send a JSON-RPC request and wait for the response.
+     */
+    request<P, R>(method: string, params?: P): Promise<R>;
+    /**
+     * Send a JSON-RPC notification (no response expected).
+     */
+    notify(method: string, params?: unknown): void;
+    /**
+     * Respond to a server request (success).
+     */
+    respond(id: number | string, result: unknown): void;
+    /**
+     * Respond to a server request (error).
+     */
+    respondError(id: number | string, code: number, message: string): void;
+    /**
+     * Dispose the client: cancel pending requests and close transport.
+     */
+    dispose(): Promise<void>;
+    private handleMessage;
+    private failPending;
+}

package/dist/runner/codex/app-server/client.js

@@ -0,0 +1,234 @@
+/**
+ * JSON-RPC client for the Codex App Server protocol.
+ *
+ * Manages the handshake, request/response matching, notification dispatch,
+ * and timeout handling over a JsonlRpcTransport.
+ */
+import { getLogger } from '../../../logger/index.js';
+// =============================================================================
+// Error Types
+// =============================================================================
+export class RpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.name = 'RpcError';
+        this.code = code;
+        this.data = data;
+    }
+}
+export class RpcTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RpcTimeoutError';
+    }
+}
+export class ConnectionLostError extends Error {
+    constructor(message = 'Connection lost') {
+        super(message);
+        this.name = 'ConnectionLostError';
+    }
+}
+// =============================================================================
+// Client
+// =============================================================================
+export class CodexAppServerClient {
+    transport;
+    /**
+     * Lifecycle hooks owned by the connection layer (ConnectionManager): slot
+     * cleanup + onConnectionLost. These must survive runner's setHooks().
+     */
+    baseHooks;
+    /** Per-run hooks from the runner, layered over baseHooks via setHooks(). */
+    runHooks = null;
+    requestTimeoutMs;
+    pendingRequests = new Map();
+    nextId = 1;
+    _ready = false;
+    _disposed = false;
+    constructor(transport, hooks, requestTimeoutMs = 60_000) {
+        this.transport = transport;
+        this.baseHooks = hooks;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    /**
+     * Replace the per-run hooks (used by the runner to bridge
+     * notifications/server requests into the active turn's translator).
+     * Connection-layer hooks (slot cleanup / onConnectionLost) are preserved:
+     * review P2-1 — an overwrite here previously silenced onClose slot cleanup,
+     * leaving dead slots behind after the app-server process was killed.
+     */
+    setHooks(hooks) {
+        this.runHooks = hooks;
+    }
+    get ready() {
+        return this._ready;
+    }
+    /**
+     * Whether the underlying transport is still alive (not disposed and not
+     * closed). Used by the connection manager to avoid handing out a cached
+     * client whose child process was killed externally.
+     */
+    get healthy() {
+        return !this._disposed && !this.transport.closed;
+    }
+    /**
+     * Connect and perform the initialize handshake.
+     * Returns the InitializeResult on success.
+     */
+    async connect() {
+        const events = {
+            onMessage: (msg) => this.handleMessage(msg),
+            onClose: () => {
+                this.failPending(new ConnectionLostError('transport closed'));
+                // 先通知连接层（slot 清理 + onConnectionLost），再通知当前 run 层
+                // （failTurn 等）。两层互不覆盖。
+                this.baseHooks.onClose();
+                this.runHooks?.onClose();
+            },
+        };
+        await this.transport.start(events);
+        // ENOENT/启动失败时 transport 已在 start() 内触发 onClose 并置 closed；
+        // 直接 fail-fast，避免 initialize 请求挂满 requestTimeoutMs 才报错。
+        if (this.transport.closed) {
+            throw new ConnectionLostError('codex app-server failed to start (binary missing or crashed)');
+        }
+        // Send initialize request
+        const initParams = {
+            clientInfo: {
+                name: 'lark-remote',
+                version: '1.0.0',
+            },
+        };
+        const result = await this.request('initialize', initParams);
+        this._ready = true;
+        return result;
+    }
+    /**
+     * Send a JSON-RPC request and wait for the response.
+     */
+    async request(method, params) {
+        if (this._disposed) {
+            throw new ConnectionLostError('client is disposed');
+        }
+        const id = this.nextId++;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new RpcTimeoutError(`request timed out: ${method}`));
+            }, this.requestTimeoutMs);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            this.transport.write(request);
+        });
+    }
+    /**
+     * Send a JSON-RPC notification (no response expected).
+     */
+    notify(method, params) {
+        if (this._disposed)
+            return;
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        this.transport.write(notification);
+    }
+    /**
+     * Respond to a server request (success).
+     */
+    respond(id, result) {
+        const response = {
+            jsonrpc: '2.0',
+            id,
+            result,
+        };
+        this.transport.write(response);
+    }
+    /**
+     * Respond to a server request (error).
+     */
+    respondError(id, code, message) {
+        const response = {
+            jsonrpc: '2.0',
+            id,
+            error: { code, message },
+        };
+        this.transport.write(response);
+    }
+    /**
+     * Dispose the client: cancel pending requests and close transport.
+     */
+    async dispose() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        this._ready = false;
+        this.failPending(new ConnectionLostError('client disposed'));
+        await this.transport.close();
+    }
+    // =========================================================================
+    // Internal
+    // =========================================================================
+    handleMessage(msg) {
+        const message = msg;
+        if ('id' in message && 'result' in message) {
+            // Success response
+            const id = message.id;
+            const pending = this.pendingRequests.get(id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(id);
+                pending.resolve(message.result);
+            }
+            return;
+        }
+        if ('id' in message && 'error' in message) {
+            // Error response
+            const id = message.id;
+            const err = message.error;
+            const pending = this.pendingRequests.get(id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(id);
+                pending.reject(new RpcError(err.code, err.message, err.data));
+            }
+            return;
+        }
+        if ('method' in message && !('id' in message)) {
+            // Notification
+            const method = message.method;
+            this.baseHooks.onNotification(method, message.params);
+            this.runHooks?.onNotification(method, message.params);
+            return;
+        }
+        if ('method' in message && 'id' in message) {
+            // Server request (incoming request from server)
+            const id = message.id;
+            const method = message.method;
+            this.baseHooks.onServerRequest(id, method, message.params);
+            this.runHooks?.onServerRequest(id, method, message.params);
+            return;
+        }
+        getLogger().warn(`[codex-client] unknown message type: ${JSON.stringify(message).slice(0, 200)}`);
+    }
+    failPending(err) {
+        for (const [_id, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(err);
+        }
+        this.pendingRequests.clear();
+    }
+}
+//# sourceMappingURL=client.js.map