@seed-ship/mcp-ui-solid 6.20.0 → 6.21.0

package/dist/utils/iframe-coep.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const solidJs = require("solid-js");
+const validation = require("../services/validation.cjs");
+function shouldSetCredentialless(url, config, options) {
+  const mode = config.iframeCredentialless;
+  if (mode === "always") return true;
+  if (mode === "never") return false;
+  if (!options.sandboxedWithoutSameOrigin) return false;
+  return !validation.isTrustedIframeDomain(url, {
+    customTrustedDomains: config.customTrustedIframeDomains
+  });
+}
+function createCrossOriginIsolated() {
+  const [isolated, setIsolated] = solidJs.createSignal(false);
+  solidJs.onMount(() => {
+    setIsolated(typeof window !== "undefined" && window.crossOriginIsolated === true);
+  });
+  return isolated;
+}
+function shouldShowIframeFallbackLink(config, crossOriginIsolated) {
+  const mode = config.iframeFallbackLink;
+  if (mode === "always") return true;
+  if (mode === "never") return false;
+  return crossOriginIsolated;
+}
+exports.createCrossOriginIsolated = createCrossOriginIsolated;
+exports.shouldSetCredentialless = shouldSetCredentialless;
+exports.shouldShowIframeFallbackLink = shouldShowIframeFallbackLink;
+//# sourceMappingURL=iframe-coep.cjs.map

package/dist/utils/iframe-coep.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe-coep.cjs","sources":["../../src/utils/iframe-coep.ts"],"sourcesContent":["/**\n * COEP helpers for the two iframes the library renders\n * (`IframeRenderer` in `UIResourceRenderer.tsx`, and the YouTube / Vimeo\n * embed in `VideoRenderer.tsx`).\n *\n * @since v6.21.0\n *\n * A host that serves `Cross-Origin-Embedder-Policy: credentialless` makes the\n * browser refuse any cross-origin iframe whose own document sends no COEP\n * header. The HTML attribute `credentialless` on the `<iframe>` lifts that,\n * at the price of the embedded document losing access to the cookies and\n * storage of its own origin — see `MCPUIConfigContext` for the policy.\n */\n\nimport { createSignal, onMount, type Accessor } from 'solid-js'\nimport { isTrustedIframeDomain } from '../services/validation'\nimport type { MCPUIConfig } from '../context/MCPUIConfigContext'\n\n/**\n * Does this iframe get the boolean `credentialless` attribute?\n *\n * `'auto'` (the default) says yes only when the embed has nothing to lose:\n * the host is not trusted AND the iframe already runs without cookies because\n * its `sandbox` has no `allow-same-origin` (`sandboxedWithoutSameOrigin`).\n * The video embed carries no sandbox, so in `'auto'` it keeps its provider\n * cookies and a COEP host must opt in with `'always'`.\n *\n * An unparsable URL is not trusted, so it gets the attribute.\n */\nexport function shouldSetCredentialless(\n  url: string,\n  config: MCPUIConfig,\n  options: { sandboxedWithoutSameOrigin: boolean }\n): boolean {\n  const mode = config.iframeCredentialless\n  if (mode === 'always') return true\n  if (mode === 'never') return false\n  if (!options.sandboxedWithoutSameOrigin) return false\n  return !isTrustedIframeDomain(url, {\n    customTrustedDomains: config.customTrustedIframeDomains,\n  })\n}\n\n/**\n * `window.crossOriginIsolated`, read **after mount** into a signal.\n *\n * Reading it during render would make the server emit markup the client\n * cannot reproduce; the signal starts at `false` (the SSR value) and flips\n * once mounted, so hydration always matches.\n */\nexport function createCrossOriginIsolated(): Accessor<boolean> {\n  const [isolated, setIsolated] = createSignal(false)\n  onMount(() => {\n    setIsolated(typeof window !== 'undefined' && window.crossOriginIsolated === true)\n  })\n  return isolated\n}\n\n/**\n * Does the \"open in a new tab\" link show under an embed?\n *\n * `'auto'` shows it only on a cross-origin-isolated page — exactly where COEP\n * can block the frame, and where the blocking is silent (a refused\n * cross-origin document fires no `error` event the parent can observe).\n */\nexport function shouldShowIframeFallbackLink(\n  config: MCPUIConfig,\n  crossOriginIsolated: boolean\n): boolean {\n  const mode = config.iframeFallbackLink\n  if (mode === 'always') return true\n  if (mode === 'never') return false\n  return crossOriginIsolated\n}\n"],"names":["isTrustedIframeDomain","createSignal","onMount"],"mappings":";;;;AA6BO,SAAS,wBACd,KACA,QACA,SACS;AACT,QAAM,OAAO,OAAO;AACpB,MAAI,SAAS,SAAU,QAAO;AAC9B,MAAI,SAAS,QAAS,QAAO;AAC7B,MAAI,CAAC,QAAQ,2BAA4B,QAAO;AAChD,SAAO,CAACA,WAAAA,sBAAsB,KAAK;AAAA,IACjC,sBAAsB,OAAO;AAAA,EAAA,CAC9B;AACH;AASO,SAAS,4BAA+C;AAC7D,QAAM,CAAC,UAAU,WAAW,IAAIC,QAAAA,aAAa,KAAK;AAClDC,UAAAA,QAAQ,MAAM;AACZ,gBAAY,OAAO,WAAW,eAAe,OAAO,wBAAwB,IAAI;AAAA,EAClF,CAAC;AACD,SAAO;AACT;AASO,SAAS,6BACd,QACA,qBACS;AACT,QAAM,OAAO,OAAO;AACpB,MAAI,SAAS,SAAU,QAAO;AAC9B,MAAI,SAAS,QAAS,QAAO;AAC7B,SAAO;AACT;;;;"}

