@ai-matrx/chat 0.6.6 → 0.7.1

package/dist/tool-call-visualization/configured-rows/field-components.js

@@ -0,0 +1,244 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "@ai-matrx/design-system";
+import { MarkdownStream } from "../../ui/markdown-stream/MarkdownStream.js";
+import { formatFileSize } from "@ai-matrx/kit/format";
+import { Globe } from "lucide-react";
+import { useState } from "react";
+function safeJson(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+const BoldLabel = ({ value, className }) => /* @__PURE__ */ jsx("div", { className: cn("text-[12px] font-semibold", className), children: String(value ?? "") });
+const TextDisplay = ({ value, className }) => /* @__PURE__ */ jsx("div", { className: cn("text-[12px]", className), children: String(value ?? "") });
+const Markdown = ({ value, className }) => {
+  if (value != null && typeof value === "object") {
+    return /* @__PURE__ */ jsx(
+      "pre",
+      {
+        className: cn(
+          "max-h-96 overflow-auto rounded-md bg-background/60 p-1.5 text-[11px] leading-snug whitespace-pre-wrap",
+          className
+        ),
+        children: safeJson(value)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("div", { className, children: /* @__PURE__ */ jsx(MarkdownStream, { content: String(value ?? "") }) });
+};
+const Code = ({ value, className }) => /* @__PURE__ */ jsx(
+  "pre",
+  {
+    className: cn(
+      "max-h-48 overflow-auto rounded-md bg-background/60 p-1.5 text-[11px] leading-snug",
+      className
+    ),
+    children: String(value ?? "")
+  }
+);
+const Json = ({ value, className }) => /* @__PURE__ */ jsx(
+  "pre",
+  {
+    className: cn(
+      "max-h-48 overflow-auto rounded-md bg-background/60 p-1.5 text-[11px] leading-snug",
+      className
+    ),
+    children: safeJson(value)
+  }
+);
+const Image = ({ value, className }) => {
+  const src = typeof value === "string" ? value : "";
+  if (!src) return null;
+  return /* @__PURE__ */ jsx("img", { src, className: cn("max-w-full rounded-md", className), alt: "" });
+};
+const Base64Image = ({ value, className }) => {
+  const src = toDataUri(value);
+  if (!src) return null;
+  const meta = imageMeta(value);
+  return /* @__PURE__ */ jsxs("div", { className: cn("space-y-1", className), children: [
+    /* @__PURE__ */ jsx(
+      "img",
+      {
+        src,
+        alt: "",
+        className: "max-h-[28rem] w-full rounded-md border border-border/40 object-contain"
+      }
+    ),
+    meta && /* @__PURE__ */ jsx("div", { className: "text-[10px] text-muted-foreground", children: meta })
+  ] });
+};
+function toDataUri(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("http://") || value.startsWith("https://")) return value;
+    return value.startsWith("data:") ? value : `data:image/png;base64,${value}`;
+  }
+  if (value == null || typeof value !== "object") return "";
+  const obj = value;
+  const hosted = pickString(obj, ["file_url", "url", "image_url"]);
+  if (hosted && (hosted.startsWith("http://") || hosted.startsWith("https://"))) {
+    return hosted;
+  }
+  const raw = pickString(obj, ["image_base64", "base64", "data", "image"]);
+  if (!raw) return "";
+  if (raw.startsWith("data:")) return raw;
+  const mediaType = pickString(obj, ["media_type", "mediaType", "mime_type", "mimeType"]) ?? formatToMime(pickString(obj, ["format"])) ?? "image/png";
+  return `data:${mediaType};base64,${raw}`;
+}
+function imageMeta(value) {
+  if (value == null || typeof value !== "object") return "";
+  const obj = value;
+  const w = obj.width ?? obj.w;
+  const h = obj.height ?? obj.h;
+  const bytes = obj.byte_length ?? obj.byteLength ?? obj.size;
+  const parts = [];
+  if (typeof w === "number" && typeof h === "number") parts.push(`${w}\xD7${h}`);
+  if (typeof bytes === "number") parts.push(formatFileSize(bytes));
+  return parts.join(" \xB7 ");
+}
+function pickString(obj, keys) {
+  for (const k of keys) {
+    const v = obj[k];
+    if (typeof v === "string" && v) return v;
+  }
+  return void 0;
+}
+function formatToMime(format) {
+  if (!format) return void 0;
+  const f = format.toLowerCase();
+  if (f === "jpeg" || f === "jpg") return "image/jpeg";
+  if (f === "png") return "image/png";
+  if (f === "webp") return "image/webp";
+  if (f === "gif") return "image/gif";
+  return `image/${f}`;
+}
+const Badge = ({ value, className }) => /* @__PURE__ */ jsx(
+  "span",
+  {
+    className: cn(
+      "inline-flex rounded-full bg-muted px-2 py-0.5 text-[10px] text-muted-foreground",
+      className
+    ),
+    children: String(value ?? "")
+  }
+);
+const Chips = ({ value, className }) => {
+  const items = Array.isArray(value) ? value.map((v) => v == null ? "" : String(v)).filter(Boolean) : value == null ? [] : [String(value)];
+  if (items.length === 0) return null;
+  return /* @__PURE__ */ jsx("div", { className: cn("flex flex-wrap gap-1", className), children: items.map((item, i) => /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: "inline-flex rounded-md border border-border/50 bg-muted/40 px-1.5 py-0.5 font-mono text-[10px] text-foreground",
+      children: item
+    },
+    `${item}-${i}`
+  )) });
+};
+const TabCard = ({ value, className }) => {
+  const [faviconErr, setFaviconErr] = useState(false);
+  if (value == null || typeof value !== "object") return null;
+  const obj = value;
+  const title = pickString(obj, ["title"]) ?? "";
+  const url = pickString(obj, ["url"]) ?? "";
+  const favicon = pickString(obj, ["fav_icon_url", "favIconUrl", "favicon"]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "flex items-start gap-2 rounded-md border border-border/40 bg-background/40 p-2",
+        className
+      ),
+      children: [
+        favicon && !faviconErr ? /* @__PURE__ */ jsx(
+          "img",
+          {
+            src: favicon,
+            alt: "",
+            className: "size-5 shrink-0 rounded-sm object-contain",
+            onError: () => setFaviconErr(true)
+          }
+        ) : /* @__PURE__ */ jsx(Globe, { className: "size-5 shrink-0 text-muted-foreground" }),
+        /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1 space-y-0.5", children: [
+          title && /* @__PURE__ */ jsx("div", { className: "truncate text-[12px] font-medium text-foreground", children: title }),
+          url && /* @__PURE__ */ jsx(
+            "a",
+            {
+              href: url,
+              target: "_blank",
+              rel: "noreferrer noopener",
+              className: "block truncate text-[10px] text-muted-foreground hover:text-foreground hover:underline",
+              onClick: (e) => e.stopPropagation(),
+              children: url
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+const Table = ({ value, className }) => {
+  if (value == null || typeof value !== "object") return null;
+  const obj = value;
+  const columns = Array.isArray(obj.columns) ? obj.columns : [];
+  const rows = Array.isArray(obj.rows) ? obj.rows : [];
+  if (columns.length === 0 || rows.length === 0) return null;
+  const visibleCols = columns.filter((c) => {
+    if (c.path && c.path.length > 0) return true;
+    return rows.some((r) => {
+      const cell = r.cells?.[c.index];
+      const v = cell?.value;
+      return typeof v === "string" ? v.trim().length > 0 : v != null;
+    });
+  });
+  if (visibleCols.length === 0) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn("overflow-auto rounded-md border border-border/40 bg-background/40", className),
+      children: [
+        /* @__PURE__ */ jsxs("table", { className: "w-full border-collapse text-[11px]", children: [
+          /* @__PURE__ */ jsx("thead", { className: "bg-muted/40", children: /* @__PURE__ */ jsx("tr", { children: visibleCols.map((c) => /* @__PURE__ */ jsx(
+            "th",
+            {
+              className: "border-b border-border/40 px-2 py-1 text-left font-medium text-muted-foreground",
+              children: (c.path ?? []).join(" \u203A ")
+            },
+            c.index
+          )) }) }),
+          /* @__PURE__ */ jsx("tbody", { children: rows.map((r, ri) => /* @__PURE__ */ jsx("tr", { className: "border-t border-border/20 hover:bg-muted/30", children: visibleCols.map((c) => {
+            const cell = r.cells?.[c.index];
+            return /* @__PURE__ */ jsx(
+              "td",
+              {
+                className: "max-w-[20rem] truncate px-2 py-1 align-top text-foreground",
+                title: typeof cell?.value === "string" ? cell.value : void 0,
+                children: typeof cell?.value === "string" ? cell.value : cell?.value == null ? "" : String(cell.value)
+              },
+              c.index
+            );
+          }) }, r.index ?? ri)) })
+        ] }),
+        obj.truncated === true && /* @__PURE__ */ jsx("div", { className: "border-t border-border/30 bg-muted/30 px-2 py-1 text-[10px] text-muted-foreground", children: "Table was truncated" })
+      ]
+    }
+  );
+};
+const fieldComponents = {
+  BoldLabel,
+  TextDisplay,
+  Markdown,
+  Code,
+  Json,
+  Image,
+  Base64Image,
+  Badge,
+  Chips,
+  TabCard,
+  Table
+};
+export {
+  fieldComponents
+};

package/dist/tool-call-visualization/configured-rows/helpers.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Resolution helpers for the tool-display registry. Everything here is silent
+ * on bad input — invalid paths return undefined, unknown transforms/icons log
+ * a console.warn and return a sensible fallback. Nothing throws into a render.
+ */
+import { type RowIcon } from './registries.js';
+import type { ColorToken, IconName, Phase, PhaseAware, ToolRowEntry, TransformName } from './types.js';
+/**
+ * If `v` is a `PhaseMap` (a plain object whose only keys are phase names),
+ * return the entry for the current phase (or undefined). Otherwise return `v`
+ * as-is — single-value config applies to every phase.
+ */
+export declare function resolvePhase<T>(v: PhaseAware<T> | undefined, phase: Phase): T | undefined;
+/**
+ * Resolve a dot-path against a tool entry. Recognized roots: args, output,
+ * result (alias of output), message, toolName, callId. Numeric path segments
+ * index into arrays. Returns undefined silently on any miss.
+ *
+ *   getByPath(entry, 'args.key')              → entry.args.key
+ *   getByPath(entry, 'output.items.0.title')  → entry.output.items[0].title
+ *   getByPath(entry, 'result.label')          → entry.output.label   (alias)
+ */
+export declare function getByPath(entry: ToolRowEntry, path: string): unknown;
+/**
+ * Run a value through one or more named transforms. Unknown names log a
+ * warning and pass the value through. A throwing transform logs and returns
+ * the last good value.
+ */
+export declare function applyTransforms(value: unknown, names?: TransformName | TransformName[] | null): unknown;
+/**
+ * Resolve a color token to a tailwind class. Error phase always wins (red),
+ * even if the registry tries to override it — keeps error visuals consistent.
+ */
+export declare function resolveColor(token: ColorToken | undefined, phase: Phase): string;
+/**
+ * Look up a registered icon by name. Unknown name: warn and use the phase default
+ * (`Loader2` for started, `CheckCircle2` for completed, `AlertTriangle` for error).
+ */
+export declare function resolveIcon(name: IconName | undefined, phase: Phase): RowIcon;

package/dist/tool-call-visualization/configured-rows/helpers.js

@@ -0,0 +1,110 @@
+import { AlertTriangle, CheckCircle2, Loader2 } from "lucide-react";
+import { ICONS } from "./registries.js";
+import { transforms } from "./transforms.js";
+function resolvePhase(v, phase) {
+  if (v == null) return void 0;
+  if (isPhaseMap(v)) return v[phase];
+  return v;
+}
+function isPhaseMap(v) {
+  if (v == null || typeof v !== "object" || Array.isArray(v)) return false;
+  const keys = Object.keys(v);
+  if (keys.length === 0) return false;
+  return keys.every((k) => k === "started" || k === "completed" || k === "error");
+}
+function getByPath(entry, path) {
+  if (!path) return void 0;
+  const segments = path.split(".");
+  const head = segments[0];
+  let cursor;
+  switch (head) {
+    case "args":
+      cursor = entry.args;
+      break;
+    case "output":
+    case "result":
+      cursor = entry.output;
+      break;
+    case "message":
+      cursor = entry.message;
+      break;
+    case "toolName":
+      cursor = entry.toolName;
+      break;
+    case "callId":
+      cursor = entry.callId;
+      break;
+    default:
+      return void 0;
+  }
+  for (let i = 1; i < segments.length; i++) {
+    if (cursor == null) return void 0;
+    const seg = segments[i];
+    if (seg === void 0) return void 0;
+    if (Array.isArray(cursor)) {
+      const idx = Number(seg);
+      if (!Number.isInteger(idx)) return void 0;
+      cursor = cursor[idx];
+    } else if (typeof cursor === "object") {
+      cursor = cursor[seg];
+    } else {
+      return void 0;
+    }
+  }
+  return cursor;
+}
+function applyTransforms(value, names) {
+  if (names == null) return value;
+  const list = Array.isArray(names) ? names : [names];
+  let cursor = value;
+  for (const name of list) {
+    const fn = transforms[name];
+    if (!fn) {
+      console.warn(`[configured-row] unknown transform: "${name}"`);
+      continue;
+    }
+    try {
+      cursor = fn(cursor);
+    } catch (err) {
+      console.warn(`[configured-row] transform "${name}" threw:`, err, { value: cursor });
+    }
+  }
+  return cursor;
+}
+const COLOR_CLASSES = {
+  blue: "text-blue-600 dark:text-blue-400",
+  sky: "text-sky-600 dark:text-sky-400",
+  emerald: "text-emerald-600 dark:text-emerald-400",
+  amber: "text-amber-600 dark:text-amber-400",
+  red: "text-red-600 dark:text-red-400",
+  violet: "text-violet-600 dark:text-violet-400",
+  slate: "text-slate-600 dark:text-slate-400",
+  primary: "text-primary",
+  muted: "text-muted-foreground"
+};
+function resolveColor(token, phase) {
+  if (phase === "error") return COLOR_CLASSES.red;
+  if (token && COLOR_CLASSES[token]) return COLOR_CLASSES[token];
+  if (phase === "started") return COLOR_CLASSES.primary;
+  if (phase === "completed") return COLOR_CLASSES.emerald;
+  return COLOR_CLASSES.muted;
+}
+const PHASE_DEFAULT_ICON = {
+  started: Loader2,
+  completed: CheckCircle2,
+  error: AlertTriangle
+};
+function resolveIcon(name, phase) {
+  if (!name) return PHASE_DEFAULT_ICON[phase];
+  const found = ICONS[name];
+  if (found) return found;
+  console.warn(`[configured-row] unregistered icon: "${name}"`);
+  return PHASE_DEFAULT_ICON[phase];
+}
+export {
+  applyTransforms,
+  getByPath,
+  resolveColor,
+  resolveIcon,
+  resolvePhase
+};

package/dist/tool-call-visualization/configured-rows/register.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDisplayEntry } from "./types.js";
+/**
+ * Configs the host keeps out of the first screen: the tool names up front (a cheap list), the
+ * configs on demand. `load` runs the first time a call to one of the tools is drawn.
+ */
+export interface LazyConfigs {
+    names: readonly string[];
+    load: () => Promise<Record<string, ToolDisplayEntry>>;
+}
+export interface RegisterConfiguredOptions {
+    /**
+     * Extra names each config is also registered under, as prefixes the server may put in front of
+     * the tool name (`["my-host:"]` registers `read_page` and `my-host:read_page`). The bare name is
+     * always registered.
+     */
+    namePrefixes?: readonly string[];
+    /** Removed from the call's tool name before the config paths read it (`toolName` paths). */
+    stripPrefix?: RegExp;
+}
+/** Register every config as a `row`-chrome renderer. Returns the registered names. */
+export declare function registerConfiguredToolRenderers(configs: Record<string, ToolDisplayEntry> | LazyConfigs, options?: RegisterConfiguredOptions): string[];
+export { registerRowTransforms } from "./transforms.js";
+export { registerRowIcons, registerRowFieldComponents } from "./registries.js";
+export type { RowTransform } from "./transforms.js";
+export type { ToolDisplayEntry, ToolRowEntry, ToolProgressRow } from "./types.js";

package/dist/tool-call-visualization/configured-rows/register.js

@@ -0,0 +1,51 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { clientLazy } from "@ai-matrx/kit/client-lazy";
+import { registerToolRenderer } from "../registry/registry.js";
+function RowPlaceholder() {
+  return /* @__PURE__ */ jsx("div", { className: "h-5", "aria-hidden": true });
+}
+const ConfiguredRowRenderer = clientLazy(
+  () => import("./ConfiguredRowRenderer.js").then((m) => ({ default: m.ConfiguredRowRenderer })),
+  { loading: RowPlaceholder }
+);
+function titleCase(name) {
+  return name.split(/[_\s-]+/).filter(Boolean).map((p) => p[0] ? p[0].toUpperCase() + p.slice(1) : p).join(" ");
+}
+function registerConfiguredToolRenderers(configs, options = {}) {
+  const registered = [];
+  const lazy = "load" in configs && typeof configs.load === "function" ? configs : null;
+  const names = lazy ? lazy.names : Object.keys(configs);
+  for (const bare of names) {
+    const cfg = lazy ? null : configs[bare];
+    const Inline = (props) => /* @__PURE__ */ jsx(
+      ConfiguredRowRenderer,
+      {
+        props,
+        bare,
+        ...cfg && { cfg },
+        ...lazy && { load: lazy.load },
+        ...options.stripPrefix && { stripPrefix: options.stripPrefix }
+      }
+    );
+    for (const toolName of [bare, ...(options.namePrefixes ?? []).map((p) => `${p}${bare}`)]) {
+      const renderer = {
+        toolName,
+        displayName: titleCase(bare),
+        chrome: "row",
+        InlineComponent: Inline
+      };
+      registerToolRenderer(toolName, renderer);
+      registered.push(toolName);
+    }
+  }
+  return registered;
+}
+import { registerRowTransforms } from "./transforms.js";
+import { registerRowIcons, registerRowFieldComponents } from "./registries.js";
+export {
+  registerConfiguredToolRenderers,
+  registerRowFieldComponents,
+  registerRowIcons,
+  registerRowTransforms
+};

package/dist/tool-call-visualization/configured-rows/registries.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a host adds to the configured rows: the icons its configs name and its own field
+ * components. Kept apart from the row code on purpose: registering costs nothing, and the row
+ * (loaded on first sight of a call) reads these when it draws.
+ */
+import type { ComponentType } from "react";
+import type { FieldComponentName, IconName } from "./types.js";
+export type RowIcon = ComponentType<{
+    className?: string;
+}>;
+export interface RowFieldProps {
+    value: unknown;
+    className?: string;
+}
+/**
+ * The icons a config can name. Deliberately NOT `import * as lucide`: that pulls the whole icon
+ * set (~200 kB gzip) into whichever chunk draws a row. A host registers the icons its configs
+ * name (`registerRowIcons({ Camera, HandGrab })`) and so pays only for those.
+ */
+export declare const ICONS: Record<IconName, RowIcon>;
+export declare function registerRowIcons(icons: Record<IconName, RowIcon>): void;
+export declare const FIELD_OVERRIDES: Partial<Record<FieldComponentName, ComponentType<RowFieldProps>>>;
+/**
+ * Replace field components with the host's own (the host's markdown renderer, say). Call once at
+ * module load, before a row renders; an override must accept `{ value, className }`.
+ */
+export declare function registerRowFieldComponents(overrides: Partial<Record<FieldComponentName, ComponentType<RowFieldProps>>>): void;

package/dist/tool-call-visualization/configured-rows/registries.js

@@ -0,0 +1,14 @@
+const ICONS = {};
+function registerRowIcons(icons) {
+  Object.assign(ICONS, icons);
+}
+const FIELD_OVERRIDES = {};
+function registerRowFieldComponents(overrides) {
+  Object.assign(FIELD_OVERRIDES, overrides);
+}
+export {
+  FIELD_OVERRIDES,
+  ICONS,
+  registerRowFieldComponents,
+  registerRowIcons
+};

package/dist/tool-call-visualization/configured-rows/to-row-entry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fold the package's `ToolLifecycleEntry` into the flat shape a configured row reads
+ * (`args.x` / `output.y` / `message` paths). Progress comes from the call's `tool_progress`
+ * events: the event message is the line, `data.step` / `data.status` / `data.percent` ride along.
+ */
+import type { ToolLifecycleEntry } from "../../agents/types/request.types.js";
+import type { ToolRowEntry } from "./types.js";
+export declare function toRowEntry(entry: ToolLifecycleEntry, stripPrefix?: RegExp): ToolRowEntry;

package/dist/tool-call-visualization/configured-rows/to-row-entry.js

@@ -0,0 +1,38 @@
+const PROGRESS_STATUSES = /* @__PURE__ */ new Set(["pending", "active", "done", "error"]);
+function progressOf(entry) {
+  const rows = [];
+  for (const ev of entry.events ?? []) {
+    if (ev.event !== "tool_progress") continue;
+    const data = ev.data ?? {};
+    const status = typeof data.status === "string" && PROGRESS_STATUSES.has(data.status) ? data.status : void 0;
+    rows.push({
+      at: typeof ev.timestamp === "number" ? ev.timestamp * 1e3 : Date.now(),
+      label: ev.message ?? void 0,
+      step: typeof data.step === "string" ? data.step : void 0,
+      status,
+      percent: typeof data.percent === "number" ? data.percent : void 0,
+      data: data.metadata ?? data.data
+    });
+  }
+  return rows.length > 0 ? rows : void 0;
+}
+function toRowEntry(entry, stripPrefix) {
+  const phase = entry.status === "completed" ? "completed" : entry.status === "error" ? "error" : "started";
+  const ended = entry.completedAt ? Date.parse(entry.completedAt) : void 0;
+  const message = entry.errorMessage ?? entry.latestMessage ?? void 0;
+  const progress = progressOf(entry);
+  return {
+    callId: entry.callId,
+    toolName: stripPrefix ? entry.toolName.replace(stripPrefix, "") : entry.toolName,
+    startedAt: Date.parse(entry.startedAt),
+    phase,
+    args: entry.arguments,
+    output: entry.result ?? void 0,
+    ...ended !== void 0 && { endedAt: ended },
+    ...message !== void 0 && { message },
+    ...progress !== void 0 && { progress }
+  };
+}
+export {
+  toRowEntry
+};

package/dist/tool-call-visualization/configured-rows/transforms.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Named value transformers for configured tool rows: used by `inline.info` (header text) and
+ * `results.keysInfo` (expanded body fields). The generic ones ship here; a host adds its own
+ * (its tools' action verbs, its icon maps) with `registerRowTransforms`, then names them from its
+ * row configs.
+ *
+ * Contract: `(unknown) => unknown`. A transform is a no-op for input it cannot handle (titleCase
+ * only acts on strings): it never throws.
+ */
+import type { TransformName } from "./types.js";
+export type RowTransform = (value: unknown) => unknown;
+export declare const transforms: Record<TransformName, RowTransform>;
+/** Add (or replace) named transforms; call once at module load, before a row renders. */
+export declare function registerRowTransforms(extra: Record<TransformName, RowTransform>): void;

package/dist/tool-call-visualization/configured-rows/transforms.js

@@ -0,0 +1,30 @@
+const titleCaseFn = (v) => {
+  if (typeof v !== "string") return v;
+  return v.split(/[_\-\s]+/).filter(Boolean).map((p) => p[0] ? p[0].toUpperCase() + p.slice(1) : p).join(" ");
+};
+const transforms = {
+  titleCase: titleCaseFn,
+  snakeToTitle: titleCaseFn,
+  kebabToTitle: titleCaseFn,
+  textClean: (v) => typeof v === "string" ? v.replace(/\\([_*`])/g, "$1").trim() : v,
+  truncate80: (v) => typeof v === "string" && v.length > 80 ? `${v.slice(0, 80)}\u2026` : v,
+  truncate200: (v) => typeof v === "string" && v.length > 200 ? `${v.slice(0, 200)}\u2026` : v,
+  lowercase: (v) => typeof v === "string" ? v.toLowerCase() : v,
+  uppercase: (v) => typeof v === "string" ? v.toUpperCase() : v,
+  /** Object with width/height → "WxH" string. Useful when info.path: 'output'. */
+  formatImageDimensions: (v) => {
+    if (v == null || typeof v !== "object") return v;
+    const obj = v;
+    const w = obj.width ?? obj.w;
+    const h = obj.height ?? obj.h;
+    if (typeof w !== "number" || typeof h !== "number") return void 0;
+    return `${w}\xD7${h}`;
+  }
+};
+function registerRowTransforms(extra) {
+  Object.assign(transforms, extra);
+}
+export {
+  registerRowTransforms,
+  transforms
+};