wave-code 1.3.0 → 1.5.0

package/src/stdio/daemonServer.ts

@@ -18,10 +18,19 @@ import net from "net";
 import * as fs from "fs";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
 import { JsonRpcConnection } from "./jsonRpcConnection.js";
+import type { RemoteControlSink } from "../remote/remoteControlSink.js";
 
 export interface DaemonServerOptions {
   socketPath: string;
   bridgeOptions?: AgentBridgeOptions;
+  /**
+   * Built with the bridge (which the daemon owns privately) so the sink can
+   * route inbound phone requests back through it. Its notifications are wired
+   * up here; connecting is the user's call, not ours. Unset means remote
+   * control is off for this daemon — the `remoteControl*` RPCs then report
+   * exactly that through the bridge's own error.
+   */
+  createRemoteSink?: (bridge: AgentBridge) => RemoteControlSink;
 }
 
 export class DaemonServer {
@@ -30,11 +39,17 @@ export class DaemonServer {
   private bridge: AgentBridge;
   private connections = new Set<JsonRpcConnection>();
   private sockets = new Set<net.Socket>();
+  private remoteSink: RemoteControlSink | undefined;
 
   constructor(options: DaemonServerOptions) {
     this.socketPath = options.socketPath;
+    let remoteSink: RemoteControlSink | undefined;
     this.bridge = new AgentBridge({
       ...options.bridgeOptions,
+      // The sink is handed the bridge it must route phone requests back
+      // through, so it can only be built after it; reading it lazily keeps the
+      // two from having to be constructed in a circle.
+      remoteControl: () => remoteSink,
       // Notifications go to every attached client; a fully detached daemon
       // has none, and the write is dropped silently (the attach snapshot
       // re-syncs state on reconnect).
@@ -42,11 +57,20 @@ export class DaemonServer {
         for (const conn of this.connections) {
           conn.sendNotification(method, params, sessionId);
         }
+        // The phone must never be able to take the local clients down with
+        // it, so a remote-path failure is contained here rather than thrown.
+        try {
+          this.remoteSink?.sendNotification(method, params, sessionId);
+        } catch {
+          // Dropped frame; the phone re-syncs on reconnect.
+        }
       },
       // The `shutdown` RPC (wave daemon stop/restart) destroys every session in
       // the bridge, then hands off here to tear the process down.
       onShutdownRequest: () => this.shutdown(),
     });
+    remoteSink = options.createRemoteSink?.(this.bridge);
+    this.remoteSink = remoteSink;
     this.server = net.createServer((socket) => {
       const conn = new JsonRpcConnection(socket, socket, this.bridge);
       this.connections.add(conn);
@@ -124,6 +148,8 @@ export class DaemonServer {
 
   stop(): Promise<void> {
     return new Promise((resolve) => {
+      this.remoteSink?.stop();
+      this.remoteSink = undefined;
       const server = this.server;
       if (!server) return resolve();
       this.server = undefined;
@@ -140,6 +166,10 @@ export class DaemonServer {
    * teardown.
    */
   private shutdown(): void {
+    // Drop the relay link explicitly: the process is about to exit, and leaving
+    // the socket to the OS would have the relay hold a dead subscription.
+    this.remoteSink?.stop();
+    this.remoteSink = undefined;
     for (const socket of this.sockets) socket.destroy();
     this.sockets.clear();
     this.server?.close();

package/src/stdio/hostSlashCommands.ts

@@ -0,0 +1,209 @@
+/**
+ * The **one** table of host-local slash commands (spec ui/slash-commands.md
+ * 「弹窗里的宿主命令只有一份表——由服务端下发并按入口过滤」).
+ *
+ * These are the commands a front end handles itself — it opens a dialog, a
+ * settings page or a panel, or it intercepts the text before it reaches the
+ * agent. They are not registered with the SDK, so they cannot come from
+ * `agent.getSlashCommands()`; before this table existed each host carried its
+ * own copy (desktop 17, VS Code 18, JetBrains 17 — differing on `/clear` and
+ * `/config` only) and the phone page carried none, which is why the same
+ * command was visible on the computer and had to be typed by hand on the phone.
+ *
+ * It lives here, next to `AgentBridge`, because that is the one place every
+ * front end already talks to: the daemon and each GUI's `--stdio` child serve
+ * the popup from it, the phone's requests land on it, and JetBrains — which
+ * cannot import TypeScript at all — reads it as JSON over the same RPC.
+ *
+ * **What each entry claims**: `surfaces` is the set of front ends that really
+ * implement it. It is a capability statement, not a label: an entry listed for
+ * a surface that has no handling behind it produces exactly the defect spec
+ * ui/remote-control.md 场景 24 forbids — a row in the popup that does nothing
+ * when picked. `hostSlashCommands.test.ts` pins each surface's set, and the
+ * remote-page set is also cross-checked there against the remote allowlist,
+ * which is the other half of the same promise (popup lists it ⇒ picking it
+ * works).
+ */
+
+import type { HostSurface, SlashCommandInfo } from "wave-agent-sdk/types";
+
+/** Which front ends a command is offered to. */
+type Surfaces = readonly HostSurface[];
+
+interface HostSlashCommandSpec {
+  id: string;
+  description: string;
+  /** Absent = insert `/name ` and let the user finish (only `/btw` today). */
+  runOnSelect?: boolean;
+  surfaces: Surfaces;
+}
+
+/** Everyone's entries — `/clear` being the one that is not quite everyone's. */
+const ALL: Surfaces = ["desktop", "vscode", "jetbrains", "remote-page"];
+
+/** The GUIs that own a settings page / marketplace / panel — not the phone. */
+const GUIS: Surfaces = ["desktop", "vscode", "jetbrains"];
+
+/**
+ * The table, in popup order. Order matters: the popup appends these after the
+ * SDK's own commands and renders them as given, so the machine also decides
+ * where a command sits. This is the order the two GUI hosts already used.
+ */
+export const HOST_SLASH_COMMANDS: readonly HostSlashCommandSpec[] = [
+  // ── 需要宿主界面的：只有桌面端与 IDE 有承载它们的页面 ──
+  {
+    id: "config",
+    description: "打开配置设置",
+    runOnSelect: true,
+    // JB 的设置页在自己的菜单里，没有这条入口；远控页没有设置页。
+    surfaces: ["desktop", "vscode"],
+  },
+  {
+    id: "plugin",
+    description: "打开插件市场",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "reload-plugins",
+    description: "就地重载插件（不重启对话）",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "mcp",
+    description: "打开 MCP 服务器管理",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+
+  // ── 页面也能执行的：背后是会话内的方法，不需要编辑器与文件系统 ──
+  {
+    id: "status",
+    description: "查看当前状态",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "remote-control",
+    description: "远程控制（用手机接管本机会话）",
+    runOnSelect: true,
+    // 远控页不列它：那一页就是二维码指向的东西，给自己开一个入口是自我指涉。
+    surfaces: GUIS,
+  },
+  {
+    id: "clear",
+    description: "清除对话历史并重置会话",
+    runOnSelect: true,
+    // 桌面端整端移除了 `/clear`（2026-09-05 拍板，见 clear-command.md 与
+    // ui/remote-control.md 场景 24）。
+    surfaces: ["vscode", "jetbrains", "remote-page"],
+  },
+  {
+    id: "compact",
+    description: "手动压缩对话历史",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "tasks",
+    description: "查看后台任务",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "workflows",
+    description: "查看工作流运行",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  {
+    id: "agents",
+    description: "查看可用 agents",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "skills",
+    description: "查看可用技能",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "hooks",
+    description: "查看已配置钩子",
+    runOnSelect: true,
+    surfaces: GUIS,
+  },
+  {
+    id: "rewind",
+    description: "回退到之前的用户消息",
+    runOnSelect: true,
+    surfaces: ALL,
+  },
+  // `/model` 不在这里：模型入口自 2026-10-21 起是输入卡片底栏的选择器（见 spec
+  // ui/model-selection.md），桌面 / IDE / 远控页都不再有这条命令；CLI 的 TUI 没有
+  // 底栏，因此 `/model` 只留在它自己的命令表里（packages/code 的 AVAILABLE_COMMANDS）。
+  {
+    id: "resume",
+    description: "恢复历史对话",
+    runOnSelect: true,
+    // 页面的会话列表只报进程内的活会话，磁盘历史会话在那边不渲染（场景 24）。
+    surfaces: GUIS,
+  },
+  {
+    id: "btw",
+    description: "旁路提问（不进入聊天记录）",
+    // 不标 `runOnSelect`：选中后只把 `/btw ` 插进输入框，等用户补问题
+    // （spec ui/btw-command.md）。
+    surfaces: ALL,
+  },
+  {
+    id: "plan",
+    description: "启用规划模式或查看当前方案",
+    runOnSelect: true,
+    // 页面上没有计划预览面板，计划正文渲染在 ExitPlanMode 的审批卡里。
+    surfaces: GUIS,
+  },
+];
+
+/** The table as one surface sees it, already in wire shape. */
+export function hostSlashCommandsFor(surface: HostSurface): SlashCommandInfo[] {
+  return HOST_SLASH_COMMANDS.filter((command) =>
+    command.surfaces.includes(surface),
+  ).map((command) => ({
+    id: command.id,
+    name: command.id,
+    description: command.description,
+    ...(command.runOnSelect ? { runOnSelect: true } : {}),
+  }));
+}
+
+/**
+ * An agent command as the popup's wire shape — `handler` and `immediate` do
+ * not cross the wire, and `skillSource` is kept only when it is actually set
+ * (the webview reads "has a source tag" off its presence).
+ */
+export function toSlashCommandInfo(command: {
+  id: string;
+  name: string;
+  description: string;
+  skillSource?: SlashCommandInfo["skillSource"];
+}): SlashCommandInfo {
+  return {
+    id: command.id,
+    name: command.name,
+    description: command.description,
+    ...(command.skillSource ? { skillSource: command.skillSource } : {}),
+  };
+}
+
+/** Narrow the `surface` field a caller sent, or `undefined` when absent/unknown. */
+export function parseHostSurface(value: unknown): HostSurface | undefined {
+  return value === "desktop" ||
+    value === "vscode" ||
+    value === "jetbrains" ||
+    value === "remote-page"
+    ? value
+    : undefined;
+}

package/src/stdio/jsonRpcConnection.ts

@@ -12,9 +12,11 @@ import readline from "readline";
 import type { Readable, Writable } from "stream";
 import { AgentBridge } from "./agentBridge.js";
 import {
+  type ClientNotificationMethod,
   type JsonRpcRequest,
   type JsonRpcResponse,
   type JsonRpcNotification,
+  type RequestMethod,
   PARSE_ERROR,
   INVALID_REQUEST,
   INTERNAL_ERROR,
@@ -123,8 +125,12 @@ export class JsonRpcConnection {
 
   private async handleRequest(msg: JsonRpcRequest): Promise<void> {
     try {
+      // The boundary and the only cast: JSON-RPC `method` is untrusted input.
+      // Anything outside the union still reaches the bridge and is answered by
+      // its `default:` branch with -32601 — the type stops at this line, and no
+      // runtime allow-list is duplicated here.
       const result = await this.bridge.handleRequest(
-        msg.method,
+        msg.method as RequestMethod,
         msg.params,
         msg.sessionId,
       );
@@ -141,7 +147,10 @@ export class JsonRpcConnection {
 
   private handleNotification(msg: JsonRpcNotification): void {
     try {
-      this.bridge.handleNotification(msg.method, msg.params);
+      this.bridge.handleNotification(
+        msg.method as ClientNotificationMethod,
+        msg.params,
+      );
     } catch (err) {
       // Notifications don't get responses, but we log to stderr
       process.stderr.write(

package/src/stdio/protocol.ts

@@ -44,121 +44,20 @@ export const METHOD_NOT_FOUND = -32601;
 export const INVALID_PARAMS = -32602;
 export const INTERNAL_ERROR = -32603;
 
-// ── Client → Server request methods ─────────────────────────────
-
-export type RequestMethod =
-  | "initialize"
-  | "destroy"
-  | "restoreSession"
-  | "listSessions"
-  | "listAllSessions"
-  | "renameSession"
-  | "getSessionInfo"
-  | "sendMessage"
-  | "bang"
-  | "askBtw"
-  | "abortMessage"
-  | "clearMessages"
-  | "rewindToMessage"
-  | "listRewindCheckpoints"
-  | "deleteQueuedMessage"
-  | "updateQueuedMessage"
-  | "deleteQueuedMessageById"
-  | "getMessages"
-  | "getFullMessageThread"
-  | "setPermissionMode"
-  | "getPermissionMode"
-  | "getPlanFile"
-  | "getMcpServers"
-  | "connectMcpServer"
-  | "disconnectMcpServer"
-  | "removeMcpServer"
-  | "getMcpConfigPaths"
-  | "getSlashCommands"
-  | "getSubagentConfigurations"
-  | "getSkillMetadata"
-  | "deleteSkill"
-  | "deleteSubagent"
-  | "getHooksByScope"
-  | "deleteHook"
-  | "searchFiles"
-  | "writeArtifactFile"
-  | "getPromptHistory"
-  | "searchPromptHistory"
-  | "updateConfig"
-  | "getConfiguredModels"
-  | "setModel"
-  // User preferences (global — read/write user-level ~/.wave/settings.json,
-  // 设置页保存路径，见 docs/specs/core/agent-config.md「设置实时重载」)
-  | "getUserSettings"
-  | "updateUserSettings"
-  // Permissions (daemon attach: re-surface pending approvals after reconnect)
-  | "listPendingPermissions"
-  // Daemon (global — list in-memory session registry, no session required)
-  | "listDaemonSessions"
-  // Auth
-  | "getAuthStatus"
-  | "getAccountInfo"
-  | "login"
-  | "logout"
-  // Memory files (user-level ~/.wave/AGENTS.md and project-level <workdir>/AGENTS.md)
-  | "getAgentsContent"
-  | "setAgentsContent"
-  // Plugins
-  | "listPlugins"
-  | "installPlugin"
-  | "uninstallPlugin"
-  | "enablePlugin"
-  | "disablePlugin"
-  | "updatePlugin"
-  | "setPluginScope"
-  | "reloadPlugins"
-  | "listMarketplaces"
-  | "addMarketplace"
-  | "removeMarketplace"
-  | "updateMarketplace"
-  | "compact"
-  | "getBackgroundTaskOutput"
-  | "stopBackgroundTask"
-  | "getWorkflowRuns"
-  | "stopWorkflowRun"
-  // Git / worktree (global — no session required)
-  | "listGitBranches"
-  | "createWorktree"
-  | "getWorktreeChanges"
-  | "removeWorktree";
-
-// ── Client → Server notification methods ────────────────────────
-
-export type ClientNotificationMethod = "permissionResponse";
-
-// ── Server → Client notification methods ────────────────────────
-
-export type ServerNotificationMethod =
-  | "userMessageAdded"
-  | "assistantMessageAdded"
-  | "assistantContentUpdated"
-  | "assistantReasoningUpdated"
-  | "toolBlockUpdated"
-  | "errorBlockAdded"
-  | "loadingChange"
-  | "commandRunningChange"
-  | "queuedMessagesChange"
-  | "tasksChange"
-  | "sessionIdChange"
-  | "permissionModeChange"
-  | "mcpServersChange"
-  | "workdirChange"
-  | "notificationMessageAdded"
-  | "permissionRequest"
-  | "authUrl"
-  | "compactBlockAdded"
-  | "compactionStateChange"
-  | "compactionContentUpdate"
-  | "planFileUpdated"
-  | "backgroundTasksChange"
-  | "btwContent"
-  | "contextUsage";
+// ── Method / notification lists ────────────────────────────────
+// Declared once, in the SDK (`src/types/stdioProtocol.ts`), because the RPC
+// client lives there too and both sides of the wire must read the same union.
+// Re-exported here so this package has one module to import from.
+//
+// The compiler — not a source-scanning test — is what keeps them honest: the
+// bridge's `default:` branch is `never`-checked, and `emit` / `RpcClient` are
+// typed with these unions, so a method added on one side without the other does
+// not build.
+export type {
+  ClientNotificationMethod,
+  RequestMethod,
+  ServerNotificationMethod,
+} from "wave-agent-sdk";
 
 // ── Helper: is this a request (has id)? ─────────────────────────
 

package/src/stdio/stdioServer.ts

@@ -9,23 +9,47 @@
 import type { Readable, Writable } from "stream";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
 import { JsonRpcConnection } from "./jsonRpcConnection.js";
+import type { RemoteControlSink } from "../remote/remoteControlSink.js";
 
 export interface StdioServerOptions {
   input?: Readable;
   output?: Writable;
   bridgeOptions?: AgentBridgeOptions;
+  /**
+   * Same seam as `DaemonServerOptions.createRemoteSink`, for the other server
+   * that owns sessions: the `--stdio` child a GUI host spawns. Unset means
+   * remote control is off for this child — the `remoteControl*` RPCs then
+   * report exactly that through the bridge's own error.
+   */
+  createRemoteSink?: (bridge: AgentBridge) => RemoteControlSink;
 }
 
 export class StdioServer {
   private bridge: AgentBridge;
   private conn: JsonRpcConnection;
+  private remoteSink: RemoteControlSink | undefined;
 
   constructor(options: StdioServerOptions = {}) {
+    let remoteSink: RemoteControlSink | undefined;
     this.bridge = new AgentBridge({
       ...options.bridgeOptions,
-      emit: (method, params, sessionId) =>
-        this.sendNotification(method, params, sessionId),
+      // The sink is handed the bridge it must route phone requests back
+      // through, so it can only be built after it; reading it lazily keeps the
+      // two from having to be constructed in a circle.
+      remoteControl: () => remoteSink,
+      emit: (method, params, sessionId) => {
+        this.sendNotification(method, params, sessionId);
+        // The phone must never be able to take the host's own client down with
+        // it, so a remote-path failure is contained here rather than thrown.
+        try {
+          this.remoteSink?.sendNotification(method, params, sessionId);
+        } catch {
+          // Dropped frame; the phone re-syncs on reconnect.
+        }
+      },
     });
+    remoteSink = options.createRemoteSink?.(this.bridge);
+    this.remoteSink = remoteSink;
     this.conn = new JsonRpcConnection(
       options.input ?? process.stdin,
       options.output ?? process.stdout,
@@ -43,6 +67,8 @@ export class StdioServer {
   }
 
   stop(): void {
+    this.remoteSink?.stop();
+    this.remoteSink = undefined;
     this.conn.stop();
   }
 
@@ -52,9 +78,14 @@ export class StdioServer {
    * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
    * exit. This is the real-world "parent died" path: without it the process
    * lingers forever whenever an agent keeps event-loop handles alive.
+   *
+   * The relay link is dropped explicitly before the exit: leaving the socket to
+   * the OS would have the relay hold a subscription for a process that is gone.
    */
   private async onConnectionClosed(): Promise<void> {
     const SHUTDOWN_TIMEOUT_MS = 5_000;
+    this.remoteSink?.stop();
+    this.remoteSink = undefined;
     await Promise.race([
       this.bridge.destroyAll(),
       new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),

package/src/stdio/uiPayload.ts

@@ -0,0 +1,65 @@
+/**
+ * Payload trimming for everything this process sends **to a UI**
+ * (docs/specs/ui/stdio-transport.md「工具图片的字节不下发 UI」).
+ *
+ * Tool images arrive as base64 on `ToolBlock.images` (Read on a picture, MCP
+ * tools returning image content). No UI renders them — the webview's only read
+ * of the field sits in a branch that never runs for a tool block, the CLI shows
+ * a count — while one screenshot can be well over a megabyte of base64, and a
+ * remote-hosted page cannot even receive a frame that large. So every message
+ * leaving this process for a host goes through here: notifications,
+ * `getMessages`, `getFullMessageThread`, and the remote relay that is fed by
+ * the same frames.
+ *
+ * **The agent's own copy is untouched.** The SDK still holds the bytes, the
+ * next request still sends them to the model, and the transcript on disk keeps
+ * them. This is a wire cut, not a memory model: stripping `images` where the
+ * SDK writes the block would break the next turn, so do not move it there.
+ *
+ * Copies are shallow and made only where the field is actually present — the
+ * common message (no images) keeps its identity and costs nothing.
+ */
+
+import type {
+  Message,
+  ToolBlock,
+  ToolBlockUpdateCallbackParams,
+} from "wave-agent-sdk";
+
+/** A message whose tool blocks carry no image bytes. */
+export function messageForUi(message: Message): Message {
+  const { blocks } = message;
+  if (!Array.isArray(blocks)) return message;
+  const trimmed = blocks.map((block) =>
+    block.type === "tool" && hasImages(block) ? withoutImages(block) : block,
+  );
+  const changed = trimmed.some((block, index) => block !== blocks[index]);
+  return changed ? { ...message, blocks: trimmed } : message;
+}
+
+/** `messageForUi` over a page / list, preserving the array when nothing changed. */
+export function messagesForUi(messages: Message[]): Message[] {
+  const trimmed = messages.map(messageForUi);
+  const changed = trimmed.some((message, index) => message !== messages[index]);
+  return changed ? trimmed : messages;
+}
+
+/** A `toolBlockUpdated` frame whose block carries no image bytes. */
+export function toolBlockUpdateForUi(
+  params: ToolBlockUpdateCallbackParams,
+): ToolBlockUpdateCallbackParams {
+  if (!params.images || params.images.length === 0) return params;
+  const { images, ...rest } = params;
+  void images;
+  return rest;
+}
+
+function hasImages(block: ToolBlock): boolean {
+  return Array.isArray(block.images) && block.images.length > 0;
+}
+
+function withoutImages(block: ToolBlock): ToolBlock {
+  const { images, ...rest } = block;
+  void images;
+  return rest;
+}

package/src/stdio-cli.ts

@@ -6,8 +6,9 @@
  * the client sends an "initialize" request.
  */
 
-import { ensureRuntimeDeps } from "wave-agent-sdk";
+import { ensureRuntimeDeps, setTelemetryStdoutProtected } from "wave-agent-sdk";
 import { StdioServer } from "./stdio/stdioServer.js";
+import { createRemoteControlSinkFactory } from "./remote/remoteControlSink.js";
 import { logger } from "./utils/logger.js";
 
 /**
@@ -55,6 +56,10 @@ export function guardStdoutForJsonRpc(): void {
 
 export async function startStdioCli(): Promise<void> {
   guardStdoutForJsonRpc();
+  // stdout is the JSON-RPC channel here: console telemetry exporters would
+  // print onto it (OTel's console exporters use console.dir, which
+  // guardStdoutForJsonRpc does not cover) — strip them at config resolution.
+  setTelemetryStdoutProtected(true);
   // Install the on-demand runtime dependencies (image codec + ripgrep) before
   // answering any RPC (see cli.tsx). Blocking here is what closes the race: the
   // host's `initialize` — and with it the webview's initial state — only lands
@@ -69,7 +74,11 @@ export async function startStdioCli(): Promise<void> {
     crashHandler("unhandledRejection", reason),
   );
 
-  const server = new StdioServer();
+  const server = new StdioServer({
+    // This child owns the sessions its host shows, so it — not a daemon on the
+    // same machine — is what serves a paired phone.
+    createRemoteSink: createRemoteControlSinkFactory(process.cwd()),
+  });
   server.start();
 
   // Keep the process alive — readline on stdin handles the event loop.

package/src/types.ts

@@ -18,4 +18,11 @@ export interface BaseAppProps {
   model?: string;
   /** Optional MCP server configs to pass to Agent.create() */
   mcpServers?: Record<string, McpServerConfig>;
+  /**
+   * Erases what ink has drawn without touching the terminal scrollback (ink's
+   * `instance.clear()`, injected by the CLI entry where the ink instance lives).
+   * Actions that must leave the previous conversation scrollable above — `/clear`
+   * — use it instead of a hard erase.
+   */
+  onClearOutput?: () => void;
 }