package/dist/utils/iframe-coep.d.ts

@@ -0,0 +1,46 @@
+/**
+ * COEP helpers for the two iframes the library renders
+ * (`IframeRenderer` in `UIResourceRenderer.tsx`, and the YouTube / Vimeo
+ * embed in `VideoRenderer.tsx`).
+ *
+ * @since v6.21.0
+ *
+ * A host that serves `Cross-Origin-Embedder-Policy: credentialless` makes the
+ * browser refuse any cross-origin iframe whose own document sends no COEP
+ * header. The HTML attribute `credentialless` on the `<iframe>` lifts that,
+ * at the price of the embedded document losing access to the cookies and
+ * storage of its own origin — see `MCPUIConfigContext` for the policy.
+ */
+import { type Accessor } from 'solid-js';
+import type { MCPUIConfig } from '../context/MCPUIConfigContext';
+/**
+ * Does this iframe get the boolean `credentialless` attribute?
+ *
+ * `'auto'` (the default) says yes only when the embed has nothing to lose:
+ * the host is not trusted AND the iframe already runs without cookies because
+ * its `sandbox` has no `allow-same-origin` (`sandboxedWithoutSameOrigin`).
+ * The video embed carries no sandbox, so in `'auto'` it keeps its provider
+ * cookies and a COEP host must opt in with `'always'`.
+ *
+ * An unparsable URL is not trusted, so it gets the attribute.
+ */
+export declare function shouldSetCredentialless(url: string, config: MCPUIConfig, options: {
+    sandboxedWithoutSameOrigin: boolean;
+}): boolean;
+/**
+ * `window.crossOriginIsolated`, read **after mount** into a signal.
+ *
+ * Reading it during render would make the server emit markup the client
+ * cannot reproduce; the signal starts at `false` (the SSR value) and flips
+ * once mounted, so hydration always matches.
+ */
+export declare function createCrossOriginIsolated(): Accessor<boolean>;
+/**
+ * Does the "open in a new tab" link show under an embed?
+ *
+ * `'auto'` shows it only on a cross-origin-isolated page — exactly where COEP
+ * can block the frame, and where the blocking is silent (a refused
+ * cross-origin document fires no `error` event the parent can observe).
+ */
+export declare function shouldShowIframeFallbackLink(config: MCPUIConfig, crossOriginIsolated: boolean): boolean;
+//# sourceMappingURL=iframe-coep.d.ts.map

package/dist/utils/iframe-coep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe-coep.d.ts","sourceRoot":"","sources":["../../src/utils/iframe-coep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAEhE;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE;IAAE,0BAA0B,EAAE,OAAO,CAAA;CAAE,GAC/C,OAAO,CAQT;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAM7D;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,WAAW,EACnB,mBAAmB,EAAE,OAAO,GAC3B,OAAO,CAKT"}

package/dist/utils/iframe-coep.js

