@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.1

package/packages/shared/src/{tool-resolver.ts → platform/binary-lookup.ts}

@@ -3,11 +3,31 @@
  * Replaces scattered whichSync/resolvePiCommand/resolveTsxCommand implementations
  * with a single configurable resolver.
  */
-import { execSync } from "node:child_process";
+import { execSync, spawnSync, buildSafeArgv } from "./exec.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { MANAGED_BIN, MANAGED_DIR } from "./managed-paths.js";
+import { MANAGED_BIN, MANAGED_DIR } from "../managed-paths.js";
+
+/**
+ * Well-known globalThis symbol for the default `ToolRegistry`.
+ *
+ * The registry publishes itself here when first constructed (see
+ * `tool-registry/index.ts::getDefaultRegistry`). Delegation avoids a
+ * static import cycle (tool-registry strategies already import from
+ * this file).
+ *
+ * See change: consolidate-windows-spawn-and-platform-handlers.
+ */
+const GLOBAL_REGISTRY_KEY = Symbol.for("pi-dashboard.tool-registry");
+interface LazyRegistry {
+  has(n: string): boolean;
+  resolveExecutor(n: string): { ok: boolean; argv: string[] };
+}
+function tryGetRegistry(): LazyRegistry | null {
+  const reg = (globalThis as unknown as { [k: symbol]: LazyRegistry | undefined })[GLOBAL_REGISTRY_KEY];
+  return reg ?? null;
+}
 
 export interface ResolverContext {
   /** Extra bin dirs to search before system PATH (e.g., bundled Node dir). */
@@ -59,25 +79,27 @@ export class ToolResolver {
   }
 
   /**
-   * Resolve pi as [cmd, ...prefixArgs].
-   * On Windows, avoids .cmd by returning [node.exe, cli.js].
+   * Resolve pi as spawn-ready argv `[cmd, ...prefixArgs]`.
+   *
+   * Fully delegates to `ToolRegistry.resolveExecutor("pi")`, which
+   * owns per-OS discovery + interpreter assembly (on Windows: find
+   * `pi-coding-agent/dist/cli.js` via managed/bare-import/npm-global
+   * and prepend `node.exe`; on Unix: find `pi` binary on PATH).
+   *
+   * Returns null when the registry is not yet constructed AND pi is
+   * not on PATH (very early boot / standalone tests). Production code
+   * always has the registry available before spawn.
    */
   resolvePi(): string[] | null {
-    if (process.platform === "win32") {
-      // Avoid .cmd — resolve pi's JS entry point directly
-      const piCli = path.join(MANAGED_BIN, "..", "@mariozechner", "pi-coding-agent", "dist", "cli.js");
-      if (existsSync(piCli)) {
-        const node = this.resolveNode();
-        if (node) return [node, piCli];
-      }
-      // Fallback to .cmd
-      const cmd = path.join(MANAGED_BIN, "pi.cmd");
-      if (existsSync(cmd)) return [cmd];
+    const registry = tryGetRegistry();
+    if (registry?.has("pi")) {
+      const exec = registry.resolveExecutor("pi");
+      if (exec.ok && exec.argv.length > 0) return exec.argv;
     }
-
+    // No registry in this process (e.g. legacy bootstrap) — fall back
+    // to PATH lookup so the method still works for non-server callers.
     const piPath = this.which("pi");
-    if (piPath) return [piPath];
-    return null;
+    return piPath ? [piPath] : null;
   }
 
   /**
@@ -160,28 +182,106 @@ export class ToolResolver {
 
 // ── Internal helpers ──────────────────────────────────────────────────────────
 
-/** Resolve a command on the current process PATH via which/where. */
-function whichSync(cmd: string): string | null {
-  const whichCmd = process.platform === "win32" ? "where" : "which";
+/**
+ * Run `where|which <target>` and return ALL stdout lines (trimmed,
+ * non-empty), or `[]`.
+ *
+ * Uses `spawnSync` via `buildSafeArgv` — no shell interpretation at
+ * all. `execSync("where tmux")` used to route through cmd.exe (because
+ * execSync takes a shell command string); spawnSync with argv bypasses
+ * that entirely. Guaranteed no cmd.exe console flash.
+ *
+ * See change: consolidate-windows-spawn-and-platform-handlers.
+ */
+function whereAllLines(whichCmd: string, target: string): string[] {
   try {
-    return execSync(`${whichCmd} ${cmd}`, {
+    const { argv, spawnOptions } = buildSafeArgv(whichCmd, [target]);
+    const result = spawnSync<string>(argv[0], argv.slice(1), {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
-    }).trim().split("\n")[0];
+      ...spawnOptions,
+    });
+    if (result.status !== 0) return [];
+    const text = typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "");
+    return text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
   } catch {
-    return null;
+    return [];
   }
 }
 
+/** Extract the file extension (lower-cased, including the dot) from a path, or "". */
+function extOf(p: string): string {
+  const slash = Math.max(p.lastIndexOf("\\"), p.lastIndexOf("/"));
+  const dot = p.lastIndexOf(".");
+  return dot > slash ? p.slice(dot).toLowerCase() : "";
+}
+
+/**
+ * Resolve a command on PATH.
+ *
+ * Unix: the first `which <name>` hit is authoritative.
+ *
+ * Windows: `where <name>` lists ALL PATH matches — a directory may contain
+ * both a bash shim (extensionless, e.g. `pi`) and a Windows-native form
+ * (`pi.cmd`). Node's `spawn()` cannot execute extensionless shims on
+ * Windows without `shell: true`, so we pick the first line whose extension
+ * is in PATHEXT. Falls back to the first line if none match (preserves
+ * whatever the user set up).
+ *
+ * Single `where` invocation — no per-extension probe loop — to keep
+ * resolution fast (especially when the command is missing entirely).
+ */
+function whichSync(cmd: string): string | null {
+  const isWin = process.platform === "win32";
+  if (!isWin) {
+    const lines = whereAllLines("which", cmd);
+    return lines[0] ?? null;
+  }
+
+  const lines = whereAllLines("where", cmd);
+  if (lines.length === 0) return null;
+
+  // If the caller already specified an extension, trust their pick.
+  const callerHasExt = /\.[A-Za-z0-9]+$/.test(cmd);
+  if (callerHasExt) return lines[0];
+
+  // Preference order: PATHEXT (user's actual Windows search path) or a
+  // standard default. Lower-cased for case-insensitive matching.
+  const pathextRaw = process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PS1";
+  const pathext = pathextRaw.split(";").map((e) => e.trim().toLowerCase()).filter(Boolean);
+
+  // Pick the first line whose extension matches PATHEXT, scanning by
+  // preference order (lower index = more preferred).
+  let best: string | null = null;
+  let bestRank = Infinity;
+  for (const line of lines) {
+    const rank = pathext.indexOf(extOf(line));
+    if (rank === -1) continue;
+    if (rank < bestRank) {
+      best = line;
+      bestRank = rank;
+    }
+  }
+  if (best) return best;
+
+  // No PATHEXT-matching entry — fall back to first line (could be a bash
+  // shim). The runner layer handles the `.cmd` / `.bat` spawn-via-shell
+  // case separately; extensionless shims will still ENOENT but that's
+  // the right signal to the caller.
+  return lines[0];
+}
+
 /** Resolve a command via login shell (picks up nvm/volta/homebrew paths). */
 function whichViaLoginShell(cmd: string): string | null {
   const shell = process.env.SHELL || "/bin/zsh";
   try {
-    const output = execSync(`${shell} -ilc "which ${cmd}"`, {
+    const raw = execSync(`${shell} -ilc "which ${cmd}"`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5000,
-    }).trim();
+      windowsHide: true,
+    });
+    const output = (typeof raw === "string" ? raw : String(raw)).trim();
     // Extract absolute path from potentially noisy login shell output
     const pathLine = output.split("\n").find(l => l.trim().startsWith("/"));
     return pathLine?.trim() || null;

package/packages/shared/src/platform/commands.ts

@@ -0,0 +1,100 @@
+/**
+ * Cross-platform OS-command primitives: open URL in default browser,
+ * detect whether the host is a virtual machine.
+ *
+ * Every OS-dependent helper accepts injectable `platform` and `exec`
+ * (or `child_exec` for async) parameters, so tests can exercise both
+ * branches without mutating globals.
+ * See change: consolidate-platform-handlers.
+ */
+
+import { exec as childExec, execSync } from "./exec.js";
+
+type ExecFn = (cmd: string, opts: { encoding: "utf-8"; timeout?: number }) => string;
+export type AsyncExecFn = (cmd: string, cb: (err: Error | null) => void) => void;
+
+export interface CommandsOpts {
+  /** Override platform (defaults to process.platform). */
+  platform?: NodeJS.Platform;
+  /** Override synchronous exec (for VM detection tests). */
+  exec?: ExecFn;
+  /** Override async exec (for openBrowser tests). */
+  asyncExec?: AsyncExecFn;
+}
+
+function defaultExec(cmd: string, opts: { encoding: "utf-8"; timeout?: number }): string {
+  return execSync(cmd, { ...opts, windowsHide: true }) as unknown as string;
+}
+
+function defaultAsyncExec(cmd: string, cb: (err: Error | null) => void): void {
+  childExec(cmd, { windowsHide: true }, (err) => cb(err));
+}
+
+// ── Open URL in default browser ─────────────────────────────────────────────
+
+/**
+ * Open a URL in the system's default browser. Fire-and-forget; errors are
+ * logged via `onError` but not thrown.
+ *   - darwin: `open "<url>"`
+ *   - win32:  `start "" "<url>"`
+ *   - linux:  `xdg-open "<url>"`
+ */
+export function openBrowser(
+  url: string,
+  opts: CommandsOpts & { onError?: (err: Error) => void } = {},
+): void {
+  const platform = opts.platform ?? process.platform;
+  const asyncExec = opts.asyncExec ?? defaultAsyncExec;
+  const quoted = JSON.stringify(url);
+  const cmd =
+    platform === "darwin" ? `open ${quoted}`
+    : platform === "win32" ? `start "" ${quoted}`
+    : `xdg-open ${quoted}`;
+  asyncExec(cmd, (err) => {
+    if (err && opts.onError) opts.onError(err);
+  });
+}
+
+// ── Virtual-machine detection ───────────────────────────────────────────────
+
+/**
+ * Best-effort virtual-machine detection. Uses platform-specific probes:
+ *   - darwin: `sysctl -n hw.model` looks for VMware/VirtualBox/Parallels
+ *   - linux:  `systemd-detect-virt` — non-`none` output means VM
+ *   - win32:  `wmic bios get serialnumber` + `wmic computersystem get manufacturer,model`
+ *             patterns: VMware | VirtualBox | VBOX | Parallels | Virtual Machine | Hyper-V
+ *
+ * Returns `false` on any probe failure (best-effort).
+ */
+export function isVirtualMachine(opts: CommandsOpts = {}): boolean {
+  const platform = opts.platform ?? process.platform;
+  const exec = opts.exec ?? defaultExec;
+  try {
+    if (platform === "darwin") {
+      const model = String(exec("sysctl -n hw.model", { encoding: "utf-8" })).trim();
+      return /VMware|VirtualBox|Parallels/i.test(model);
+    }
+    if (platform === "linux") {
+      const virt = String(exec("systemd-detect-virt 2>/dev/null || echo none", { encoding: "utf-8" })).trim();
+      return virt !== "none" && virt.length > 0;
+    }
+    if (platform === "win32") {
+      const checks = [
+        "wmic bios get serialnumber",
+        "wmic computersystem get manufacturer,model",
+      ];
+      for (const cmd of checks) {
+        try {
+          const out = String(exec(cmd, { encoding: "utf-8", timeout: 5000 }));
+          if (/VMware|VirtualBox|VBOX|Parallels|Virtual Machine|Hyper-V/i.test(out)) return true;
+        } catch {
+          /* try next */
+        }
+      }
+      return false;
+    }
+  } catch {
+    /* ignore */
+  }
+  return false;
+}

package/packages/shared/src/platform/detached-spawn.ts

@@ -0,0 +1,305 @@
+/**
+ * OS-aware detached-child spawn primitives.
+ *
+ * The dashboard spawns several kinds of long-lived detached children
+ * (pi sessions, dashboard server from Electron or bridge, CLI restart
+ * orchestrator) and every site re-implemented the same spawn-then-wait
+ * dance with slightly different defaults — producing lifecycle bugs on
+ * Windows (children in the parent's libuv kill-on-close job → die on
+ * restart) and ~200 LOC of near-duplicated boilerplate. This module
+ * consolidates them into three primitives:
+ *
+ *   • spawnDetached    — spawn with libuv-correct defaults
+ *   • waitForNoCrash   — did the child survive a fixed window?
+ *   • waitForReady     — did the child pass a positive probe?
+ *
+ * Key invariants (see change: consolidate-windows-spawn-and-platform-handlers):
+ *
+ *   1. `detached: true` on every platform. On Windows, libuv only excludes
+ *      a child from the parent's global Job Object (which has
+ *      JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE) when `detached: true` — that is
+ *      the PGID-equivalent mechanism, and it is the correct default for
+ *      every detached-child we spawn.
+ *   2. `shell: false` always. `.cmd` shims must be pre-resolved to
+ *      `node.exe + cli.js` by the caller (via ToolResolver.resolvePi /
+ *      resolveTsx etc.). `shell: true + detached + windowsHide + .cmd`
+ *      triggers Node issue #21825 (flashing console window).
+ *   3. `stdio[0] = "ignore"` always. A parent-owned pipe breaks when the
+ *      parent dies (EPIPE on first write); file fds survive.
+ *   4. `windowsHide: true` always (defence in depth alongside detached).
+ *
+ * All OS-dependent helpers accept an optional trailing
+ * `platform: NodeJS.Platform` parameter so tests can exercise both branches
+ * without mutating `process.platform`. See AGENTS.md invariant.
+ */
+import type { ChildProcess, SpawnOptions } from "node:child_process";
+import { spawn as safeSpawn } from "./exec.js";
+
+// ── spawnDetached ───────────────────────────────────────────────────────────
+
+export interface SpawnDetachedOptions {
+  /** Absolute path to the binary. MUST be pre-resolved — no `.cmd` shims. */
+  cmd: string;
+  /** Argv tokens. Passed verbatim to `spawn()`; no shell interpretation. */
+  args: string[];
+  /** Working directory for the child. */
+  cwd?: string;
+  /** Environment for the child. Defaults to `process.env` via Node. */
+  env?: NodeJS.ProcessEnv;
+  /**
+   * Optional file descriptor for stderr. When omitted, stderr is "ignore".
+   * Caller is responsible for `fs.openSync(logPath, "a")` and closing the
+   * parent's copy after spawn (the child retains its dup via stdio
+   * inheritance). File fds survive parent death; pipes do not.
+   */
+  logFd?: number;
+  /**
+   * stdin mode. Default: "ignore" — child's stdin closes immediately.
+   *
+   * Use `"pipe"` when the child is a Node program whose RPC mode
+   * listens for stdin `end` events and shuts down on EOF (e.g.
+   * pi-coding-agent's `--mode rpc`). A parent-held pipe keeps the
+   * child's stdin open as long as the parent is alive. Note: when
+   * the parent process dies, Windows closes the pipe and the child
+   * gets EOF — i.e., stdio:"pipe" undoes the session-survives-
+   * server-restart invariant of `detached: true`. Callers must pick
+   * one property (durability vs RPC-mode keep-alive) consciously.
+   */
+  stdinMode?: "ignore" | "pipe";
+  /**
+   * Whether to detach the child from the parent's libuv Job Object
+   * (Windows) / process group (POSIX). Default: `true`.
+   *
+   * When `true` (default):
+   *   - Windows: child is excluded from the parent's Job Object, so
+   *     killing the parent does NOT kill the child. Downside: libuv
+   *     allocates a new console for the child unless all stdio slots
+   *     are "ignore" (see libuv `src/win/process.c` — `CREATE_NO_WINDOW`
+   *     is only set when no stdio slot has `UV_INHERIT_FD`). With a
+   *     parent-held stdin pipe or file-fd stdout/stderr, brief console
+   *     flashes occur despite `windowsHide: true` (which only applies
+   *     `SW_HIDE` — hides AFTER allocation).
+   *   - POSIX: child is placed in its own process group.
+   *
+   * When `false`:
+   *   - Windows: child stays in parent's Job Object. `CREATE_NO_WINDOW`
+   *     is irrelevant (no new console allocation). No flash regardless
+   *     of stdio shape. Child dies with parent (Job Object closure).
+   *   - POSIX: child inherits parent's process group. Child dies with
+   *     parent on SIGTERM to the group.
+   *
+   * Use `false` when the child's lifecycle is deliberately tied to the
+   * parent (e.g., pi-session spawn where RPC stdin-EOF already ties
+   * them). Use default (`true`) for everything that must outlive its
+   * parent (server auto-start, CLI daemon, Electron server launch).
+   *
+   * See change: prep-for-develop-merge (restores the behavior of
+   * commit d331850 that was silently overridden by 5ab7956's universal
+   * detached:true invariant).
+   */
+  detach?: boolean;
+  /**
+   * Override platform for testing. Does not affect spawn behaviour (Node's
+   * `spawn` is platform-aware internally) but is surfaced here so future
+   * platform-specific branches stay out of callers.
+   */
+  platform?: NodeJS.Platform;
+}
+
+export interface SpawnDetachedResult {
+  ok: boolean;
+  pid?: number;
+  process?: ChildProcess;
+  error?: string;
+}
+
+/**
+ * Spawn a detached child with libuv-correct defaults on every platform.
+ *
+ * Returns `{ ok: true, pid, process }` on success. Returns `{ ok: false,
+ * error }` when the child has no PID or fails synchronously. Async errors
+ * are surfaced via a short (200 ms) grace period: if `ok: false` is
+ * returned, either the child never started or it errored immediately.
+ */
+export async function spawnDetached(opts: SpawnDetachedOptions): Promise<SpawnDetachedResult> {
+  const stdioIn: "ignore" | "pipe" = opts.stdinMode ?? "ignore";
+  const stdio: ("ignore" | "pipe" | number)[] = [stdioIn, "ignore", opts.logFd ?? "ignore"];
+
+  let child: ChildProcess;
+  let spawnError: string | null = null;
+  try {
+    child = safeSpawn(opts.cmd, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      detached: opts.detach ?? true,
+      stdio,
+      shell: false,
+      windowsHide: true,
+    } as SpawnOptions);
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? String(err) };
+  }
+
+  child.on("error", (err: Error) => {
+    spawnError = err.message;
+  });
+
+  // unref() so Node's event loop doesn't keep the parent alive because of
+  // this child. Harmless when the child has its own stdio file fds.
+  try { child.unref(); } catch { /* ignore */ }
+
+  // Short grace window for synchronous / near-synchronous spawn errors
+  // (ENOENT is emitted via 'error' on nextTick, not thrown).
+  if (!child.pid) {
+    await delay(200);
+    return { ok: false, error: spawnError ?? "spawn failed: no PID" };
+  }
+
+  // If the child errored inside the grace window, surface it even though
+  // we have a PID (some failures emit both: PID assigned then ENOENT on
+  // the exec itself).
+  await delay(5);
+  if (spawnError) {
+    return { ok: false, error: spawnError, pid: child.pid, process: child };
+  }
+
+  return { ok: true, pid: child.pid, process: child };
+}
+
+// ── waitForNoCrash ─────────────────────────────────────────────────────────
+
+export interface WaitForNoCrashOptions {
+  /** The child returned by spawnDetached(). */
+  child: ChildProcess;
+  /** How long to wait before declaring "didn't crash" (ms). */
+  windowMs: number;
+  /**
+   * If > 0, capture up to N bytes from the child's stderr stream (if a
+   * pipe is attached — which requires stdio[2] to be "pipe" rather than
+   * a file fd). Only useful when the caller manually attached a pipe
+   * before calling this; `spawnDetached` does NOT use pipes by default.
+   */
+  captureStderrBytes?: number;
+}
+
+export interface WaitForNoCrashResult {
+  ok: boolean;
+  exitCode?: number | null;
+  stderrTail?: string;
+}
+
+/**
+ * Wait up to `windowMs` milliseconds; return ok:true if the child is
+ * still alive at the end, or ok:false if it exited within the window.
+ *
+ * The primary use case: pi spawn on Windows where we want to catch
+ * "pi crashed on startup due to missing module / config error" without
+ * blocking the response for the full startup handshake.
+ */
+export async function waitForNoCrash(opts: WaitForNoCrashOptions): Promise<WaitForNoCrashResult> {
+  const { child, windowMs, captureStderrBytes } = opts;
+
+  let stderrBuf = "";
+  const cap = captureStderrBytes ?? 0;
+  const onStderr = cap > 0 && child.stderr
+    ? (chunk: Buffer) => {
+        stderrBuf += chunk.toString();
+        if (stderrBuf.length > cap) stderrBuf = stderrBuf.slice(-cap);
+      }
+    : null;
+  if (onStderr) child.stderr!.on("data", onStderr);
+
+  const exitCode = await Promise.race([
+    new Promise<number | null>((resolve) => child.once("exit", resolve)),
+    delay(windowMs).then(() => undefined),
+  ]);
+
+  if (onStderr) child.stderr!.off("data", onStderr);
+
+  if (exitCode === undefined) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    exitCode,
+    stderrTail: stderrBuf ? stderrBuf.trim() : undefined,
+  };
+}
+
+// ── waitForReady ───────────────────────────────────────────────────────────
+
+export interface WaitForReadyOptions {
+  /** Called repeatedly until it resolves true, or deadline elapses. */
+  probe: () => Promise<boolean>;
+  /**
+   * Maximum total wait (ms). Omit (or pass `undefined`) to wait
+   * indefinitely — in that case the only way to end the wait early is
+   * the optional `child` crashing. Use the infinite form when the
+   * caller trusts child-exit detection to cover the failure path and
+   * doesn't want a false-positive timeout on slow-but-working starts
+   * (e.g., cold jiti compile on Windows).
+   */
+  deadlineMs?: number;
+  /** Poll interval (ms). Default 500. */
+  pollIntervalMs?: number;
+  /**
+   * Optional child for early failure detection. If provided, an `error`
+   * event or non-zero `exit` short-circuits the wait.
+   */
+  child?: ChildProcess;
+}
+
+export interface WaitForReadyResult {
+  ok: boolean;
+  error?: string;
+}
+
+/**
+ * Poll `probe()` until it resolves true, or return timeout / early-failure.
+ * When `deadlineMs` is undefined, polls indefinitely until the probe
+ * succeeds or the child crashes.
+ */
+export async function waitForReady(opts: WaitForReadyOptions): Promise<WaitForReadyResult> {
+  const { probe, deadlineMs, pollIntervalMs = 500, child } = opts;
+
+  let childError: string | null = null;
+  const onError = (err: Error) => { childError = err.message; };
+  const onExit = (code: number | null) => {
+    if (code !== 0 && code !== null) {
+      childError = `child exited with code ${code}`;
+    } else if (code === 0) {
+      // Exit 0 is fine for short-lived children (e.g., wt.exe). Don't
+      // treat it as an error — the probe decides readiness.
+    }
+  };
+  if (child) {
+    child.on("error", onError);
+    child.on("exit", onExit);
+  }
+
+  const deadline = deadlineMs === undefined ? Infinity : Date.now() + deadlineMs;
+  try {
+    while (Date.now() < deadline) {
+      if (childError) return { ok: false, error: childError };
+      try {
+        if (await probe()) return { ok: true };
+      } catch {
+        // Swallow probe errors — treat as "not ready yet".
+      }
+      await delay(pollIntervalMs);
+    }
+    if (childError) return { ok: false, error: childError };
+    return { ok: false, error: "timeout" };
+  } finally {
+    if (child) {
+      child.off("error", onError);
+      child.off("exit", onExit);
+    }
+  }
+}
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function delay(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}