@seed-ship/mcp-ui-solid 6.14.0 → 6.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seed-ship/mcp-ui-solid",
-  "version": "6.14.0",
+  "version": "6.15.0",
   "description": "SolidJS components for rendering MCP-generated UI resources",
   "type": "module",
   "main": "./dist/index.cjs",

package/src/components/UIResourceRenderer.tsx

@@ -1478,6 +1478,14 @@ function ComponentRenderer(props: {
     const mode: ValidationErrorMode = props.errorMode ?? 'block'
     const firstError = validation.errors?.[0]?.message || 'Unknown validation error'
 
+    // P1.6 — an UNKNOWN component type must never produce a silent blank,
+    // whatever the errorMode. The renderer has no branch for it, so even
+    // `silent` would otherwise render nothing. Always surface a visible
+    // "Unsupported component type" notice + a render:error telemetry signal.
+    if (validation.errors?.some((e) => e.code === 'UNKNOWN_COMPONENT_TYPE')) {
+      return <UnsupportedComponentFallback component={props.component} />
+    }
+
     if (mode === 'silent') {
       return null
     }
@@ -1586,10 +1594,37 @@ function ComponentRenderer(props: {
       <Show when={props.component.type === 'graph'}>
         <GraphRenderer component={props.component} toolbarVariant={props.toolbarVariant} />
       </Show>
+      {/* P1.6 — `footer` is a valid type with a real renderer but had no
+          dispatch branch, so a standalone footer component rendered a silent
+          blank (it was only auto-injected at the layout level). */}
+      <Show when={props.component.type === 'footer'}>
+        <FooterRenderer params={props.component.params as any} />
+      </Show>
     </GenerativeUIErrorBoundary>
   )
 }
 
+/**
+ * Visible fallback for a component whose `type` is not recognized (audit P1.6).
+ *
+ * An unknown type has no renderer branch, so without this it would render a
+ * **silent blank** — even under `errorMode: 'silent'`. The validation gate
+ * routes unknown types here regardless of mode, so the user always sees an
+ * "Unsupported component type: X" notice. The telemetry signal is emitted by
+ * the gate itself (`validation:failed` with `firstErrorCode:
+ * 'UNKNOWN_COMPONENT_TYPE'`), so this component stays purely presentational.
+ */
+function UnsupportedComponentFallback(props: { component: UIComponent }) {
+  return (
+    <div
+      role="alert"
+      class="w-full rounded-lg border border-amber-300 bg-amber-50 px-3 py-2 text-sm text-amber-800 dark:border-amber-700/50 dark:bg-amber-900/20 dark:text-amber-200"
+    >
+      Unsupported component type: <code class="font-mono">{props.component.type}</code>
+    </div>
+  )
+}
+
 /**
  * Render an action component (button or link)
  * Refactored in Phase 5.0 to use useAction hook for Context-based execution

package/src/components/UnsupportedComponent.test.tsx

@@ -0,0 +1,77 @@
+/**
+ * v6.15.0 — audit P1.6: a component that reaches the renderer with a type that
+ * has no render branch must never produce a silent blank.
+ *
+ * `errorMode: 'silent'` lets a payload past the validation gate without an
+ * error card, so a bogus / known-but-unrendered type would otherwise render
+ * nothing. We assert the visible "Unsupported component type" notice instead,
+ * and that a real type (`footer`, previously missing a branch) now renders.
+ */
+import { describe, it, expect, afterEach } from 'vitest'
+import { render, cleanup, waitFor } from '@solidjs/testing-library'
+import { UIResourceRenderer } from './UIResourceRenderer'
+import { MCPUITelemetryProvider } from '../context/MCPUITelemetryContext'
+import type { UIComponent } from '../types'
+
+afterEach(cleanup)
+
+const bogus = {
+  id: 'x1',
+  type: 'totally-made-up' as any,
+  position: { colStart: 1, colSpan: 12 },
+  params: {},
+} satisfies UIComponent
+
+describe('Unsupported component never renders blank (P1.6)', () => {
+  it('shows a visible "Unsupported component type" notice', async () => {
+    // errorMode: 'silent' skips the validation error card, so the bogus type
+    // reaches the render dispatch — the catch-all must still surface it.
+    const { container } = render(() => (
+      <UIResourceRenderer content={bogus} errorMode="silent" />
+    ))
+
+    await waitFor(() => {
+      expect(container.textContent ?? '').toContain('Unsupported component type')
+    })
+    expect(container.textContent).toContain('totally-made-up')
+  })
+
+  it('emits a validation:failed telemetry signal for the unsupported type', async () => {
+    const events: Array<{ type: string; errorMessage?: string }> = []
+    render(() => (
+      <MCPUITelemetryProvider
+        sink={(batch) => events.push(...batch)}
+        options={{ bufferMs: 0 }}
+      >
+        <UIResourceRenderer content={bogus} errorMode="silent" />
+      </MCPUITelemetryProvider>
+    ))
+
+    // The validation gate emits `validation:failed` with the precise
+    // `UNKNOWN_COMPONENT_TYPE` code — the privacy-safe drift signal hosts watch.
+    await waitFor(() => {
+      expect(
+        events.some(
+          (e: any) =>
+            e.type === 'validation:failed' && e.firstErrorCode === 'UNKNOWN_COMPONENT_TYPE'
+        )
+      ).toBe(true)
+    })
+  })
+
+  it('renders a standalone footer component (previously a silent blank)', async () => {
+    const footer: UIComponent = {
+      id: 'f1',
+      type: 'footer',
+      position: { colStart: 1, colSpan: 12 },
+      params: { poweredBy: 'Deposium', sourceCount: 3 } as any,
+    }
+    const { container } = render(() => <UIResourceRenderer content={footer} />)
+
+    await waitFor(() => {
+      expect(container.textContent ?? '').toContain('Deposium')
+    })
+    // Not the unsupported notice — footer is a real renderer now.
+    expect(container.textContent).not.toContain('Unsupported component type')
+  })
+})