@webmcp-auto-ui/ui 2.5.32 → 2.5.33

package/src/widgets/SafeImage.svelte

@@ -0,0 +1,67 @@
+<script lang="ts">
+  /**
+   * SafeImage — URL validation + error fallback. Replaces raw <img> in widgets.
+   */
+  interface Props {
+    src: string | undefined | null;
+    alt?: string;
+    class?: string;
+    style?: string;
+    loading?: 'lazy' | 'eager';
+    fallbackText?: string;
+    hideOnError?: boolean;
+  }
+
+  let { src, alt = '', class: className = '', style = '', loading = 'lazy', fallbackText, hideOnError = false }: Props = $props();
+
+  const VALID_PREFIXES = ['http://', 'https://', 'data:', '/'];
+
+  const isValidUrl = $derived(
+    typeof src === 'string' && src.length > 0 && VALID_PREFIXES.some(p => src!.startsWith(p))
+  );
+
+  let hasError = $state(false);
+  let isLoaded = $state(false);
+
+  $effect(() => {
+    if (src) {
+      hasError = false;
+      isLoaded = false;
+    }
+  });
+
+  function onError() { hasError = true; }
+  function onLoad() { isLoaded = true; }
+
+  const showPlaceholder = $derived(!isValidUrl || hasError);
+  const label = $derived(fallbackText ?? alt ?? 'Image');
+</script>
+
+{#if showPlaceholder}
+  {#if !hideOnError}
+    <div
+      class="flex items-center justify-center bg-surface2 text-text2 text-xs {className}"
+      {style}
+      role="img"
+      aria-label={label}
+    >
+      <svg class="w-5 h-5 opacity-40 mr-1" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5">
+        <rect x="3" y="3" width="18" height="18" rx="2" />
+        <circle cx="8.5" cy="8.5" r="1.5" />
+        <path d="M21 15l-5-5L5 21" />
+      </svg>
+      <span class="truncate max-w-[80%]">{label}</span>
+    </div>
+  {/if}
+{:else}
+  <img
+    {src}
+    {alt}
+    class={className}
+    {style}
+    {loading}
+    onerror={onError}
+    onload={onLoad}
+    referrerpolicy="no-referrer"
+  />
+{/if}

package/src/widgets/WidgetRenderer.svelte

@@ -13,84 +13,89 @@
   }
 
   // Safe clone for data passed to vanilla renderers — strips Svelte 5 $state
-  // proxies without crashing on BigInt / circular refs / undefined values.
+  // proxies, then falls back to a JSON pass that drops non-serializable values.
   function safeClone<T>(value: T): T {
     if (value === null || typeof value !== 'object') return value;
     try {
       return structuredClone(value);
-    } catch (err) {
-      console.warn('[WidgetRenderer] structuredClone failed, falling back to shallow copy', err);
-      return { ...(value as Record<string, unknown>) } as T;
+    } catch {
+      try {
+        const seen = new WeakSet<object>();
+        return JSON.parse(JSON.stringify(value, (_k, v) => {
+          if (v === null || v === undefined) return v;
+          const t = typeof v;
+          if (t === 'function' || t === 'symbol' || t === 'bigint') return undefined;
+          if (t !== 'object') return v;
+          if (typeof Node !== 'undefined' && v instanceof Node) return undefined;
+          if (typeof Window !== 'undefined' && v instanceof Window) return undefined;
+          if (typeof Event !== 'undefined' && v instanceof Event) return undefined;
+          if (seen.has(v)) return undefined;
+          seen.add(v);
+          return v;
+        })) as T;
+      } catch {
+        return value;
+      }
     }
   }
 
-  // ── Native vanilla renderers ─────────────────────────────────────────────
-  // Simple widgets
-  import { render as renderStat }    from './simple/stat.js';
-  import { render as renderKv }      from './simple/kv.js';
-  import { render as renderList }    from './simple/list.js';
-  import { render as renderChart }   from './simple/chart.js';
-  import { render as renderAlert }   from './simple/alert.js';
-  import { render as renderCode }    from './simple/code.js';
-  import { render as renderText }    from './simple/text.js';
-  import { render as renderActions } from './simple/actions.js';
-  import { render as renderTags }    from './simple/tags.js';
-  // Rich widgets
-  import { render as renderStatCard }      from './rich/stat-card.js';
-  import { render as renderProfile }       from './rich/profile.js';
-  import { render as renderJsonViewer }    from './rich/json-viewer.js';
-  import { render as renderChartRich }     from './rich/chart-rich.js';
-  import { render as renderSankey }        from './rich/sankey.js';
-  import { render as renderHemicycle }     from './rich/hemicycle.js';
-  import { render as renderDataTable }     from './rich/data-table.js';
-  import { render as renderTimeline }      from './rich/timeline.js';
-  import { render as renderTrombinoscope } from './rich/trombinoscope.js';
-  import { render as renderCards }         from './rich/cards.js';
-  import { render as renderGridData }      from './rich/grid-data.js';
-  import { render as renderMap }           from './rich/map.js';
-  import { render as renderD3 }            from './rich/d3.js';
-  import { render as renderJsSandbox }    from './rich/js-sandbox.js';
-  import { render as renderLog }           from './rich/log.js';
-  import { render as renderGallery }       from './rich/gallery.js';
-  import { render as renderCarousel }      from './rich/carousel.js';
-
-  /** A vanilla renderer: returns cleanup or Promise thereof. */
+  // ── Native custom-element widgets (Svelte 5 compiled) ────────────────────
+  // Side-effect imports register the custom elements with the browser.
+  // Simple (9)
+  import './simple/stat.svelte';
+  import './simple/kv.svelte';
+  import './simple/list.svelte';
+  import './simple/chart.svelte';
+  import './simple/alert.svelte';
+  import './simple/code.svelte';
+  import './simple/text.svelte';
+  import './simple/actions.svelte';
+  import './simple/tags.svelte';
+  // Rich (15) — map and d3 intentionally omitted (see plan: handled by leaflet/d3 servers)
+  import './rich/stat-card.svelte';
+  import './rich/profile.svelte';
+  import './rich/json-viewer.svelte';
+  import './rich/chart-rich.svelte';
+  import './rich/sankey.svelte';
+  import './rich/hemicycle.svelte';
+  import './rich/data-table.svelte';
+  import './rich/timeline.svelte';
+  import './rich/trombinoscope.svelte';
+  import './rich/cards.svelte';
+  import './rich/grid-data.svelte';
+  import './rich/js-sandbox.svelte';
+  import './rich/log.svelte';
+  import './rich/gallery.svelte';
+  import './rich/carousel.svelte';
+  import './rich/chat-input.svelte';
+  // Notebook (1)
+  import './notebook/notebook.svelte';
+  // Agent browsers (registered as widgets for widget_display)
+  import '../agent/RecipeBrowser.svelte';
+
+  /** Native widget types served as custom elements (`<auto-${type}>`). */
+  const NATIVE_CUSTOM_ELEMENTS = new Set<string>([
+    // Simple
+    'stat', 'kv', 'list', 'chart', 'alert', 'code', 'text', 'actions', 'tags',
+    // Rich
+    'stat-card', 'profile', 'json-viewer', 'chart-rich', 'sankey', 'hemicycle',
+    'data-table', 'timeline', 'trombinoscope', 'cards', 'grid-data',
+    'js-sandbox', 'log', 'gallery', 'carousel', 'chat-input',
+    // Notebook
+    'notebook',
+    // Agent browsers
+    'recipe-browser',
+  ]);
+
+  /** A vanilla renderer: returns cleanup or Promise thereof. Still used for
+   *  server-provided custom widgets via `widget.vanilla = true`. */
   type VanillaRenderer = (
     container: HTMLElement,
     data: Record<string, unknown>,
   ) => void | (() => void) | Promise<void | (() => void)>;
 
-  /** Static map of all native widget types → vanilla renderer */
-  const NATIVE_VANILLA_MAP: Record<string, VanillaRenderer> = {
-    // Simple
-    'stat':           renderStat,
-    'kv':             renderKv,
-    'list':           renderList,
-    'chart':          renderChart,
-    'alert':          renderAlert,
-    'code':           renderCode,
-    'text':           renderText,
-    'actions':        renderActions,
-    'tags':           renderTags,
-    // Rich
-    'stat-card':      renderStatCard,
-    'profile':        renderProfile,
-    'json-viewer':    renderJsonViewer,
-    'chart-rich':     renderChartRich,
-    'sankey':         renderSankey,
-    'hemicycle':      renderHemicycle,
-    'data-table':     renderDataTable,
-    'timeline':       renderTimeline,
-    'trombinoscope':  renderTrombinoscope,
-    'cards':          renderCards,
-    'grid-data':      renderGridData,
-    'map':            renderMap,
-    'd3':             renderD3 as unknown as VanillaRenderer,
-    'js-sandbox':     renderJsSandbox as unknown as VanillaRenderer,
-    'log':            renderLog,
-    'gallery':        renderGallery,
-    'carousel':       renderCarousel,
-  };
+  /** No native vanilla widgets remain — all native widgets are custom elements. */
+  const NATIVE_VANILLA_MAP: Record<string, VanillaRenderer> = {};
 
   interface Props {
     id?: string;
@@ -115,7 +120,7 @@
     bus.broadcast(busId, 'interact', { type, action, payload });
   }
 
-  // ── Renderer resolution: servers > native vanilla > fallback ────────────
+  // ── Renderer resolution: servers > native custom-element > native vanilla > fallback ────
 
   // Look up a custom widget entry from connected WebMCP servers
   const customWidgetEntry = $derived.by(() => {
@@ -130,8 +135,13 @@
   const customRenderer = $derived(customWidgetEntry?.renderer ?? null);
   const isCustomVanilla = $derived(customWidgetEntry?.vanilla === true);
 
+  /** True if this widget type is served as a native Svelte-compiled custom element. */
+  const isNativeCustomElement = $derived(
+    !customRenderer && NATIVE_CUSTOM_ELEMENTS.has(type),
+  );
+
   const nativeVanillaRenderer = $derived<VanillaRenderer | undefined>(
-    customRenderer ? undefined : NATIVE_VANILLA_MAP[type],
+    customRenderer || isNativeCustomElement ? undefined : NATIVE_VANILLA_MAP[type],
   );
 
   /** True when a vanilla renderer (custom or native) should be used */
@@ -148,9 +158,54 @@
   // libs (D3, Leaflet, etc.) rely on Object.defineProperty which conflicts with proxies.
   const plainData: Record<string, unknown> = $derived(safeClone(data) as Record<string, unknown>);
 
+  // ── Custom element container + element handle ─────────
+  let ceContainer: HTMLElement | undefined = $state(undefined);
+  let ceElement: HTMLElement | undefined = undefined;
+
+  $effect(() => {
+    if (!isNativeCustomElement || !ceContainer) return;
+    const tag = `auto-${type}`;
+    // Instantiate on first mount. `data` setter is reactive via Svelte 5 custom-element.
+    const el = document.createElement(tag) as HTMLElement;
+    (el as unknown as { data: unknown }).data = plainData;
+    const onInteract = (ev: Event) => {
+      const ce = ev as CustomEvent<{ action?: string; payload?: unknown }>;
+      const action = ce.detail?.action ?? 'interact';
+      emit(action, ce.detail?.payload);
+    };
+    el.addEventListener('widget:interact', onInteract);
+    ceContainer.innerHTML = '';
+    ceContainer.appendChild(el);
+    ceElement = el;
+    return () => {
+      el.removeEventListener('widget:interact', onInteract);
+      ceElement = undefined;
+      if (ceContainer) ceContainer.innerHTML = '';
+    };
+  });
+
+  // In-place data updates on the custom element — no remount.
+  $effect(() => {
+    const next = plainData;
+    if (!isNativeCustomElement || !ceElement) return;
+    (ceElement as unknown as { data: unknown }).data = next;
+  });
+
   // ── Vanilla renderer container + lifecycle ────────────
   let vanillaContainer: HTMLElement | undefined = $state(undefined);
 
+  // Cleanup handle shared between the mount effect and the data-update fallback
+  // remount — so a fallback remount can tear down the previous render even
+  // though it doesn't re-run the mount effect.
+  let currentCleanup: (() => void) | undefined = undefined;
+  function runCurrentCleanup() {
+    const c = currentCleanup;
+    currentCleanup = undefined;
+    if (typeof c === 'function') {
+      try { c(); } catch (err) { console.error('[WidgetRenderer] cleanup failed:', err); }
+    }
+  }
+
   // Mount effect — re-runs only when the widget identity changes (type /
   // renderer / container). Data changes are handled separately to avoid a
   // flickering full remount on every agent update.
@@ -160,6 +215,9 @@
     if (!useVanilla || !vanillaRenderer || !vanillaContainer) return;
     const container = vanillaContainer;
     const renderer = vanillaRenderer;
+    // If a previous render is still live (e.g. via data-update fallback),
+    // tear it down before we clear the DOM.
+    runCurrentCleanup();
     container.innerHTML = '';
 
     const onInteract = (ev: Event) => {
@@ -169,17 +227,24 @@
     };
     container.addEventListener('widget:interact', onInteract);
 
-    let cleanup: (() => void) | void;
     let cancelled = false;
 
     try {
       const result = renderer(container, untrack(() => plainData));
       if (result && typeof (result as Promise<unknown>).then === 'function') {
         (result as Promise<void | (() => void)>).then(
-          (c) => { if (!cancelled) cleanup = c ?? undefined; },
+          (c) => {
+            // If we were torn down before the promise resolved, invoke the
+            // late cleanup immediately rather than leaking resources.
+            if (cancelled && typeof c === 'function') {
+              try { c(); } catch { /* ignore */ }
+            } else {
+              currentCleanup = c ?? undefined;
+            }
+          },
         ).catch((err) => { console.error('[WidgetRenderer] async render failed:', err); });
       } else {
-        cleanup = result as (() => void) | void;
+        currentCleanup = (result as (() => void) | undefined) ?? undefined;
       }
     } catch (err) {
       console.error('[WidgetRenderer] sync render failed:', err);
@@ -188,9 +253,7 @@
     return () => {
       cancelled = true;
       container.removeEventListener('widget:interact', onInteract);
-      if (typeof cleanup === 'function') {
-        try { cleanup(); } catch (err) { console.error('[WidgetRenderer] cleanup failed:', err); }
-      }
+      runCurrentCleanup();
     };
   });
 
@@ -208,10 +271,20 @@
     const handled = !vanillaContainer.dispatchEvent(ev);
     if (handled || !vanillaRenderer) return;
     // Not handled — fall back to remount by clearing + calling renderer again.
+    // Run the previous cleanup first so the old renderer releases its
+    // resources (timers, observers, third-party instances).
     const container = vanillaContainer;
+    runCurrentCleanup();
     container.innerHTML = '';
     try {
-      vanillaRenderer(container, data);
+      const result = vanillaRenderer(container, data);
+      if (result && typeof (result as Promise<unknown>).then === 'function') {
+        (result as Promise<void | (() => void)>).then(
+          (c) => { currentCleanup = c ?? undefined; },
+        ).catch((err) => { console.error('[WidgetRenderer] fallback async render failed:', err); });
+      } else {
+        currentCleanup = (result as (() => void) | undefined) ?? undefined;
+      }
     } catch (err) {
       console.error('[WidgetRenderer] fallback remount failed:', err);
     }
@@ -250,7 +323,7 @@
       description: `Update the data of ${type} widget (id: ${busId}).`,
       inputSchema: { type: 'object', properties: {}, additionalProperties: true },
       execute: (args: Record<string, unknown>) => {
-        oninteract?.(type, 'update', args);
+        oninteract?.(type, 'bus-update', args);
         return { content: [{ type: 'text', text: `widget_${busId} updated` }] };
       },
     });
