@visual-z/xeno 0.8.4 → 0.9.0

package/src/runtime/retry.ts

@@ -1,447 +0,0 @@
-/**
- * When a failed request is worth making again.
- *
- * Split into a pure decision and a thin loop, because the decision is where
- * all the rules are and none of them need a clock. What to retry, how long to
- * wait, when to stop -- all of it is testable in microseconds, which is the
- * difference between pinning the policy and hoping it works.
- *
- * The rules mirror the OpenAI and Anthropic SDKs' own, by way of pi, which
- * notes the same lineage. That is deliberate: the failure modes were found by
- * people running far more traffic than this, and inventing a different policy
- * would mean rediscovering them.
- *
- * Retry lives at the request, inside the adapter, and not in the loop. A retry
- * in the loop would straddle a log append -- the failed attempt would either
- * be recorded, polluting an append-only history with something that did not
- * happen, or dropped, leaving usage that does not add up. The loop should see
- * a result that has already been retried, or a definite failure.
- */
-
-import { isContextOverflow } from "../core/overflow.ts";
-import type { FailureCause } from "../core/events.ts";
-
-/**
- * Words providers and relays use for "try again": timeouts, unavailable or
- * overloaded upstreams, rate limits, dropped connections, 5xx codes. A
- * pattern, not a list of known providers, because relays forward their
- * upstream's wording.
- */
-const TRANSIENT_STREAM = /time[d ]?out|timed out|unavailable|overload|rate.?limit|too many requests|connection (?:reset|closed|refused)|ECONNRESET|temporar|\b5\d\d\b|internal.?server|bad gateway|service.?unavailable/i;
-
-/**
- * Connection failures, named by code rather than guessed from prose.
- *
- * Bun's fetch reports every one of these as a plain Error carrying `code`
- * (measured on 1.3.10: a reset before the headers, one halfway through the
- * body and a refused port all arrive that way), never as the TypeError the
- * WHATWG spec describes -- so the TypeError rule below never sees them. SDKs
- * wrap the same error as `cause`. The two sets follow Claude Code's split:
- * "stale" is a connection that existed and died, "network_down" is one that
- * could never be opened. Both are worth another attempt.
- */
-const STALE_CONNECTION_CODES = new Set([
-  "ECONNRESET", "EPIPE", "ECONNABORTED", "ETIMEDOUT", "ConnectionClosed",
-  "ERR_SOCKET_CLOSED", "UND_ERR_SOCKET", "UND_ERR_CLOSED",
-]);
-const NETWORK_DOWN_CODES = new Set([
-  "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH", "ENETDOWN", "EHOSTUNREACH", "EHOSTDOWN",
-  "EAI_AGAIN", "ConnectionRefused", "FailedToOpenSocket", "ERR_PROXY_TUNNEL",
-]);
-
-/**
- * The same failures in the words Bun, Node and undici use, for adapters that
- * forward only the message (pi-ai turns a dropped stream into errorMessage
- * and the code is gone by the time it reaches here).
- */
-const STALE_CONNECTION_TEXT = /socket connection was closed unexpectedly|socket hang up|other side closed|\bECONNRESET\b|\bEPIPE\b/i;
-const NETWORK_DOWN_TEXT = /unable to connect\. is the computer able to access the url|\bECONNREFUSED\b|\bENOTFOUND\b|\bEAI_AGAIN\b/i;
-
-export type ConnectionFailure = "stale" | "network_down";
-
-function codeOf(value: unknown): string | undefined {
-  if (typeof value !== "object" || value === null) return undefined;
-  const code = (value as { code?: unknown }).code;
-  return typeof code === "string" ? code : undefined;
-}
-
-/** TLS verification codes from Node, Bun and undici; Claude Code also leaves these unretried. */
-const CERTIFICATE_CODE = /^(?:CERT_|UNABLE_TO_VERIFY_|UNABLE_TO_GET_ISSUER_CERT)|^(?:SELF_SIGNED_CERT_IN_CHAIN|DEPTH_ZERO_SELF_SIGNED_CERT|ERR_TLS_CERT_ALTNAME_INVALID)$/;
-
-function certificateFailure(error: unknown): boolean {
-  const cause = typeof error === "object" && error !== null ? (error as { cause?: unknown }).cause : undefined;
-  return [codeOf(error), codeOf(cause)].some((code) => code !== undefined && CERTIFICATE_CODE.test(code));
-}
-
-/**
- * A few words for the retry line: what went wrong, not the full message.
- * Bun's text runs to a sentence about `verbose: true`, which the status line
- * cannot hold; the full message still reaches the user if the retries run out.
- */
-export function retryLabel(error: unknown): string {
-  const status = statusOf(error);
-  if (status === 429) return "rate limited";
-  if (status !== undefined) return `HTTP ${status}`;
-  const connection = connectionFailure(error);
-  if (connection === "stale") return "connection lost";
-  if (connection === "network_down") return "network unreachable";
-  if (isStreamIdle(error)) return "stream stalled";
-  if (isMalformedResponse(error)) return "malformed response";
-  if (isStreamFailure(error)) return "stream error";
-  return error instanceof TypeError ? "connection failed" : "request failed";
-}
-
-/**
- * What a failed request leaves in the log. `retries` is present only for a
- * provider failure: it is what the adapter reported, not what the policy allowed.
- * A harness error contributes its class name alone -- the message may quote a
- * path, a command or a credential, and the class is chosen by code.
- */
-export function failureCause(error: unknown, provider: { retries: number } | undefined): FailureCause {
-  if (provider) {
-    const status = statusOf(error);
-    return { source: "provider", label: retryLabel(error), ...(status === undefined ? {} : { status }), retries: provider.retries };
-  }
-  const name = error instanceof Error ? error.name : "";
-  return { source: "harness", label: /^[A-Za-z][\w.]{0,63}$/.test(name) ? name : "Error" };
-}
-
-/** The words a person reads: "HTTP 503 after 3 retries", "connection lost". */
-export function describeFailure(cause: FailureCause): string {
-  if (cause.source === "harness") return `xeno internal error (${cause.label})`;
-  const retries = cause.retries ?? 0;
-  return retries === 0 ? cause.label : `${cause.label} after ${retries} ${retries === 1 ? "retry" : "retries"}`;
-}
-
-/** Whether this error is a connection that died or one that never opened. */
-export function connectionFailure(error: unknown): ConnectionFailure | undefined {
-  const cause = typeof error === "object" && error !== null ? (error as { cause?: unknown }).cause : undefined;
-  for (const code of [codeOf(error), codeOf(cause)]) {
-    if (code === undefined) continue;
-    if (STALE_CONNECTION_CODES.has(code)) return "stale";
-    if (NETWORK_DOWN_CODES.has(code)) return "network_down";
-  }
-  for (const value of [error, cause]) {
-    if (!(value instanceof Error)) continue;
-    if (STALE_CONNECTION_TEXT.test(value.message)) return "stale";
-    if (NETWORK_DOWN_TEXT.test(value.message)) return "network_down";
-  }
-  return undefined;
-}
-
-/** Structural, so retry.ts need not import an adapter to recognise its error. */
-function isStreamFailure(error: unknown): error is Error & { code?: string } {
-  return error instanceof Error && error.name === "StreamError";
-}
-
-/** stream-idle.ts StreamIdleError: an attempt abandoned after the stream went silent. */
-function isStreamIdle(error: unknown): boolean {
-  return error instanceof Error && error.name === "StreamIdleError";
-}
-
-/**
- * Retries a silent stream gets. Fewer than the general budget because each
- * one has already cost the idle limit (300s): ten would be fifty minutes.
- * Codex CLI allows 5 stream retries and Claude Code 1; 2 is an assumption.
- */
-const STREAM_IDLE_RETRIES = 2;
-
-/** provider.ts MalformedResponseError: a self-contradictory 200, structural for the same reason. */
-function isMalformedResponse(error: unknown): boolean {
-  return error instanceof Error && error.name === "MalformedResponseError";
-}
-
-export interface RetryPolicy {
-  /**
-   * Attempts after the first. Ten, doubling to a 32s ceiling, is Claude
-   * Code's budget: about 160s of backoff before failing. Four (~15s) gave up
-   * inside an ordinary network blip or proxy reconnect (Horizyn 2026-10-12,
-   * feat-retry-budget-and-progress). The wait is visible -- a countdown and
-   * attempt n/max -- and Escape ends it, so a longer budget is not a silent
-   * hang. The ceiling is an assumption carried over, not measured here.
-   */
-  maxRetries: number;
-  /**
-   * Longest server-requested delay worth honouring. Beyond this, fail. An
-   * agent that silently sleeps for twenty minutes cannot be told apart from
-   * one that has died, and is harder to diagnose than an error.
-   */
-  maxRetryDelayMs: number;
-}
-
-export const DEFAULT_RETRY: RetryPolicy = { maxRetries: 10, maxRetryDelayMs: 60_000 };
-
-/** Longest backoff between attempts when the server names no delay. */
-const BACKOFF_CEILING_MS = 32_000;
-
-/**
- * 0.5s doubling to the ceiling, then flat. `jitter` in [0, 1) only shortens
- * the wait, by at most a quarter (see retryDecision).
- */
-function backoffMs(attempt: number, jitter: number): number {
-  return Math.min(500 * 2 ** attempt, BACKOFF_CEILING_MS) * (1 - jitter * 0.25);
-}
-
-export type RetryDecision =
-  | { retry: true; delayMs: number }
-  | { retry: false; reason: string };
-
-/** What this module needs from an error: a status and headers, if it has them. */
-interface HasResponse {
-  status?: unknown;
-  headers?: unknown;
-}
-
-export function statusOf(error: unknown): number | undefined {
-  if (typeof error !== "object" || error === null) return undefined;
-  const status = (error as HasResponse).status;
-  return typeof status === "number" ? status : undefined;
-}
-
-function headersOf(error: unknown): Headers | undefined {
-  if (typeof error !== "object" || error === null) return undefined;
-  const headers = (error as HasResponse).headers;
-  return headers instanceof Headers ? headers : undefined;
-}
-
-/**
- * Whether this status is about timing rather than about the request.
- *
- * 400 and 401 are the two worth naming: a malformed request and a bad key are
- * deterministic, so retrying converts one clear failure into several slow ones
- * and delays the only message that would have helped.
- */
-function statusIsTransient(status: number): boolean {
-  return status === 408 || status === 409 || status === 429 || status >= 500;
-}
-
-function serverDelayMs(headers: Headers | undefined): number | undefined {
-  if (headers === undefined) return undefined;
-
-  // Milliseconds first: it is the more precise of the two, and a provider
-  // that sends both means the finer one.
-  const ms = headers.get("retry-after-ms");
-  if (ms !== null) {
-    const value = Number.parseFloat(ms);
-    if (!Number.isNaN(value)) return value;
-  }
-
-  const after = headers.get("retry-after");
-  if (after !== null) {
-    const seconds = Number.parseFloat(after);
-    if (!Number.isNaN(seconds)) return seconds * 1000;
-    // The header is also allowed to be an HTTP date.
-    const at = Date.parse(after);
-    if (!Number.isNaN(at)) return Math.max(0, at - Date.now());
-  }
-
-  return undefined;
-}
-
-/**
- * Whether to try again, and how long to wait first.
- *
- * `jitter` is a value in [0, 1) supplied by the caller rather than drawn here,
- * so the backoff arithmetic is deterministic under test. It only ever
- * shortens the wait: lengthening it could push past the window the server
- * implied, while shortening is what breaks up the thundering herd of clients
- * that were all rate-limited at the same instant and would otherwise wake
- * together.
- */
-export function retryDecision(
-  error: unknown,
-  attempt: number,
-  policy: RetryPolicy,
-  jitter: number,
-): RetryDecision {
-  if (attempt >= policy.maxRetries) {
-    return { retry: false, reason: `giving up after ${policy.maxRetries} retries` };
-  }
-
-  const headers = headersOf(error);
-  const status = statusOf(error);
-
-  // The same prompt overflows the same way however often it is sent, even
-  // when a relay dresses the rejection up as a 5xx. The loop owns the remedy.
-  if (error instanceof Error && isContextOverflow(error.message, status)) {
-    return { retry: false, reason: "the prompt exceeds the model's context window" };
-  }
-
-  // A certificate is the same on every attempt; retrying only delays the one
-  // message that sends the user to their proxy or CA bundle. Checked before
-  // the TypeError rule, which undici uses to wrap exactly this failure.
-  if (status === undefined && certificateFailure(error)) {
-    return { retry: false, reason: "the server's certificate could not be verified" };
-  }
-
-  if (isStreamIdle(error)) {
-    return attempt < STREAM_IDLE_RETRIES
-      ? { retry: true, delayMs: backoffMs(attempt, jitter) }
-      : { retry: false, reason: `the stream went silent ${attempt + 1} times` };
-  }
-
-  // A connection that died or never opened says nothing about the request,
-  // whichever wrapper carried it here.
-  if (status === undefined && connectionFailure(error) !== undefined) {
-    return { retry: true, delayMs: backoffMs(attempt, jitter) };
-  }
-
-  // A provider that knows whether its own error is worth retrying gets the
-  // last word, in both directions.
-  // A failure reported inside a 200 stream carries no status. Relays and
-  // Anthropic's own `overloaded_error` use it for exactly the conditions a
-  // 5xx would signal; anything else in a stream is a real rejection.
-  if (status === undefined && (isStreamFailure(error) || isMalformedResponse(error))) {
-    // A contradictory response is a bad sample, not a rejection of the request:
-    // resend it like a dropped stream, and let the bound turn it into an error.
-    if (isStreamFailure(error) && !TRANSIENT_STREAM.test(`${error.code ?? ""} ${error.message}`)) {
-      return { retry: false, reason: "the stream reported a non-transient error" };
-    }
-    return { retry: true, delayMs: backoffMs(attempt, jitter) };
-  }
-
-  const advice = headers?.get("x-should-retry");
-  let worthRetrying: boolean;
-  if (advice === "true") worthRetrying = true;
-  else if (advice === "false") worthRetrying = false;
-  else if (status !== undefined) worthRetrying = statusIsTransient(status);
-  else {
-    // No status at all. fetch reports a refused, reset or dropped connection
-    // as a TypeError, which is exactly the transient case. Anything else --
-    // a TypeError from our own code, a RangeError -- is a bug, and retrying a
-    // bug just runs it again.
-    worthRetrying = error instanceof TypeError;
-  }
-
-  if (!worthRetrying) {
-    return {
-      retry: false,
-      reason: status === undefined ? "not a retryable failure" : `HTTP ${status} is not retryable`,
-    };
-  }
-
-  const requested = serverDelayMs(headers);
-  if (requested !== undefined) {
-    if (requested > policy.maxRetryDelayMs) {
-      return {
-        retry: false,
-        reason:
-          `server asked to wait ${Math.ceil(requested / 1000)}s, ` +
-          `longer than the ${Math.ceil(policy.maxRetryDelayMs / 1000)}s cap`,
-      };
-    }
-    return { retry: true, delayMs: requested };
-  }
-
-  return { retry: true, delayMs: backoffMs(attempt, jitter) };
-}
-
-export interface RetryEffects {
-  sleep(ms: number, signal?: AbortSignal): Promise<void>;
-  jitter(): number;
-}
-
-function abortReason(signal: AbortSignal): Error {
-  if (signal.reason instanceof Error) return signal.reason;
-  return new DOMException("The operation was aborted.", "AbortError");
-}
-
-/**
- * A wait the caller can cancel.
- *
- * The SDK's own retry timers ignore AbortSignal, which is why the adapters
- * retry with `maxRetries: 0` and sleep here. A sleep that runs to the end
- * after Escape is the hang the user pressed it to get out of.
- */
-function interruptibleSleep(ms: number, signal?: AbortSignal): Promise<void> {
-  if (signal === undefined) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  return new Promise((resolve, reject) => {
-    if (signal.aborted) {
-      reject(abortReason(signal));
-      return;
-    }
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(abortReason(signal));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-export const DEFAULT_RETRY_EFFECTS: RetryEffects = {
-  sleep: interruptibleSleep,
-  jitter: () => Math.random(),
-};
-
-/**
- * Resolves when `waiting` does, or rejects as soon as the signal fires.
- *
- * Injected sleeps are allowed to ignore the signal -- tests do, to prove
- * this wrapper is what stops the wait. Swallowing the abandoned sleep
- * avoids an unhandled rejection when it later settles.
- */
-function waitOrAbort(waiting: Promise<void>, signal?: AbortSignal): Promise<void> {
-  if (signal === undefined) return waiting;
-  if (signal.aborted) {
-    void waiting.catch(() => {});
-    return Promise.reject(abortReason(signal));
-  }
-  return new Promise<void>((resolve, reject) => {
-    const onAbort = () => {
-      cleanup();
-      void waiting.catch(() => {});
-      reject(abortReason(signal));
-    };
-    const onSettled = (error?: unknown) => {
-      cleanup();
-      if (error === undefined) resolve();
-      else reject(error);
-    };
-    const cleanup = () => signal.removeEventListener("abort", onAbort);
-    signal.addEventListener("abort", onAbort, { once: true });
-    waiting.then(() => onSettled(), (error: unknown) => onSettled(error));
-  });
-}
-
-/**
- * Runs a request, retrying per the policy.
- *
- * `onRetry` exists so the caller can say something. A retry that produces no
- * output is indistinguishable from a hang, which is the problem this was
- * supposed to solve rather than one to introduce.
- *
- * `signal` is per-request, not per-policy: aborting one send must not
- * poison the adapter. An already-aborted signal does not start an attempt,
- * and an abort during backoff does not wait out the delay -- both would
- * turn Escape into "wait, then maybe stop".
- */
-export async function withRetry<T>(
-  request: () => Promise<T>,
-  policy: RetryPolicy = DEFAULT_RETRY,
-  fx: RetryEffects = DEFAULT_RETRY_EFFECTS,
-  onRetry?: (attempt: number, delayMs: number, error: unknown) => void,
-  signal?: AbortSignal,
-): Promise<T> {
-  const effects = fx ?? DEFAULT_RETRY_EFFECTS;
-  for (let attempt = 0; ; attempt++) {
-    if (signal?.aborted) throw abortReason(signal);
-    try {
-      return await request();
-    } catch (error) {
-      // Checked here rather than inside retryDecision: abort is a user
-      // decision, not a status code, and a fetch abort that surfaces as
-      // TypeError must not start another wait.
-      if (signal?.aborted) throw abortReason(signal);
-      const decision = retryDecision(error, attempt, policy, effects.jitter());
-      if (!decision.retry) throw error;
-      onRetry?.(attempt + 1, decision.delayMs, error);
-      await waitOrAbort(effects.sleep(decision.delayMs, signal), signal);
-    }
-  }
-}

package/src/runtime/review-tool.ts

@@ -1,48 +0,0 @@
-/** Shared diff preparation for model tools and user review commands; no provider calls. */
-import type { FileChanges } from "../core/checkpoints.ts";
-import type { ReviewScope } from "../core/review.ts";
-import { failureFromError, READ_ATTEMPTED } from "../core/tool-failure.ts";
-import { readReview, readCheckpointReview } from "../store/review.ts";
-import { presentObservation, type ToolContext, type ToolDefinition } from "./tools.ts";
-
-export interface LastTurnReview { blobs: string; changes: FileChanges; limitations: string[] }
-export interface DiffToolOptions {
-  lastTurn?: (context: ToolContext) => Promise<LastTurnReview>;
-  /** Current resource policy must be checked before diff bytes enter an artifact or model output. */
-  canRead?: (context: ToolContext, path: string) => Promise<boolean>;
-}
-export function parseReviewScope(input: Record<string, unknown>): ReviewScope {
-  const kind = input["scope"] ?? "working";
-  if (kind === "working" || kind === "last-turn") {
-    if (input["base"] !== undefined || input["commit"] !== undefined) throw new Error(`${kind} scope accepts no revision`);
-    return { kind };
-  }
-  if (kind === "branch" && typeof input["base"] === "string" && input["base"].trim() && input["commit"] === undefined) return { kind, base: input["base"] };
-  if (kind === "commit" && typeof input["commit"] === "string" && input["commit"].trim() && input["base"] === undefined) return { kind, commit: input["commit"] };
-  throw new Error("review scope must be working, branch with base, commit with commit, or last-turn");
-}
-
-export function createDiffTool(options: DiffToolOptions = {}): ToolDefinition {
-  return {
-    name: "diff", access: "read", execution: "parallel", branch: "read",
-    description: "Read a unified diff for current staged/unstaged/untracked changes, a branch merge base, a selected commit, or durable checkpoints in the last user turn. Fixed Git argv disables external diff/textconv drivers and confines paths to the workspace. Reports uncaptured or unavailable data explicitly. This observes changes; it does not change files or run a model review.",
-    input_schema: { type: "object", required: [], properties: { scope: { type: "string", enum: ["working", "branch", "commit", "last-turn"] }, base: { type: "string" }, commit: { type: "string" } } },
-    run: async (ctx, input) => {
-      try {
-        const scope = parseReviewScope(input);
-        const canRead = options.canRead === undefined ? undefined : (path: string) => options.canRead!(ctx, path);
-        const snapshot = scope.kind === "last-turn" ? await (async () => {
-          if (!options.lastTurn) throw new Error("last-turn diff requires original session checkpoint history");
-          const original = await options.lastTurn(ctx);
-          return readCheckpointReview(original.blobs, original.changes, original.limitations, canRead);
-        })() : await readReview(ctx.root, scope, ctx.signal, canRead);
-        const notices = snapshot.limitations.length ? "\nLimitations:\n" + snapshot.limitations.map(line => "- " + line).join("\n") : "";
-        return { ...await presentObservation(ctx, `${snapshot.label}\n${snapshot.diff || "(no captured changes)"}${notices}`), ok: true,
-          data: { scope: scope.kind, paths: snapshot.paths, limitations: snapshot.limitations, ...(snapshot.base === undefined ? {} : { base: snapshot.base }) } };
-      } catch (error) {
-        const diagnostic = failureFromError(error, READ_ATTEMPTED);
-        return { ok: false, content: diagnostic.message, diagnostic };
-      }
-    },
-  };
-}

package/src/runtime/rich-text.ts

@@ -1,36 +0,0 @@
-/** Ported from Pi (MIT), theme.ts and components/mermaid.ts at 02eed88; only presentation, never log rewriting. */
-import { Marked } from "marked";
-import { render } from "grok-mermaid";
-import { highlight, supportsLanguage, loadAllHighlightLanguages } from "../vendor/pi-rich/syntax-highlight.ts";
-
-type Paint = (token: string, text: string) => string;
-export const warmSyntaxLanguages = loadAllHighlightLanguages;
-export function highlightCode(code: string, language: string | undefined, paint: Paint): string[] {
-  if (!language || !supportsLanguage(language)) return code.split("\n").map(line => paint("mdCodeBlock", line));
-  const tokens: Record<string, string> = { keyword: "Keyword", built_in: "Function", title: "Function", function: "Function",
-    string: "String", regexp: "String", number: "Number", literal: "Number", type: "Type", class: "Type",
-    variable: "Variable", params: "Variable", attr: "Variable", attribute: "Variable", symbol: "Variable",
-    comment: "Comment", meta: "Comment", operator: "Operator", punctuation: "Punctuation" };
-  try { return highlight(code, { language, ignoreIllegals: true,
-    theme: Object.fromEntries(Object.entries(tokens).map(([scope, token]) => [scope, (text: string) => paint("syntax" + token, text)])),
-  }).split("\n"); } catch { return code.split("\n"); }
-}
-const parser = new Marked();
-function codeSpan(line: string): string {
-  const content = line || "\u00a0";
-  const longest = Math.max(0, ...Array.from(content.matchAll(/`+/g), match => match[0].length));
-  const fence = "`".repeat(longest + 1), padding = content.startsWith("`") || content.endsWith("`") ? " " : "";
-  return `${fence}${padding}${content}${padding}${fence}`;
-}
-export function transformMermaid(markdown: string, width: number, mode: "off" | "final" | "streaming", streaming: boolean, paint: Paint): string {
-  if (mode === "off" || streaming && mode !== "streaming") return markdown;
-  try { return parser.lexer(markdown).map(token => {
-    if (token.type !== "code" || token.lang?.trim().split(/\s+/, 1)[0]?.toLowerCase() !== "mermaid") return token.raw;
-    // Incomplete stream fences remain source; rendering half a graph would flicker and lose error context.
-    if (streaming && !/\n\s*(`{3,}|~{3,})\s*$/.test(token.raw.trimEnd())) return token.raw;
-    const art = render(token.text);
-    if (!art || art.width > width || art.warnings.length) return token.raw;
-    const tokens: Record<string, string> = { border: "borderMuted", text: "text", edge: "accent", edgeLabel: "muted", title: "accent" };
-    return art.styled.map(row => codeSpan(row.map(span => paint(tokens[span.cls] ?? "text", span.text)).join(""))).join("  \n") + "\n";
-  }).join(""); } catch { return markdown; }
-}