@@ -0,0 +1,30 @@
+import { createSignal, onMount } from "solid-js";
+import { isTrustedIframeDomain } from "../services/validation.js";
+function shouldSetCredentialless(url, config, options) {
+  const mode = config.iframeCredentialless;
+  if (mode === "always") return true;
+  if (mode === "never") return false;
+  if (!options.sandboxedWithoutSameOrigin) return false;
+  return !isTrustedIframeDomain(url, {
+    customTrustedDomains: config.customTrustedIframeDomains
+  });
+}
+function createCrossOriginIsolated() {
+  const [isolated, setIsolated] = createSignal(false);
+  onMount(() => {
+    setIsolated(typeof window !== "undefined" && window.crossOriginIsolated === true);
+  });
+  return isolated;
+}
+function shouldShowIframeFallbackLink(config, crossOriginIsolated) {
+  const mode = config.iframeFallbackLink;
+  if (mode === "always") return true;
+  if (mode === "never") return false;
+  return crossOriginIsolated;
+}
+export {
+  createCrossOriginIsolated,
+  shouldSetCredentialless,
+  shouldShowIframeFallbackLink
+};
+//# sourceMappingURL=iframe-coep.js.map

package/dist/utils/iframe-coep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe-coep.js","sources":["../../src/utils/iframe-coep.ts"],"sourcesContent":["/**\n * COEP helpers for the two iframes the library renders\n * (`IframeRenderer` in `UIResourceRenderer.tsx`, and the YouTube / Vimeo\n * embed in `VideoRenderer.tsx`).\n *\n * @since v6.21.0\n *\n * A host that serves `Cross-Origin-Embedder-Policy: credentialless` makes the\n * browser refuse any cross-origin iframe whose own document sends no COEP\n * header. The HTML attribute `credentialless` on the `<iframe>` lifts that,\n * at the price of the embedded document losing access to the cookies and\n * storage of its own origin — see `MCPUIConfigContext` for the policy.\n */\n\nimport { createSignal, onMount, type Accessor } from 'solid-js'\nimport { isTrustedIframeDomain } from '../services/validation'\nimport type { MCPUIConfig } from '../context/MCPUIConfigContext'\n\n/**\n * Does this iframe get the boolean `credentialless` attribute?\n *\n * `'auto'` (the default) says yes only when the embed has nothing to lose:\n * the host is not trusted AND the iframe already runs without cookies because\n * its `sandbox` has no `allow-same-origin` (`sandboxedWithoutSameOrigin`).\n * The video embed carries no sandbox, so in `'auto'` it keeps its provider\n * cookies and a COEP host must opt in with `'always'`.\n *\n * An unparsable URL is not trusted, so it gets the attribute.\n */\nexport function shouldSetCredentialless(\n  url: string,\n  config: MCPUIConfig,\n  options: { sandboxedWithoutSameOrigin: boolean }\n): boolean {\n  const mode = config.iframeCredentialless\n  if (mode === 'always') return true\n  if (mode === 'never') return false\n  if (!options.sandboxedWithoutSameOrigin) return false\n  return !isTrustedIframeDomain(url, {\n    customTrustedDomains: config.customTrustedIframeDomains,\n  })\n}\n\n/**\n * `window.crossOriginIsolated`, read **after mount** into a signal.\n *\n * Reading it during render would make the server emit markup the client\n * cannot reproduce; the signal starts at `false` (the SSR value) and flips\n * once mounted, so hydration always matches.\n */\nexport function createCrossOriginIsolated(): Accessor<boolean> {\n  const [isolated, setIsolated] = createSignal(false)\n  onMount(() => {\n    setIsolated(typeof window !== 'undefined' && window.crossOriginIsolated === true)\n  })\n  return isolated\n}\n\n/**\n * Does the \"open in a new tab\" link show under an embed?\n *\n * `'auto'` shows it only on a cross-origin-isolated page — exactly where COEP\n * can block the frame, and where the blocking is silent (a refused\n * cross-origin document fires no `error` event the parent can observe).\n */\nexport function shouldShowIframeFallbackLink(\n  config: MCPUIConfig,\n  crossOriginIsolated: boolean\n): boolean {\n  const mode = config.iframeFallbackLink\n  if (mode === 'always') return true\n  if (mode === 'never') return false\n  return crossOriginIsolated\n}\n"],"names":[],"mappings":";;AA6BO,SAAS,wBACd,KACA,QACA,SACS;AACT,QAAM,OAAO,OAAO;AACpB,MAAI,SAAS,SAAU,QAAO;AAC9B,MAAI,SAAS,QAAS,QAAO;AAC7B,MAAI,CAAC,QAAQ,2BAA4B,QAAO;AAChD,SAAO,CAAC,sBAAsB,KAAK;AAAA,IACjC,sBAAsB,OAAO;AAAA,EAAA,CAC9B;AACH;AASO,SAAS,4BAA+C;AAC7D,QAAM,CAAC,UAAU,WAAW,IAAI,aAAa,KAAK;AAClD,UAAQ,MAAM;AACZ,gBAAY,OAAO,WAAW,eAAe,OAAO,wBAAwB,IAAI;AAAA,EAClF,CAAC;AACD,SAAO;AACT;AASO,SAAS,6BACd,QACA,qBACS;AACT,QAAM,OAAO,OAAO;AACpB,MAAI,SAAS,SAAU,QAAO;AAC9B,MAAI,SAAS,QAAS,QAAO;AAC7B,SAAO;AACT;"}

