@codexhost/cli-darwin-x64 0.16.1 → 0.17.0

package/app/plugins/grok/plugin.mjs

@@ -603,7 +603,7 @@ async function readGrokCredentials(environment) {
 }
 
 // dist/grok-adapter.js
-import path15 from "node:path";
+import path16 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -1371,10 +1371,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1783,11 +1783,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -1934,16 +1934,16 @@ function flattenError(error53, mapper = (issue2) => issue2.message) {
 }
 function formatError(error53, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error54, path16 = []) => {
+  const processError = (error54, path17 = []) => {
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1970,17 +1970,17 @@ function formatError(error53, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error53, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error54, path16 = []) => {
+  const processError = (error54, path17 = []) => {
     var _a3, _b;
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else {
-        const fullpath = [...path16, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2012,8 +2012,8 @@ function treeifyError(error53, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path16) {
+  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14705,13 +14705,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path16 = ref.slice(1).split("/").filter(Boolean);
-  if (path16.length === 0) {
+  const path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path16[0] === defsKey) {
-    const key = path16[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -16977,11 +16977,371 @@ function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
   return harnessCommandCatalogSchema.parse({ commands: [...builtIns.commands, ...dynamic] });
 }
 
+// ../../harness-adapter/dist/local-media-markdown.js
+import { existsSync, statSync } from "node:fs";
+import path7 from "node:path";
+import { fileURLToPath } from "node:url";
+var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".aac",
+  ".gif",
+  ".jpeg",
+  ".jpg",
+  ".m4a",
+  ".m4v",
+  ".mov",
+  ".mp3",
+  ".mp4",
+  ".ogg",
+  ".png",
+  ".svg",
+  ".wav",
+  ".webm",
+  ".webp"
+]);
+function rewriteLocalMediaMarkdown(text, roots, options = {}) {
+  return projectLocalMedia(text, roots, options.exists ?? mediaFileExists, options.holdIncomplete === true, options.relativeImagesOnly === true).text;
+}
+var LocalMediaMarkdownStream = class {
+  #roots;
+  #exists;
+  #relativeImagesOnly;
+  #native = "";
+  #text = "";
+  /** Native text length represented by `#text`; the rest is held. */
+  #consumed = 0;
+  #verbatim = false;
+  constructor(roots, exists = mediaFileExists, options = {}) {
+    this.#roots = [...roots];
+    this.#relativeImagesOnly = options.relativeImagesOnly === true;
+    const known = /* @__PURE__ */ new Map();
+    this.#exists = (absolutePath) => {
+      let found = known.get(absolutePath);
+      if (found === void 0) {
+        found = exists(absolutePath);
+        known.set(absolutePath, found);
+      }
+      return found;
+    };
+  }
+  /** Projected text published so far: every returned delta, concatenated. */
+  get text() {
+    return this.#text;
+  }
+  /** Add native text and return the projected text it makes publishable, possibly empty. */
+  append(text) {
+    this.#native += text;
+    return this.#advance(true);
+  }
+  /** Return the projected text still held at the end of the stream. */
+  flush() {
+    return this.#advance(false);
+  }
+  #advance(holdIncomplete) {
+    const next = this.#verbatim ? void 0 : projectLocalMedia(this.#native, this.#roots, this.#exists, holdIncomplete, this.#relativeImagesOnly);
+    let delta;
+    if (next?.text.startsWith(this.#text)) {
+      delta = next.text.slice(this.#text.length);
+      this.#consumed = next.consumed;
+    } else {
+      this.#verbatim = true;
+      delta = this.#native.slice(this.#consumed);
+      this.#consumed = this.#native.length;
+    }
+    this.#text += delta;
+    return delta;
+  }
+};
+function projectLocalMedia(text, roots, exists, holdIncomplete, relativeImagesOnly) {
+  let output = "";
+  let index = 0;
+  let fence = null;
+  while (index < text.length) {
+    if (fence) {
+      const close = closingFenceEnd(text, index, fence.marker, fence.length);
+      if (close === -1)
+        break;
+      output += text.slice(index, close);
+      index = close;
+      fence = null;
+      continue;
+    }
+    const next = earliestIndex([
+      text.indexOf("![", index),
+      text.indexOf("`", index),
+      indexOfLineStartTilde(text, index)
+    ]);
+    if (next === -1)
+      break;
+    output += text.slice(index, next);
+    index = next;
+    const marker = text[next];
+    let markerLength = 1;
+    if (marker === "`" || marker === "~") {
+      let runEnd = next;
+      while (text[runEnd] === marker)
+        runEnd += 1;
+      markerLength = runEnd - next;
+      if (runEnd === text.length && holdIncomplete) {
+        return { text: output, consumed: next };
+      }
+      if (runEnd - next >= 3) {
+        const kind = fenceLineKind(text, next);
+        if (kind === "opaque")
+          break;
+        if (kind === "flat") {
+          fence = { marker, length: runEnd - next };
+          output += text.slice(next, runEnd);
+          index = runEnd;
+          continue;
+        }
+      }
+      if (marker === "~") {
+        output += text.slice(next, runEnd);
+        index = runEnd;
+        continue;
+      }
+    }
+    if (text.startsWith("![", next)) {
+      const image = parseMarkdownImage(text, next);
+      if (image.kind === "text") {
+        output += text.slice(next, image.end);
+        index = image.end;
+        continue;
+      }
+      if (image.kind === "open") {
+        if (!holdIncomplete)
+          break;
+        return { text: output + text.slice(next, image.holdFrom), consumed: image.holdFrom };
+      }
+      const resolved2 = relativeImagesOnly && /^(?:[\\/]|[a-z][a-z\d+.-]*:)/i.test(image.destination.trim()) ? null : resolveLocalMediaPath(image.destination, roots, exists);
+      output += resolved2 === null ? text.slice(next, image.end) : text.slice(next, image.destinationStart) + markdownDestination(resolved2, image.bracketed) + text.slice(image.destinationEnd, image.end);
+      index = image.end;
+      continue;
+    }
+    const code = parseInlineCode(text, next, markerLength);
+    if (code.kind !== "code" || holdIncomplete && code.end === text.length) {
+      if (holdIncomplete && code.kind !== "text")
+        return { text: output, consumed: next };
+      output += text.slice(next, next + markerLength);
+      index = next + markerLength;
+      continue;
+    }
+    const resolved = relativeImagesOnly || markerLength !== 1 || /[\r\n]/u.test(code.content) ? null : resolveLocalMediaPath(code.content, roots, exists);
+    output += resolved === null ? text.slice(next, code.end) : mediaMarkdownImage(resolved);
+    index = code.end;
+  }
+  return { text: output + text.slice(index), consumed: text.length };
+}
+function fenceLineKind(text, index) {
+  const prefix = text.slice(text.lastIndexOf("\n", index - 1) + 1, index);
+  if (prefix === "")
+    return "flat";
+  let remaining = prefix.replace(/^[ \t]+/u, "");
+  while (remaining) {
+    const marker = /^(?:>|(?:[-+*]|\d{1,9}[.)])(?=[ \t]))[ \t]*/u.exec(remaining);
+    if (!marker)
+      return null;
+    remaining = remaining.slice(marker[0].length);
+  }
+  return "opaque";
+}
+function indexOfLineStartTilde(text, start) {
+  for (let tilde = text.indexOf("~", start); tilde !== -1; tilde = text.indexOf("~", tilde + 1)) {
+    if (fenceLineKind(text, tilde) !== null)
+      return tilde;
+  }
+  return -1;
+}
+function closingFenceEnd(text, start, marker, length) {
+  const closing = new RegExp(`^ {0,3}${marker === "`" ? "`" : "~"}{${length},}[ \\t]*\\r?$`, "u");
+  let lineStart = text.indexOf("\n", start);
+  while (lineStart !== -1) {
+    lineStart += 1;
+    const newline2 = text.indexOf("\n", lineStart);
+    const lineEnd = newline2 === -1 ? text.length : newline2;
+    if (closing.test(text.slice(lineStart, lineEnd)))
+      return lineEnd;
+    lineStart = newline2;
+  }
+  return -1;
+}
+function earliestIndex(candidates) {
+  let next = -1;
+  for (const candidate of candidates) {
+    if (candidate === -1)
+      continue;
+    if (next === -1 || candidate < next)
+      next = candidate;
+  }
+  return next;
+}
+function parseInlineCode(text, start, length) {
+  let index = start + length;
+  while (index < text.length) {
+    const tick = text.indexOf("`", index);
+    if (/\n[^\S\n]*\n/u.test(text.slice(index, tick < 0 ? text.length : tick))) {
+      return { kind: "text" };
+    }
+    if (tick === -1)
+      break;
+    let end = tick + 1;
+    while (text[end] === "`")
+      end += 1;
+    if (end - tick === length) {
+      return { kind: "code", content: text.slice(start + length, tick), end };
+    }
+    index = end;
+  }
+  return { kind: "open" };
+}
+function parseMarkdownImage(text, start) {
+  const openLabel = { kind: "open", holdFrom: start + 2 };
+  let index = start + 2;
+  while (index < text.length) {
+    const character = text[index];
+    if (character === "\n")
+      return { kind: "text", end: start + 1 };
+    if (character === "\\") {
+      index += 2;
+      continue;
+    }
+    if (character === "]")
+      break;
+    index += 1;
+  }
+  if (index + 1 >= text.length)
+    return openLabel;
+  if (text[index + 1] !== "(")
+    return { kind: "text", end: start + 1 };
+  const destinationStart = index + 2;
+  const open = { kind: "open", holdFrom: destinationStart };
+  const malformed = { kind: "text", end: destinationStart };
+  index = skipBlanks(text, destinationStart);
+  if (index >= text.length)
+    return open;
+  let destination;
+  let destinationEnd;
+  let bracketed = false;
+  if (text[index] === "<") {
+    bracketed = true;
+    let close = index + 1;
+    while (close < text.length && text[close] !== ">" && text[close] !== "\n")
+      close += 1;
+    if (close >= text.length)
+      return open;
+    if (text[close] === "\n")
+      return malformed;
+    destination = text.slice(index + 1, close);
+    destinationEnd = close + 1;
+    index = destinationEnd;
+  } else {
+    const begin = index;
+    while (index < text.length) {
+      const character = text[index];
+      if (character === "\n" || character === " " || character === "	" || character === ")")
+        break;
+      index += character === "\\" ? 2 : 1;
+    }
+    if (index >= text.length)
+      return open;
+    destination = unescapeMarkdown(text.slice(begin, index));
+    destinationEnd = index;
+  }
+  index = skipBlanks(text, index);
+  if (index >= text.length)
+    return open;
+  const opener = text[index];
+  if (opener === '"' || opener === "'" || opener === "(") {
+    const closer = opener === "(" ? ")" : opener;
+    index += 1;
+    while (index < text.length && text[index] !== closer && text[index] !== "\n")
+      index += 1;
+    if (index >= text.length)
+      return open;
+    if (text[index] === "\n")
+      return malformed;
+    index = skipBlanks(text, index + 1);
+    if (index >= text.length)
+      return open;
+  }
+  if (text[index] !== ")")
+    return malformed;
+  return {
+    kind: "image",
+    destination,
+    destinationStart,
+    destinationEnd,
+    end: index + 1,
+    bracketed
+  };
+}
+function skipBlanks(text, start) {
+  let index = start;
+  while (text[index] === " " || text[index] === "	")
+    index += 1;
+  return index;
+}
+function mediaMarkdownImage(absolutePath) {
+  const name = path7.basename(absolutePath).replaceAll("]", "\\]");
+  return `![${name}](${markdownDestination(absolutePath, false)})`;
+}
+function markdownDestination(absolutePath, bracketed) {
+  const encoded = absolutePath.replaceAll("%", "%2525");
+  const destination = /^[A-Za-z]:\\/.test(encoded) ? encoded.replaceAll("\\", "/") : encoded.replaceAll("\\", "\\\\");
+  return bracketed || /[\s()]/.test(destination) ? `<${destination}>` : destination;
+}
+function unescapeMarkdown(value) {
+  return value.replace(/\\([\\()])/g, "$1");
+}
+function resolveLocalMediaPath(raw, roots, exists = mediaFileExists) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0 || isRemoteMediaUrl(trimmed))
+    return null;
+  const stripped = stripFileUrl(trimmed);
+  if (stripped === null)
+    return null;
+  if (isAbsoluteMediaPath(stripped)) {
+    const absolute = path7.resolve(stripped);
+    return hasMediaExtension(absolute) && exists(absolute) ? absolute : null;
+  }
+  for (const root of roots) {
+    const absolute = path7.resolve(root, stripped);
+    if (hasMediaExtension(absolute) && exists(absolute))
+      return absolute;
+  }
+  return null;
+}
+function isRemoteMediaUrl(value) {
+  return /^(?:https?:|data:|app:|blob:)/i.test(value);
+}
+function stripFileUrl(value) {
+  if (!value.toLowerCase().startsWith("file:"))
+    return value;
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return null;
+  }
+}
+function isAbsoluteMediaPath(value) {
+  return path7.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
+}
+function hasMediaExtension(value) {
+  return MEDIA_EXTENSIONS.has(path7.extname(value).toLowerCase());
+}
+function mediaFileExists(absolutePath) {
+  try {
+    return existsSync(absolutePath) && statSync(absolutePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
 // dist/acp-transport.js
 import { spawn, spawnSync } from "node:child_process";
 import { readdir, readFile as readFile3 } from "node:fs/promises";
 import os5 from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -21169,8 +21529,8 @@ function parseGrokAvailableCommands(value) {
   });
 }
 function isGrokSkill(command) {
-  const path16 = command.meta?.path;
-  return typeof path16 === "string" && /(^|[\\/])SKILL\.md$/u.test(path16) || typeof command.meta?.qualifiedName === "string";
+  const path17 = command.meta?.path;
+  return typeof path17 === "string" && /(^|[\\/])SKILL\.md$/u.test(path17) || typeof command.meta?.qualifiedName === "string";
 }
 function grokLiveCommands(native) {
   return native.map((command) => ({
@@ -21181,7 +21541,7 @@ function grokLiveCommands(native) {
 }
 
 // dist/command.js
-import path7 from "node:path";
+import path8 from "node:path";
 var GrokExecutableError = class extends Error {
   code = "GROK_NOT_FOUND";
 };
@@ -21210,7 +21570,7 @@ function resolveGrokExecutable(input = {}) {
   });
   if (!resolution)
     throw new GrokExecutableError("Grok CLI is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path7.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path8.resolve(resolution.executable);
 }
 function grokInvocation(command, platform = process.platform, modelId) {
   const arguments_ = ["agent", "--no-leader"];
@@ -21223,11 +21583,11 @@ function grokInvocation(command, platform = process.platform, modelId) {
 
 // dist/grok-fork.js
 import { isDeepStrictEqual } from "node:util";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // dist/grok-file-change.js
 import { Buffer as Buffer2 } from "node:buffer";
-import path8 from "node:path";
+import path9 from "node:path";
 
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -21329,16 +21689,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path16, added, removed, oldPosInc, options) {
-    const last = path16.lastComponent;
+  addToPath(path17, added, removed, oldPosInc, options) {
+    const last = path17.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path16.oldPos + oldPosInc,
+        oldPos: path17.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path16.oldPos + oldPosInc,
+        oldPos: path17.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -21651,13 +22011,13 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validAbsolutePath(value) {
-  return typeof value === "string" && path8.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
+  return typeof value === "string" && path9.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path8.resolve(cwd);
-  const resolvedPath = path8.resolve(nativePath);
-  const relative = path8.relative(resolvedCwd, resolvedPath);
-  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`);
+  const resolvedCwd = path9.resolve(cwd);
+  const resolvedPath = path9.resolve(nativePath);
+  const relative = path9.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path9.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -21718,299 +22078,19 @@ function projectGrokFileChanges(content, cwd, textLimit = DEFAULT_GROK_FILE_CHAN
 }
 
 // dist/local-media-markdown.js
-import { existsSync, statSync } from "node:fs";
 import os4 from "node:os";
-import path9 from "node:path";
-var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".aac",
-  ".gif",
-  ".jpeg",
-  ".jpg",
-  ".m4a",
-  ".m4v",
-  ".mov",
-  ".mp3",
-  ".mp4",
-  ".ogg",
-  ".png",
-  ".svg",
-  ".wav",
-  ".webm",
-  ".webp"
-]);
+import path10 from "node:path";
 function grokMediaResolveRoots(cwd, sessionDirectory) {
-  const roots = [path9.resolve(cwd)];
+  const roots = [path10.resolve(cwd)];
   if (sessionDirectory) {
-    const session = path9.resolve(sessionDirectory);
-    roots.push(session, path9.join(session, "videos"), path9.join(session, "images"));
+    const session = path10.resolve(sessionDirectory);
+    roots.push(session, path10.join(session, "videos"), path10.join(session, "images"));
   }
   const home = process.env.HOME ?? process.env.USERPROFILE ?? os4.homedir();
   if (home)
-    roots.push(path9.join(home, "Downloads"));
+    roots.push(path10.join(home, "Downloads"));
   return roots;
 }
-function rewriteLocalMediaMarkdown(text, roots, options = {}) {
-  const exists = options.exists ?? mediaFileExists;
-  const holdIncomplete = options.holdIncomplete === true;
-  let output = "";
-  let index = 0;
-  let fence = false;
-  while (index < text.length) {
-    if (fence) {
-      const fenceEnd = text.indexOf("```", index);
-      if (fenceEnd === -1) {
-        output += text.slice(index);
-        break;
-      }
-      output += text.slice(index, fenceEnd + 3);
-      index = fenceEnd + 3;
-      fence = false;
-      continue;
-    }
-    const fenceStart = text.indexOf("```", index);
-    const imageStart = text.indexOf("![", index);
-    const tickStart = indexOfInlineTick(text, index);
-    const next = earliestIndex([fenceStart, imageStart, tickStart]);
-    if (next === -1) {
-      output += text.slice(index);
-      break;
-    }
-    output += text.slice(index, next);
-    if (next === fenceStart) {
-      output += "```";
-      index = fenceStart + 3;
-      fence = true;
-      continue;
-    }
-    if (next === imageStart) {
-      const parsed = parseMarkdownImage(text, imageStart);
-      if (!parsed) {
-        output += "!";
-        index = imageStart + 1;
-        continue;
-      }
-      if (!parsed.closed) {
-        output += holdIncomplete ? text.slice(imageStart, parsed.destinationStart) : text.slice(imageStart);
-        break;
-      }
-      const resolved2 = resolveLocalMediaPath(parsed.destination, roots, exists);
-      output += text.slice(imageStart, parsed.destinationStart) + formatMarkdownDestination(resolved2 ?? parsed.destination, parsed.bracketed) + text.slice(parsed.destinationEnd, parsed.end);
-      index = parsed.end;
-      continue;
-    }
-    const inline = parseInlineCode(text, tickStart);
-    if (!inline.closed) {
-      if (!holdIncomplete)
-        output += text.slice(tickStart);
-      break;
-    }
-    const resolved = resolveLocalMediaPath(inline.content, roots, exists);
-    output += resolved ? mediaMarkdownImage(resolved) : text.slice(tickStart, inline.end);
-    index = inline.end;
-  }
-  return output;
-}
-function indexOfInlineTick(text, start) {
-  let index = start;
-  while (index < text.length) {
-    const tick = text.indexOf("`", index);
-    if (tick === -1)
-      return -1;
-    if (text.startsWith("```", tick)) {
-      index = tick + 3;
-      continue;
-    }
-    return tick;
-  }
-  return -1;
-}
-function earliestIndex(candidates) {
-  let next = -1;
-  for (const candidate of candidates) {
-    if (candidate === -1)
-      continue;
-    if (next === -1 || candidate < next)
-      next = candidate;
-  }
-  return next;
-}
-function parseInlineCode(text, start) {
-  let index = start + 1;
-  while (index < text.length) {
-    const character = text[index];
-    if (character === "\n")
-      return { closed: false, content: text.slice(start + 1, index), end: index };
-    if (character === "`")
-      return { closed: true, content: text.slice(start + 1, index), end: index + 1 };
-    index += 1;
-  }
-  return { closed: false, content: text.slice(start + 1), end: text.length };
-}
-function mediaMarkdownImage(absolutePath) {
-  const name = path9.basename(absolutePath).replaceAll("]", "\\]");
-  return `![${name}](${formatMarkdownDestination(absolutePath, false)})`;
-}
-function parseMarkdownImage(text, start) {
-  if (text.slice(start, start + 2) !== "![")
-    return null;
-  let index = start + 2;
-  while (index < text.length) {
-    const character = text[index];
-    if (character === "\n")
-      return null;
-    if (character === "\\" && index + 1 < text.length) {
-      index += 2;
-      continue;
-    }
-    if (character === "]")
-      break;
-    index += 1;
-  }
-  if (text[index] !== "]" || text[index + 1] !== "(")
-    return null;
-  const destinationStart = index + 2;
-  index = destinationStart;
-  while (text[index] === " " || text[index] === "	")
-    index += 1;
-  if (index >= text.length) {
-    return {
-      closed: false,
-      destination: "",
-      destinationStart,
-      destinationEnd: index,
-      end: text.length,
-      bracketed: false
-    };
-  }
-  let destination;
-  let destinationEnd;
-  let bracketed = false;
-  if (text[index] === "<") {
-    bracketed = true;
-    const close = text.indexOf(">", index + 1);
-    if (close === -1 || text.slice(index, close).includes("\n")) {
-      return {
-        closed: false,
-        destination: text.slice(index + 1),
-        destinationStart,
-        destinationEnd: text.length,
-        end: text.length,
-        bracketed: true
-      };
-    }
-    destination = text.slice(index + 1, close);
-    destinationEnd = close + 1;
-    index = destinationEnd;
-  } else {
-    const begin = index;
-    while (index < text.length) {
-      const character = text[index];
-      if (character === "\n" || character === " " || character === "	" || character === ")")
-        break;
-      if (character === "\\" && index + 1 < text.length) {
-        index += 2;
-        continue;
-      }
-      index += 1;
-    }
-    destination = unescapeMarkdown(text.slice(begin, index));
-    destinationEnd = index;
-  }
-  while (text[index] === " " || text[index] === "	")
-    index += 1;
-  if (text[index] === '"' || text[index] === "'" || text[index] === "(") {
-    const closer = text[index] === "(" ? ")" : text[index];
-    index += 1;
-    while (index < text.length && text[index] !== closer && text[index] !== "\n")
-      index += 1;
-    if (text[index] !== closer) {
-      return {
-        closed: false,
-        destination,
-        destinationStart,
-        destinationEnd,
-        end: text.length,
-        bracketed
-      };
-    }
-    index += 1;
-    while (text[index] === " " || text[index] === "	")
-      index += 1;
-  }
-  if (text[index] !== ")") {
-    return {
-      closed: false,
-      destination,
-      destinationStart,
-      destinationEnd,
-      end: text.length,
-      bracketed
-    };
-  }
-  return {
-    closed: true,
-    destination,
-    destinationStart,
-    destinationEnd,
-    end: index + 1,
-    bracketed
-  };
-}
-function formatMarkdownDestination(destination, bracketed) {
-  if (bracketed || /[\s()]/.test(destination))
-    return `<${destination}>`;
-  return destination.replaceAll(" ", "%20");
-}
-function unescapeMarkdown(value) {
-  return value.replace(/\\([\\()])/g, "$1");
-}
-function resolveLocalMediaPath(raw, roots, exists = mediaFileExists) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0 || isRemoteMediaUrl(trimmed))
-    return null;
-  const stripped = stripFileUrl(trimmed);
-  if (!hasMediaExtension(stripped))
-    return null;
-  if (isAbsoluteMediaPath(stripped)) {
-    const absolute = path9.resolve(stripped);
-    return exists(absolute) ? absolute : null;
-  }
-  for (const root of roots) {
-    const absolute = path9.resolve(root, stripped);
-    if (exists(absolute))
-      return absolute;
-  }
-  return null;
-}
-function isRemoteMediaUrl(value) {
-  return /^(?:https?:|data:|app:|blob:)/i.test(value);
-}
-function stripFileUrl(value) {
-  if (!value.toLowerCase().startsWith("file:"))
-    return value;
-  try {
-    const url2 = new URL(value);
-    if (url2.protocol !== "file:")
-      return value;
-    return decodeURIComponent(url2.pathname);
-  } catch {
-    return value.replace(/^file:\/\//i, "");
-  }
-}
-function isAbsoluteMediaPath(value) {
-  return path9.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
-}
-function hasMediaExtension(value) {
-  const pathname = value.split(/[?#]/, 1)[0] ?? value;
-  return MEDIA_EXTENSIONS.has(path9.extname(pathname).toLowerCase());
-}
-function mediaFileExists(absolutePath) {
-  try {
-    return existsSync(absolutePath) && statSync(absolutePath).isFile();
-  } catch {
-    return false;
-  }
-}
 
 // dist/grok-tool-output.js
 var DEFAULT_GROK_TOOL_OUTPUT_LIMIT = 64e3;
@@ -23011,11 +23091,11 @@ function parseGrokForkResponse(value) {
 }
 function projectRelativePath(value, cwds) {
   const normalized = value.replaceAll("\\", "/");
-  if (!path10.isAbsolute(value))
+  if (!path11.isAbsolute(value))
     return normalized;
   for (const cwd of cwds) {
-    const relative = path10.relative(path10.resolve(cwd), path10.resolve(value));
-    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path10.sep}`)) {
+    const relative = path11.relative(path11.resolve(cwd), path11.resolve(value));
+    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path11.sep}`)) {
       return relative.replaceAll("\\", "/");
     }
   }
@@ -23080,8 +23160,8 @@ async function forkGrokSession(input) {
       error: error51("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path10.resolve(located.cwd);
-  const targetCwd = path10.resolve(input.cwd);
+  const sourceCwd = path11.resolve(located.cwd);
+  const targetCwd = path11.resolve(input.cwd);
   const source = await readSnapshot({ ...input, cwd: sourceCwd }, sourceRef.data.nativeSessionId);
   if (!source.ok)
     return source;
@@ -23264,7 +23344,7 @@ function parseGrokCompactResult(value, cancelled = false) {
 }
 
 // dist/grok-rewind.js
-import path11 from "node:path";
+import path12 from "node:path";
 var GROK_REWIND_EXECUTE_METHOD = "_x.ai/rewind/execute";
 function error52(code, message, retryable = false) {
   return { code, message, retryable };
@@ -23337,8 +23417,8 @@ async function rewindGrokLastTurn(input) {
       error: error52("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path11.resolve(located.cwd);
-  const targetCwd = path11.resolve(input.cwd);
+  const sourceCwd = path12.resolve(located.cwd);
+  const targetCwd = path12.resolve(input.cwd);
   if (sourceCwd !== targetCwd) {
     return {
       ok: false,
@@ -23717,8 +23797,14 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord13(error53) || error53.code !== "ESRCH")
-      throw error53;
+    if (!isRecord13(error53) || error53.code === "ESRCH")
+      return;
+    try {
+      child.kill(signal);
+    } catch (fallback) {
+      if (!isRecord13(fallback) || fallback.code !== "ESRCH")
+        throw fallback;
+    }
   }
 }
 function transportEvent(update, metadata) {
@@ -23812,13 +23898,13 @@ function transportEvent(update, metadata) {
 function grokHomeDir(options) {
   const environment = { ...process.env, ...options.environment };
   const home = environment.HOME ?? environment.USERPROFILE ?? os5.homedir();
-  return environment.GROK_HOME ?? path12.join(home, ".grok");
+  return environment.GROK_HOME ?? path13.join(home, ".grok");
 }
 function grokNativeSessionDirectory(options, sessionId) {
-  return path12.join(grokHomeDir(options), "sessions", encodeURIComponent(path12.resolve(options.cwd)), sessionId);
+  return path13.join(grokHomeDir(options), "sessions", encodeURIComponent(path13.resolve(options.cwd)), sessionId);
 }
 function nativeSessionFile(options, sessionId, fileName) {
-  return path12.join(grokNativeSessionDirectory(options, sessionId), fileName);
+  return path13.join(grokNativeSessionDirectory(options, sessionId), fileName);
 }
 function nativeHistoryPath(options, sessionId) {
   return nativeSessionFile(options, sessionId, "updates.jsonl");
@@ -23838,7 +23924,7 @@ async function locateGrokNativeSession(options, sessionId) {
     return null;
   let entries;
   try {
-    entries = await readdir(path12.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
+    entries = await readdir(path13.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
   } catch (error53) {
     if (isMissingFile(error53))
       return null;
@@ -23852,7 +23938,7 @@ async function locateGrokNativeSession(options, sessionId) {
       continue;
     let summaryRaw;
     try {
-      summaryRaw = await readFile3(path12.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
+      summaryRaw = await readFile3(path13.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
       if (isMissingFile(error53) || isRecord13(error53) && error53.code === "ENOTDIR")
         continue;
@@ -23869,8 +23955,8 @@ async function locateGrokNativeSession(options, sessionId) {
     if (!isRecord13(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord13(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path12.resolve(info.cwd) : path12.resolve(decodeURIComponent(entry.name));
-    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path12.resolve(parsed.source_workspace_dir) : void 0;
+    const cwd = isRecord13(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path13.resolve(info.cwd) : path13.resolve(decodeURIComponent(entry.name));
+    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path13.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
       ...sourceWorkspaceDir ? { sourceWorkspaceDir } : {}
@@ -23880,7 +23966,7 @@ async function locateGrokNativeSession(options, sessionId) {
 }
 async function readGrokNativeHistory(options, sessionId) {
   try {
-    return parseNativeHistory(await readFile3(nativeHistoryPath({ ...options, cwd: path12.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
+    return parseNativeHistory(await readFile3(nativeHistoryPath({ ...options, cwd: path13.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
   } catch (error53) {
     if (isMissingFile(error53))
       return [];
@@ -24379,7 +24465,7 @@ var GrokAcpTransport = class {
 // dist/session-import.js
 import { createReadStream as createReadStream2 } from "node:fs";
 import { opendir as opendir2, readFile as readFile4, stat } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // ../../harness-adapter/dist/session-import.js
@@ -24600,7 +24686,7 @@ var GrokSessionImport = class {
     const active = /* @__PURE__ */ new Set();
     let entries;
     try {
-      entries = await readJson(path13.join(this.#home(), "active_sessions.json"), signal);
+      entries = await readJson(path14.join(this.#home(), "active_sessions.json"), signal);
     } catch (error53) {
       signal.throwIfAborted();
       if (isStorageAccessError(error53))
@@ -24617,7 +24703,7 @@ var GrokSessionImport = class {
   }
   /** Session ID to every directory claiming it. Enumerated links are not followed. */
   async #sessionDirectories(signal) {
-    const root = path13.join(this.#home(), "sessions");
+    const root = path14.join(this.#home(), "sessions");
     const found = /* @__PURE__ */ new Map();
     const info = await optionalLstat(root);
     if (!info)
@@ -24628,7 +24714,7 @@ var GrokSessionImport = class {
       signal.throwIfAborted();
       if (!workspace.isDirectory())
         continue;
-      const workspaceDirectory = path13.join(root, workspace.name);
+      const workspaceDirectory = path14.join(root, workspace.name);
       const sessions = await opendir2(workspaceDirectory).catch((error53) => {
         if (isMissingFileError(error53))
           return null;
@@ -24641,7 +24727,7 @@ var GrokSessionImport = class {
         if (!session.isDirectory())
           continue;
         const directories = found.get(session.name) ?? [];
-        directories.push(path13.join(workspaceDirectory, session.name));
+        directories.push(path14.join(workspaceDirectory, session.name));
         found.set(session.name, directories);
       }
     }
@@ -24649,10 +24735,10 @@ var GrokSessionImport = class {
   }
   async #candidate(sessionDirectory, active, signal) {
     signal.throwIfAborted();
-    const nativeSessionId = path13.basename(sessionDirectory);
+    const nativeSessionId = path14.basename(sessionDirectory);
     const files = [
-      path13.join(sessionDirectory, "summary.json"),
-      path13.join(sessionDirectory, "updates.jsonl")
+      path14.join(sessionDirectory, "summary.json"),
+      path14.join(sessionDirectory, "updates.jsonl")
     ];
     return readStableFiles(files, async ([summaryInfo, updates]) => {
       if (!summaryInfo?.isFile() || !updates?.isFile() || summaryInfo.size > MAX_METADATA_BYTES)
@@ -24664,10 +24750,10 @@ var GrokSessionImport = class {
         if (typeof summary.session_kind === "string" && SUBAGENT_SESSION_KINDS.has(summary.session_kind))
           return null;
         const nativeCwd = summary.info.cwd;
-        if (typeof nativeCwd !== "string" || !path13.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
+        if (typeof nativeCwd !== "string" || !path14.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
           return null;
-        const cwd = path13.resolve(nativeCwd);
-        if (encodeURIComponent(cwd) !== path13.basename(path13.dirname(sessionDirectory)))
+        const cwd = path14.resolve(nativeCwd);
+        if (encodeURIComponent(cwd) !== path14.basename(path14.dirname(sessionDirectory)))
           return null;
         if (!(await stat(cwd)).isDirectory())
           return null;
@@ -24989,9 +25075,17 @@ function stateForGrokModel(modelState, nativeState, model2 = modelState.currentM
 // dist/grok-credits.js
 import { readFile as readFile5 } from "node:fs/promises";
 import os6 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+var GROK_SETTINGS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/settings";
 var REQUEST_TIMEOUT_MS = 15e3;
+var PLAN_TIMEOUT_MS = 2e3;
+function parseGrokPlan(value) {
+  if (!isRecord16(value) || typeof value.subscription_tier_display !== "string")
+    return void 0;
+  const plan = value.subscription_tier_display.trim();
+  return plan && plan.length <= 128 && !/[\u0000-\u001f\u007f]/u.test(plan) ? plan : void 0;
+}
 function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -25009,7 +25103,7 @@ function nonNegativeCentValue(value) {
   return amount;
 }
 function grokHome2(environment) {
-  return environment.GROK_HOME ?? path14.join(environment.HOME ?? environment.USERPROFILE ?? os6.homedir(), ".grok");
+  return environment.GROK_HOME ?? path15.join(environment.HOME ?? environment.USERPROFILE ?? os6.homedir(), ".grok");
 }
 function periodTypeFrom(value) {
   if (typeof value !== "string")
@@ -25101,26 +25195,30 @@ async function fetchGrokAccount(input = {}) {
     if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((value) => value?.trim()))
       return null;
     const now = input.now ?? /* @__PURE__ */ new Date();
-    const authPath = path14.join(grokHome2(environment), "auth.json");
+    const authPath = path15.join(grokHome2(environment), "auth.json");
     const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile5(authPath, "utf8");
     const token = selectAccessToken(JSON.parse(raw), now);
     if (!token)
       return null;
     const fetchImpl = input.fetch ?? fetch;
-    const response = await fetchImpl(GROK_CREDITS_ENDPOINT, {
+    const request = (url2, timeoutMs) => fetchImpl(url2, {
       method: "GET",
       headers: {
         Authorization: `Bearer ${token.key}`,
         "x-xai-token-auth": "xai-grok-cli",
         Accept: "application/json"
       },
-      signal: input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      signal: input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs)
     });
+    const credits = request(GROK_CREDITS_ENDPOINT, REQUEST_TIMEOUT_MS);
+    const plan = input.includePlan === false ? Promise.resolve(void 0) : request(GROK_SETTINGS_ENDPOINT, input.planTimeoutMs ?? PLAN_TIMEOUT_MS).then(async (response2) => response2.ok ? parseGrokPlan(await response2.json()) : void 0).catch(() => void 0);
+    const response = await credits;
     if (!response.ok)
       return null;
     const snapshot = parseGrokCreditsResponse(await response.json(), now.toISOString());
     if (!snapshot)
       return null;
+    const planName = await plan;
     return {
       credits: {
         usedPercent: snapshot.usedPercent,
@@ -25129,14 +25227,15 @@ async function fetchGrokAccount(input = {}) {
         ...snapshot.productUsage ? { productUsage: [...snapshot.productUsage] } : {}
       },
       ...token.email ? { email: token.email } : {},
-      ...token.label ? { label: token.label } : {}
+      ...token.label ? { label: token.label } : {},
+      ...planName ? { plan: planName } : {}
     };
   } catch {
     return null;
   }
 }
 async function fetchGrokCredits(input = {}) {
-  const account = await fetchGrokAccount(input);
+  const account = await fetchGrokAccount({ ...input, includePlan: false });
   if (!account?.credits)
     return null;
   const { credits } = account;
@@ -25645,8 +25744,7 @@ var GrokHarnessSession = class {
       usage: new GrokTurnUsage(this.#usage, this.#snapshot.turns.length === 0),
       agent: null,
       agentMessageId: null,
-      rawAgentText: "",
-      projectedAgentText: "",
+      agentMedia: null,
       reasoning: null,
       reasoningMessageId: null,
       compactionItem: null,
@@ -25735,8 +25833,7 @@ var GrokHarnessSession = class {
       questions: new GrokQuestions(command.turnId, this.#randomUUID, (output) => this.#channel.emit(output)),
       agent: null,
       agentMessageId: null,
-      rawAgentText: "",
-      projectedAgentText: "",
+      agentMedia: null,
       reasoning: null,
       reasoningMessageId: null,
       compactionItem: null,
@@ -26089,19 +26186,16 @@ var GrokHarnessSession = class {
         itemId: hostItemIdSchema.parse(this.#randomUUID()),
         text: ""
       };
-      active.rawAgentText = "";
-      active.projectedAgentText = "";
+      active.agentMedia = new LocalMediaMarkdownStream(this.#mediaRoots);
       this.#event({ type: "item.started", turnId: active.command.turnId, item: active.agent });
     }
-    active.rawAgentText += text;
-    const projected = rewriteLocalMediaMarkdown(active.rawAgentText, this.#mediaRoots, {
-      holdIncomplete: true
-    });
-    const delta = projected.startsWith(active.projectedAgentText) ? projected.slice(active.projectedAgentText.length) : text;
-    if (delta.length === 0)
+    const delta = active.agentMedia?.append(text) ?? "";
+    this.#publishAgent(active, delta);
+  }
+  #publishAgent(active, delta) {
+    if (!active.agent || !active.agentMedia || !delta)
       return;
-    active.projectedAgentText += delta;
-    active.agent = { ...active.agent, text: active.projectedAgentText };
+    active.agent = { ...active.agent, text: active.agentMedia.text };
     this.#event({
       type: "item.updated",
       turnId: active.command.turnId,
@@ -26322,25 +26416,12 @@ var GrokHarnessSession = class {
   }
   #completeAgent(active, outcome) {
     const item = active.agent;
-    if (item && active.rawAgentText.length > 0) {
-      const flushed = rewriteLocalMediaMarkdown(active.rawAgentText, this.#mediaRoots);
-      const delta = flushed.startsWith(item.text) ? flushed.slice(item.text.length) : "";
-      if (delta.length > 0) {
-        active.projectedAgentText = flushed;
-        active.agent = { ...item, text: flushed };
-        this.#event({
-          type: "item.updated",
-          turnId: active.command.turnId,
-          itemId: item.itemId,
-          update: { type: "text.append", text: delta }
-        });
-      }
-    }
+    if (item && active.agentMedia)
+      this.#publishAgent(active, active.agentMedia.flush());
     const completed = active.agent ?? item;
     active.agent = null;
     active.agentMessageId = null;
-    active.rawAgentText = "";
-    active.projectedAgentText = "";
+    active.agentMedia = null;
     if (completed)
       this.#completeItem(active, completed, outcome);
   }
@@ -26590,7 +26671,7 @@ var GrokAdapter = class {
   async inspect(input = {}) {
     if (this.#closePromise)
       return { status: "unavailable", error: invalidState("Grok Adapter is closed") };
-    const cwd = path15.resolve(input.cwd ?? process.cwd());
+    const cwd = path16.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -26652,7 +26733,7 @@ var GrokAdapter = class {
         }
       };
     }
-    const cwd = path15.resolve(input.cwd);
+    const cwd = path16.resolve(input.cwd);
     const parsedRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (parsedRef && (!parsedRef.success || parsedRef.data.harnessId !== this.harnessId)) {
       return {