@@ -260,7 +333,7 @@
       description: `Remove ${type} widget (id: ${busId}) from the view.`,
       inputSchema: { type: 'object', properties: {} },
       execute: () => {
-        oninteract?.(type, 'remove', {});
+        oninteract?.(type, 'bus-remove', {});
         return { content: [{ type: 'text', text: `widget_${busId} removed` }] };
       },
       annotations: { destructiveHint: true },
@@ -277,7 +350,9 @@
   });
 </script>
 
-{#if useVanilla}
+{#if isNativeCustomElement}
+  <div bind:this={ceContainer} class="ce-container w-full h-full overflow-auto p-2"></div>
+{:else if useVanilla}
   <div bind:this={vanillaContainer} class="vanilla-container w-full h-full overflow-auto p-2"></div>
 {:else if customRenderer}
   <svelte:component this={customRenderer as Component<any>} {data} {id} />

package/src/widgets/notebook/executors/index.ts

@@ -1,4 +1,3 @@
 export { createSqlExecutor } from './sql.js';
-export type { SqlExecutorOptions } from './sql.js';
 export { createJsExecutor } from './js-worker.js';
 export type { JsExecutorOptions } from './js-worker.js';

package/src/widgets/notebook/executors/sql.ts

@@ -1,206 +1,56 @@
-// @ts-nocheck
-/**
- * SQL executor for notebook cells.
- *
- * Finds a SQL-capable tool on the connected data servers via auto-pattern,
- * calls it via postMessage, parses the result into a `table` CellResult.
- */
-
 import { callToolViaPostMessage } from '@webmcp-auto-ui/core';
-import type { CellExecutor, CellExecContext, DataServerDescriptor } from '../shared.js';
-
-export interface SqlExecutorOptions {
-  /** Timeout per query (ms). Default 30000 */
-  timeoutMs?: number;
-  /** Max rows to keep in result (truncate beyond). Default 1000 */
-  maxRows?: number;
-}
+import type { CellExecutor, CellExecContext, CellResult, DataServerDescriptor } from '../shared.js';
 
 const PATTERN_PRIMARY = /^.*query_sql$/i;
 const PATTERN_FALLBACK = /^(query|run|execute)(_sql)?$/i;
 
 function findSqlTool(servers: DataServerDescriptor[]): string | null {
-  // Priority 1: *_query_sql or query_sql
-  for (const srv of servers) {
-    for (const t of srv.tools ?? []) {
-      if (PATTERN_PRIMARY.test(t.name)) return t.name;
-    }
-  }
-  // Priority 2: query / run / execute (with optional _sql)
-  for (const srv of servers) {
-    for (const t of srv.tools ?? []) {
-      if (PATTERN_FALLBACK.test(t.name)) return t.name;
+  for (const p of [PATTERN_PRIMARY, PATTERN_FALLBACK]) {
+    for (const srv of servers) {
+      for (const t of srv.tools ?? []) if (p.test(t.name)) return t.name;
     }
   }
   return null;
 }
 
-/**
- * Extract the first text content from an MCP tool result.
- */
-function extractText(result: any): string | null {
-  if (!result) return null;
-  const content = result.content ?? result;
-  if (!Array.isArray(content)) {
-    if (typeof content === 'string') return content;
-    return null;
-  }
-  for (const item of content) {
-    if (item && item.type === 'text' && typeof item.text === 'string') {
-      return item.text;
-    }
-  }
-  return null;
-}
-
-function tryParseJson(text: string): unknown {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text; // not JSON, return raw
-  }
-}
-
-export function createSqlExecutor(
-  getServers: () => DataServerDescriptor[],
-  opts?: SqlExecutorOptions
-): CellExecutor {
-  const timeoutMs = opts?.timeoutMs ?? 30_000;
-  const maxRows = opts?.maxRows ?? 1000;
-
-  return async (ctx: CellExecContext) => {
+export function createSqlExecutor(getServers: () => DataServerDescriptor[]): CellExecutor {
+  return async (ctx: CellExecContext): Promise<CellResult> => {
     const startedAt = Date.now();
-    const servers = getServers();
-
-    const toolName = findSqlTool(servers);
+    const toolName = findSqlTool(getServers());
     if (!toolName) {
-      return {
-        ok: false,
-        error: 'No SQL tool found on connected servers',
-        errorKind: 'schema',
-        durationMs: Date.now() - startedAt,
-      };
+      return { ok: false, error: 'No SQL tool available on connected servers.', errorKind: 'schema', durationMs: Date.now() - startedAt };
     }
-
     const sql = (ctx.cell.content ?? '').trim();
-    if (!sql) {
-      return { ok: true, kind: 'empty', durationMs: Date.now() - startedAt };
-    }
-
-    // Wrap the tool call with the cell's AbortSignal so an external abort
-    // rejects the promise even if callToolViaPostMessage doesn't support signals.
-    const callPromise = callToolViaPostMessage(toolName, { sql }, { timeout: timeoutMs });
+    if (!sql) return { ok: true, kind: 'empty', durationMs: Date.now() - startedAt };
 
-    let raceResult: any;
+    let raw: unknown;
     try {
-      raceResult = await new Promise((resolve, reject) => {
-        let settled = false;
-        const onAbort = () => {
-          if (settled) return;
-          settled = true;
-          reject(new Error('aborted'));
-        };
-        if (ctx.signal.aborted) {
-          onAbort();
-          return;
-        }
-        ctx.signal.addEventListener('abort', onAbort, { once: true });
-        callPromise.then(
-          (v) => {
-            if (settled) return;
-            settled = true;
-            ctx.signal.removeEventListener('abort', onAbort);
-            resolve(v);
-          },
-          (err) => {
-            if (settled) return;
-            settled = true;
-            ctx.signal.removeEventListener('abort', onAbort);
-            reject(err);
-          }
-        );
-      });
-    } catch (err: any) {
-      const durationMs = Date.now() - startedAt;
-      const msg = String(err?.message ?? err);
-      const isTimeout = /timed out|aborted/i.test(msg);
-      return {
-        ok: false,
-        error: msg,
-        errorKind: isTimeout ? 'timeout' : 'runtime',
-        durationMs,
-      };
+      raw = await callToolViaPostMessage(toolName, { sql });
+    } catch (err) {
+      return { ok: false, error: String((err as { message?: unknown })?.message ?? err), errorKind: 'runtime', durationMs: Date.now() - startedAt };
     }
-
     const durationMs = Date.now() - startedAt;
 
-    // Unwrap MCP content array → text → JSON.
-    const text = extractText(raceResult);
-    const parsed = text != null ? tryParseJson(text) : raceResult;
-
-    // Error shape returned inside the tool result
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && 'error' in (parsed as any) && (parsed as any).error) {
-      return {
-        ok: false,
-        error: String((parsed as any).error),
-        errorKind: 'runtime',
-        durationMs,
-      };
-    }
-
-    // {rows, columns} shape
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && Array.isArray((parsed as any).rows)) {
-      let rows: Record<string, unknown>[] = (parsed as any).rows;
-      const columns: string[] = Array.isArray((parsed as any).columns)
-        ? (parsed as any).columns
-        : rows.length > 0 && typeof rows[0] === 'object'
-          ? Object.keys(rows[0] as Record<string, unknown>)
-          : [];
-      let truncated = false;
-      if (rows.length > maxRows) {
-        rows = rows.slice(0, maxRows);
-        truncated = true;
-      }
-      return {
-        ok: true,
-        kind: 'table',
-        rows,
-        columns,
-        rowCount: (parsed as any).rows.length,
-        truncated: truncated || undefined,
-        durationMs,
-      };
+    const content = (raw as { content?: unknown })?.content;
+    const text = Array.isArray(content)
+      ? (content.find((c) => (c as { type?: unknown })?.type === 'text') as { text?: string } | undefined)?.text ?? ''
+      : '';
+    let parsed: unknown = text;
+    try { parsed = JSON.parse(text); } catch { /* not JSON */ }
+
+    if (!text) return { ok: true, kind: 'empty', durationMs };
+
+    const rows: unknown[] =
+      Array.isArray(parsed) ? parsed
+      : Array.isArray((parsed as { rows?: unknown })?.rows) ? (parsed as { rows: unknown[] }).rows
+      : [];
+    if (rows.length && rows.every((r) => r && typeof r === 'object')) {
+      const declared = (parsed as { columns?: unknown })?.columns;
+      const columns = Array.isArray(declared)
+        ? declared.map(String)
+        : Array.from(new Set(rows.flatMap((r) => Object.keys(r as Record<string, unknown>))));
+      return { ok: true, kind: 'table', rows: rows as Record<string, unknown>[], columns, rowCount: rows.length, durationMs };
     }
-
-    // Array of objects
-    if (Array.isArray(parsed)) {
-      if (parsed.length === 0) {
-        return { ok: true, kind: 'table', rows: [], columns: [], rowCount: 0, durationMs };
-      }
-      const first = parsed[0];
-      if (first && typeof first === 'object' && !Array.isArray(first)) {
-        let rows = parsed as Record<string, unknown>[];
-        const columns = Object.keys(first as Record<string, unknown>);
-        const rowCount = rows.length;
-        let truncated = false;
-        if (rows.length > maxRows) {
-          rows = rows.slice(0, maxRows);
-          truncated = true;
-        }
-        return {
-          ok: true,
-          kind: 'table',
-          rows,
-          columns,
-          rowCount,
-          truncated: truncated || undefined,
-          durationMs,
-        };
-      }
-      return { ok: true, kind: 'value', value: parsed, durationMs };
-    }
-
-    // Anything else — a scalar or object that isn't tabular
     return { ok: true, kind: 'value', value: parsed, durationMs };
   };
 }