package/dist/validation.cjs

@@ -3,6 +3,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const validation = require("./services/validation.cjs");
 exports.DEFAULT_RESOURCE_LIMITS = validation.DEFAULT_RESOURCE_LIMITS;
 exports.DEFAULT_VALIDATION_MESSAGES = validation.DEFAULT_VALIDATION_MESSAGES;
+exports.getIframeSandbox = validation.getIframeSandbox;
+exports.isTrustedIframeDomain = validation.isTrustedIframeDomain;
 exports.sanitizeString = validation.sanitizeString;
 exports.validateChartComponent = validation.validateChartComponent;
 exports.validateComponent = validation.validateComponent;

package/dist/validation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"validation.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"validation.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}

package/dist/validation.d.cts

@@ -9,7 +9,7 @@
  * import { validateLayout } from '@seed-ship/mcp-ui-solid/validation'
  * ```
  */
-export { validateComponent, validateLayout, validateGridPosition, validateChartComponent, validateTableComponent, validatePayloadSize, validateIframeDomain, sanitizeString, DEFAULT_RESOURCE_LIMITS, validateFieldValue, validateFormData, DEFAULT_VALIDATION_MESSAGES, } from './services/validation';
+export { validateComponent, validateLayout, validateGridPosition, validateChartComponent, validateTableComponent, validatePayloadSize, validateIframeDomain, getIframeSandbox, isTrustedIframeDomain, sanitizeString, DEFAULT_RESOURCE_LIMITS, validateFieldValue, validateFormData, DEFAULT_VALIDATION_MESSAGES, } from './services/validation';
 export type { FormValidationMessages } from './services/validation';
 export type { UIComponent, UILayout, GridPosition, ComponentType, ChartComponentParams, TableComponentParams, MetricComponentParams, TextComponentParams, ValidationResult, ResourceLimits, } from './types';
 //# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts

@@ -9,7 +9,7 @@
  * import { validateLayout } from '@seed-ship/mcp-ui-solid/validation'
  * ```
  */
-export { validateComponent, validateLayout, validateGridPosition, validateChartComponent, validateTableComponent, validatePayloadSize, validateIframeDomain, sanitizeString, DEFAULT_RESOURCE_LIMITS, validateFieldValue, validateFormData, DEFAULT_VALIDATION_MESSAGES, } from './services/validation';
+export { validateComponent, validateLayout, validateGridPosition, validateChartComponent, validateTableComponent, validatePayloadSize, validateIframeDomain, getIframeSandbox, isTrustedIframeDomain, sanitizeString, DEFAULT_RESOURCE_LIMITS, validateFieldValue, validateFormData, DEFAULT_VALIDATION_MESSAGES, } from './services/validation';
 export type { FormValidationMessages } from './services/validation';
 export type { UIComponent, UILayout, GridPosition, ComponentType, ChartComponentParams, TableComponentParams, MetricComponentParams, TextComponentParams, ValidationResult, ResourceLimits, } from './types';
 //# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,uBAAuB,EAEvB,kBAAkB,EAClB,gBAAgB,EAChB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,YAAY,EACV,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,GACf,MAAM,SAAS,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAGhB,qBAAqB,EACrB,cAAc,EACd,uBAAuB,EAEvB,kBAAkB,EAClB,gBAAgB,EAChB,2BAA2B,GAC5B,MAAM,uBAAuB,CAAA;AAC9B,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE,YAAY,EACV,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,GACf,MAAM,SAAS,CAAA"}

package/dist/validation.js

@@ -1,7 +1,9 @@
-import { DEFAULT_RESOURCE_LIMITS, DEFAULT_VALIDATION_MESSAGES, sanitizeString, validateChartComponent, validateComponent, validateFieldValue, validateFormData, validateGridPosition, validateIframeDomain, validateLayout, validatePayloadSize, validateTableComponent } from "./services/validation.js";
+import { DEFAULT_RESOURCE_LIMITS, DEFAULT_VALIDATION_MESSAGES, getIframeSandbox, isTrustedIframeDomain, sanitizeString, validateChartComponent, validateComponent, validateFieldValue, validateFormData, validateGridPosition, validateIframeDomain, validateLayout, validatePayloadSize, validateTableComponent } from "./services/validation.js";
 export {
   DEFAULT_RESOURCE_LIMITS,
   DEFAULT_VALIDATION_MESSAGES,
+  getIframeSandbox,
+  isTrustedIframeDomain,
   sanitizeString,
   validateChartComponent,
   validateComponent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seed-ship/mcp-ui-solid",
-  "version": "6.20.0",
+  "version": "6.21.0",
   "description": "SolidJS components for rendering MCP-generated UI resources",
   "type": "module",
   "files": [

package/src/components/IframeFallbackLink.tsx

@@ -0,0 +1,57 @@
+/**
+ * IframeFallbackLink — the way out of a silently blocked embed.
+ *
+ * @since v6.21.0
+ *
+ * An iframe refused by `Cross-Origin-Embedder-Policy` fires no event the
+ * parent page can observe (`onerror` does not fire for a rejected
+ * cross-origin document), so the user is left with a blank frame and no
+ * explanation. This link, rendered under the frame, always works.
+ *
+ * Visibility follows `MCPUIConfig.iframeFallbackLink`; `'auto'` (the default)
+ * shows it only on a cross-origin-isolated page. The URL goes through
+ * `safeUrl` — an unsafe one renders nothing at all.
+ */
+
+import { createMemo, Show, type JSX } from 'solid-js'
+import { safeUrl } from '../utils/safe-url'
+import { useMCPUIStrings } from '../context/MCPUIStringsContext'
+import { useMCPUIConfig } from '../context/MCPUIConfigContext'
+import {
+  createCrossOriginIsolated,
+  shouldShowIframeFallbackLink,
+} from '../utils/iframe-coep'
+
+export interface IframeFallbackLinkProps {
+  /** The embedded URL. Bound to `href` only when `safeUrl` accepts it. */
+  url: string
+  /** Extra classes on the wrapping `<div>`. */
+  class?: string
+}
+
+export function IframeFallbackLink(props: IframeFallbackLinkProps): JSX.Element {
+  const strings = useMCPUIStrings()
+  const config = useMCPUIConfig()
+  const crossOriginIsolated = createCrossOriginIsolated()
+
+  const href = createMemo(() => safeUrl(props.url))
+  const visible = createMemo(
+    () => !!href() && shouldShowIframeFallbackLink(config, crossOriginIsolated())
+  )
+
+  return (
+    <Show when={visible()}>
+      <div class={`px-4 py-2 text-right ${props.class || ''}`}>
+        <a
+          href={href()}
+          target="_blank"
+          rel="noopener noreferrer"
+          data-mcp-ui-action="open-external"
+          class="text-xs text-blue-600 dark:text-blue-400 hover:underline focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 rounded"
+        >
+          {strings.iframeOpenInNewTab}
+        </a>
+      </div>
+    </Show>
+  )
+}

package/src/components/UIResourceRenderer.tsx

@@ -10,7 +10,7 @@ import { escapeHtml } from '../utils/escape-html'
 import { safeUrl } from '../utils/safe-url'
 import { SafeHtml } from './SafeHtml'
 import type { UIComponent, UILayout, RendererError, TableVirtualizeOptions } from '../types'
-import { validateComponent, DEFAULT_RESOURCE_LIMITS, getIframeSandbox } from '../services/validation'
+import { validateComponent, DEFAULT_RESOURCE_LIMITS, getIframeSandbox, isTrustedIframeDomain } from '../services/validation'
 import { GenerativeUIErrorBoundary } from './GenerativeUIErrorBoundary'
 import { markRenderStart, markRenderEnd, PERF_PREFIX } from '../utils/perf'
 import { isDebugEnabled } from '../utils/logger'
@@ -27,6 +27,9 @@ import {
   formatMCPUIString,
   useMCPUIStrings,
 } from '../context/MCPUIStringsContext'
+import { useMCPUIConfig } from '../context/MCPUIConfigContext'
+import { shouldSetCredentialless } from '../utils/iframe-coep'
+import { IframeFallbackLink } from './IframeFallbackLink'
 
 /**
  * How `<UIResourceRenderer>` reacts when `validateComponent()` rejects a
@@ -1458,7 +1461,12 @@ function TextRenderer(props: { component: UIComponent }) {
  */
 function IframeRenderer(props: { component: UIComponent }) {
   const strings = useMCPUIStrings()
+  const config = useMCPUIConfig()
   const params = props.component.params as any
+  // v6.21.0 — the host's custom trusted hosts now reach BOTH the sandbox (they
+  // used not to: `getIframeSandbox(params.url)` was called with no options) and
+  // the `credentialless` decision.
+  const trustOptions = () => ({ customTrustedDomains: config.customTrustedIframeDomains })
   return (
     <div class="w-full h-full bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700 overflow-hidden flex flex-col">
       <Show when={params.title}>
@@ -1471,9 +1479,22 @@ function IframeRenderer(props: { component: UIComponent }) {
         title={params.title || strings.iframeTitle}
         class="w-full border-0 flex-1"
         style={`height: ${params.height || '400px'}; min-height: 300px;`}
-        sandbox={getIframeSandbox(params.url)}
+        sandbox={getIframeSandbox(params.url, trustOptions())}
+        // `attr:` is required: `credentialless` is in dom-expressions'
+        // `Properties` set, so a plain `credentialless={…}` compiles to a JS
+        // property assignment and never reaches the DOM as an attribute.
+        // `true | undefined` keeps it a BOOLEAN attribute — bare in SSR
+        // markup, removed (not `="false"`) when it does not apply.
+        attr:credentialless={
+          shouldSetCredentialless(params.url, config, {
+            // This iframe's sandbox never carries `allow-same-origin` for an
+            // untrusted host, so it already runs without cookies.
+            sandboxedWithoutSameOrigin: !isTrustedIframeDomain(params.url, trustOptions()),
+          }) || undefined
+        }
         loading="lazy"
       />
+      <IframeFallbackLink url={params.url} class="border-t border-gray-200 dark:border-gray-700" />
     </div>
   )
 }
@@ -1595,6 +1616,7 @@ function ComponentRenderer(props: {
   // opt in see zero behavior change.
   const telemetry = useTelemetry()
   const strings = useMCPUIStrings()
+  const componentConfig = useMCPUIConfig()
 
   onMount(() => {
     markRenderEnd(props.component.id)
@@ -1636,8 +1658,13 @@ function ComponentRenderer(props: {
     }
   })
 
-  // Validate component before rendering
-  const validation = validateComponent(props.component)
+  // Validate component before rendering. The host's allow-list extension
+  // (v6.21.0) has to reach validation too: an unlisted host is replaced by the
+  // validation card before any renderer runs.
+  const validation = validateComponent(props.component, {
+    iframePolicy: componentConfig.iframePolicy,
+    customIframeDomains: componentConfig.customIframeDomains,
+  })
   if (!validation.valid) {
     props.onError?.({
       type: 'validation',

package/src/components/VideoRenderer.tsx

@@ -9,6 +9,9 @@ import { Component, createMemo, Show } from 'solid-js'
 import type { UIComponent, VideoComponentParams } from '../types'
 import { ExpandableWrapper, useExpanded } from './ExpandableWrapper'
 import { useMCPUIStrings } from '../context/MCPUIStringsContext'
+import { useMCPUIConfig } from '../context/MCPUIConfigContext'
+import { shouldSetCredentialless } from '../utils/iframe-coep'
+import { IframeFallbackLink } from './IframeFallbackLink'
 
 export interface VideoRendererProps {
   /**
@@ -76,6 +79,7 @@ function parseVideoUrl(url: string): VideoInfo {
 
 export const VideoRenderer: Component<VideoRendererProps> = (props) => {
   const strings = useMCPUIStrings()
+  const config = useMCPUIConfig()
   const params = () => props.params || (props.component?.params as VideoComponentParams)
   const isExpanded = useExpanded()
 
@@ -181,11 +185,27 @@ export const VideoRenderer: Component<VideoRendererProps> = (props) => {
             class="absolute inset-0 w-full h-full"
             allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
             allowfullscreen
+            // v6.21.0 — youtube-nocookie / player.vimeo are not trusted hosts,
+            // so under COEP `credentialless` is what lets them load at all.
+            // `attr:` + `true | undefined` — see the note in `IframeRenderer`.
+            attr:credentialless={
+              // No sandbox here: a YouTube/Vimeo embed keeps its provider
+              // cookies, so `'auto'` leaves it alone and a COEP host opts in
+              // with `iframeCredentialless: 'always'`.
+              shouldSetCredentialless(embedUrl()!, config, {
+                sandboxedWithoutSameOrigin: false,
+              }) || undefined
+            }
             loading="lazy"
           />
         </Show>
       </div>
 
+      {/* v6.21.0 — a COEP-blocked embed is silent; this link is the way out. */}
+      <Show when={embedUrl()}>
+        <IframeFallbackLink url={params()?.url || ''} />
+      </Show>
+
       {/* Caption */}
       <Show when={params()?.caption}>
         <div class="px-4 py-3 border-t border-gray-200 dark:border-gray-700 flex-shrink-0">

package/src/context/MCPUIConfigContext.tsx

@@ -0,0 +1,151 @@
+/**
+ * MCPUIConfigContext — host-level rendering policy for the library's iframes.
+ *
+ * @since v6.21.0
+ *
+ * ## Why
+ *
+ * A host that serves `Cross-Origin-Embedder-Policy: credentialless` makes the
+ * browser refuse every cross-origin iframe whose own document does not send a
+ * COEP header — which is YouTube, Vimeo, Google Docs, Notion and nearly all of
+ * `DEFAULT_IFRAME_DOMAINS`. The escape hatch is the boolean HTML attribute
+ * `credentialless` on the `<iframe>` itself: the document then loads, but
+ * without access to the cookies and storage of its own origin.
+ *
+ * That trade-off is free for a public video or chart and fatal for an
+ * authenticated embed, so the library keys it on the distinction it already
+ * makes: `TRUSTED_IFRAME_DOMAINS` (the hosts that receive `allow-same-origin`
+ * because they need their own cookies) do NOT get the attribute; everything
+ * else does. This context lets a host override that, add its own trusted
+ * hosts, and control the "open in a new tab" fallback link.
+ *
+ * ## Scope — policy only, NOT strings
+ *
+ * Text lives in `MCPUIStrings` (`MCPUIStringsContext`). This context carries
+ * only behavioural switches, and like the strings context every renderer works
+ * standalone: with no provider mounted, `DEFAULT_MCPUI_CONFIG` applies.
+ *
+ * @example
+ * ```tsx
+ * import { MCPUIConfigProvider } from '@seed-ship/mcp-ui-solid'
+ *
+ * <MCPUIConfigProvider config={{ customTrustedIframeDomains: ['embed.acme.com'] }}>
+ *   <App />
+ * </MCPUIConfigProvider>
+ * ```
+ */
+
+import { createContext, mergeProps, useContext, type JSX } from 'solid-js'
+import type { IframePolicy } from '../types'
+
+/**
+ * Host-level rendering policy. Every field has a default — a provider passes
+ * a partial override.
+ */
+export interface MCPUIConfig {
+  /**
+   * When the library puts the boolean `credentialless` attribute on an
+   * `<iframe>` it renders.
+   *
+   * - `'auto'` (default) — on every iframe whose host is NOT in
+   *   `TRUSTED_IFRAME_DOMAINS` (plus `customTrustedIframeDomains`). Those
+   *   hosts already ran without cookies, since their sandbox has no
+   *   `allow-same-origin`; the attribute is what unblocks them under COEP.
+   * - `'always'` — on every iframe, trusted hosts included. An authenticated
+   *   embed will then render its login screen.
+   * - `'never'` — never. The right value for a host that sends no COEP header
+   *   and does not want its embeds to lose their cookies.
+   *
+   * Chrome/Edge 110+ honour the attribute; Firefox ignores it (iframes stay
+   * blocked while the host sends COEP); Safari ignores the COEP value itself,
+   * so nothing is blocked there in the first place.
+   */
+  iframeCredentialless: 'auto' | 'always' | 'never'
+
+  /**
+   * Extra hosts treated as trusted, on top of `TRUSTED_IFRAME_DOMAINS`:
+   * no `credentialless` attribute, and `allow-same-origin` in the sandbox.
+   * A subdomain of a listed host matches too.
+   *
+   * This only RECLASSIFIES a host the allow-list already accepts. To render an
+   * iframe whose host is outside `DEFAULT_IFRAME_DOMAINS`, add it to
+   * {@link MCPUIConfig.customIframeDomains} with `iframePolicy: 'extend'`.
+   */
+  customTrustedIframeDomains: string[]
+
+  /**
+   * How `UIResourceRenderer` validates an `iframe` component's host:
+   * `'strict'` (default) accepts `DEFAULT_IFRAME_DOMAINS` only, `'extend'`
+   * also accepts {@link MCPUIConfig.customIframeDomains}.
+   */
+  iframePolicy: IframePolicy
+
+  /**
+   * Extra hosts the allow-list accepts when `iframePolicy` is `'extend'`.
+   * Without this, a component pointing at an unlisted host is replaced by the
+   * validation card before any renderer runs.
+   */
+  customIframeDomains: string[]
+
+  /**
+   * When the library renders an "open in a new tab" link under an embed
+   * (`strings.iframeOpenInNewTab`).
+   *
+   * A COEP-blocked iframe fires no event the parent page can observe, so
+   * without this the user sees an unexplained blank frame.
+   *
+   * - `'auto'` (default) — only when the page is cross-origin isolated
+   *   (`window.crossOriginIsolated`). That flag needs COOP `same-origin` AND
+   *   COEP, so a host that sends COEP alone still blocks embeds while the
+   *   flag is false: set `'always'` there. Read after mount, never during
+   *   render, so SSR markup and hydration agree.
+   * - `'always'` / `'never'` — unconditional.
+   */
+  iframeFallbackLink: 'auto' | 'always' | 'never'
+}
+
+/**
+ * Defaults. Chosen so a host that sends no COEP header sees no change from
+ * 6.20.0 apart from the fallback link, which `'auto'` keeps hidden there.
+ */
+export const DEFAULT_MCPUI_CONFIG: MCPUIConfig = {
+  iframeCredentialless: 'auto',
+  customTrustedIframeDomains: [],
+  iframePolicy: 'strict',
+  customIframeDomains: [],
+  iframeFallbackLink: 'auto',
+}
+
+export const MCPUIConfigContext = createContext<MCPUIConfig>(DEFAULT_MCPUI_CONFIG)
+
+/**
+ * Reads the active host config. Returns `DEFAULT_MCPUI_CONFIG` when no
+ * `<MCPUIConfigProvider>` is mounted above.
+ */
+export function useMCPUIConfig(): MCPUIConfig {
+  return mergeProps(DEFAULT_MCPUI_CONFIG, useContext(MCPUIConfigContext))
+}
+
+export interface MCPUIConfigProviderProps {
+  /**
+   * Partial override of the host config. Any key left unset falls back to
+   * `DEFAULT_MCPUI_CONFIG`.
+   */
+  config?: Partial<MCPUIConfig>
+  children: JSX.Element
+}
+
+/**
+ * Provides the host config to every MCP-UI renderer below it.
+ * Merges the partial `config` override over the defaults.
+ */
+export function MCPUIConfigProvider(props: MCPUIConfigProviderProps): JSX.Element {
+  // The function source keeps replacement `config` objects reactive while
+  // mergeProps fills any omitted key without taking a one-time snapshot.
+  const value = mergeProps(DEFAULT_MCPUI_CONFIG, () => props.config)
+  return (
+    <MCPUIConfigContext.Provider value={value}>
+      {props.children}
+    </MCPUIConfigContext.Provider>
+  )
+}

package/src/context/MCPUIStringsContext.tsx

@@ -323,6 +323,13 @@ export interface MCPUIStrings {
   imageViewFullSize?: string
   /** Fallback `title` of an iframe without one. */
   iframeTitle?: string
+  /**
+   * Label of the "open in a new tab" link rendered under an embed
+   * (`IframeRenderer`, `VideoRenderer`). A COEP-blocked iframe fires no
+   * observable event, so this link is the only way out of a blank frame.
+   * @since 6.21.0
+   */
+  iframeOpenInNewTab?: string
   /** Fallback label of a link component without one. */
   linkLabel?: string
   /**
@@ -1085,6 +1092,9 @@ export const DEFAULT_MCPUI_STRINGS: Required<MCPUIStrings> = {
   sizeBytes: '{size} B',
   sizeKilobytes: '{size} KB',
   sizeMegabytes: '{size} MB',
+
+  // ── 6.21.0 — iframe COEP fallback ──────────────────────────
+  iframeOpenInNewTab: 'Open in a new tab',
 }
 
 /**

package/src/index.ts

@@ -142,6 +142,18 @@ export type {
   MCPUIStringsProviderProps,
 } from './context/MCPUIStringsContext'
 
+// Host rendering policy — iframe `credentialless` / COEP (v6.21.0)
+export {
+  MCPUIConfigProvider,
+  MCPUIConfigContext,
+  useMCPUIConfig,
+  DEFAULT_MCPUI_CONFIG,
+} from './context/MCPUIConfigContext'
+export type {
+  MCPUIConfig,
+  MCPUIConfigProviderProps,
+} from './context/MCPUIConfigContext'
+
 // Telemetry sink (B.5 — v5.6.0)
 export {
   MCPUITelemetryProvider,
@@ -331,6 +343,9 @@ export {
   validateLayout,
   validateIframeDomain,
   getIframeSandbox,
+  // v6.21.0 — the trusted-host test behind `getIframeSandbox` and the
+  // `credentialless` iframe attribute.
+  isTrustedIframeDomain,
   DEFAULT_RESOURCE_LIMITS,
   DEFAULT_IFRAME_DOMAINS,
   TRUSTED_IFRAME_DOMAINS,

package/src/services/index.ts

@@ -9,6 +9,7 @@ export {
   validateLayout,
   validateIframeDomain,
   getIframeSandbox,
+  isTrustedIframeDomain,
   DEFAULT_RESOURCE_LIMITS,
   DEFAULT_IFRAME_DOMAINS,
   TRUSTED_IFRAME_DOMAINS,