@legionworks/facet 1.9.0

package/src/validation/tier1/frame-target.ts

@@ -0,0 +1,162 @@
+/**
+ * Resolve the opaque-origin `about:srcdoc` child frame the verifier
+ * probes. The parent page loads the host HTML which builds an iframe
+ * with `srcdoc` (the harness). The verifier needs the child frame's
+ * CDP frame ID to:
+ *
+ *   1. Create an isolated execution world BEFORE source ingress
+ *      (so the page shim cannot reach it).
+ *   2. Scope `DOMSnapshot.captureSnapshot` to that exact frame
+ *      (so the protocol data is independent of the parent page world).
+ *
+ * The parent page world (the iframe HOST) is untrusted for the same
+ * reason the page shim is — only the child frame's CDP-observed
+ * counts are the authority.
+ */
+
+import type { VerifierCdpSession } from "./browser-process";
+
+export interface ResolvedChildFrame {
+  readonly frameId: string;
+  readonly url: string;
+}
+
+/**
+ * Walk `Page.getFrameTree` and return the first child frame whose
+ * URL is `about:srcdoc` (or, when the harness loads via a `src=`
+ * URL, `about:blank` is the initial state — the verifier accepts
+ * either). Throws when no child frame matches — that is a
+ * verifier-side setup failure (the harness page never built the
+ * iframe), not a `tampered` verdict.
+ */
+export async function resolveSrcdocChildFrame(
+  session: VerifierCdpSession,
+): Promise<ResolvedChildFrame> {
+  const tree = (await session.send("Page.getFrameTree")) as {
+    frameTree: {
+      frame: { id: string; url: string };
+      childFrames?: { frame: { id: string; url: string } }[];
+    };
+  };
+  const children = tree.frameTree.childFrames ?? [];
+  for (const child of children) {
+    const url = child.frame.url;
+    if (url === "about:srcdoc" || url.startsWith("file://") || url === "about:blank") {
+      return { frameId: child.frame.id, url };
+    }
+  }
+  throw new Error("verifier: no about:srcdoc child frame resolved");
+}
+
+interface FrameTreeNode {
+  readonly frame: { readonly id: string; readonly url: string };
+  readonly childFrames?: readonly FrameTreeNode[];
+}
+
+interface ProtocolDomNode {
+  readonly nodeName?: string;
+  readonly backendNodeId?: number;
+  readonly attributes?: readonly string[];
+  readonly contentDocument?: ProtocolDomNode;
+  readonly children?: readonly ProtocolDomNode[];
+  readonly shadowRoots?: readonly ProtocolDomNode[];
+}
+
+function findFrameTreeNode(node: FrameTreeNode, frameId: string): FrameTreeNode | null {
+  if (node.frame.id === frameId) return node;
+  for (const child of node.childFrames ?? []) {
+    const found = findFrameTreeNode(child, frameId);
+    if (found !== null) return found;
+  }
+  return null;
+}
+
+function findContentDocument(node: ProtocolDomNode, backendNodeId: number): ProtocolDomNode | null {
+  if (node.backendNodeId === backendNodeId) return node.contentDocument ?? null;
+  for (const child of [
+    node.contentDocument,
+    ...(node.children ?? []),
+    ...(node.shadowRoots ?? []),
+  ]) {
+    if (child === undefined) continue;
+    const found = findContentDocument(child, backendNodeId);
+    if (found !== null) return found;
+  }
+  return null;
+}
+
+function hasDirectTsxMount(node: ProtocolDomNode): boolean {
+  const attributes = node.attributes ?? [];
+  for (let index = 0; index + 1 < attributes.length; index += 2) {
+    if (
+      node.nodeName === "MAIN" &&
+      attributes[index] === "id" &&
+      attributes[index + 1] === "facet-tsx-mount"
+    ) {
+      return true;
+    }
+  }
+  for (const child of [...(node.children ?? []), ...(node.shadowRoots ?? [])]) {
+    if (hasDirectTsxMount(child)) return true;
+  }
+  return false;
+}
+
+/**
+ * Resolve the interactive TSX artifact document under the outer harness child.
+ * The direct mount has no child frame; nested frames are resolved from their
+ * CDP-owned iframe element rather than frame order or about:srcdoc URLs.
+ */
+export async function resolveNestedArtifactFrame(
+  session: VerifierCdpSession,
+  outerFrame: ResolvedChildFrame,
+): Promise<ResolvedChildFrame> {
+  const tree = (await session.send("Page.getFrameTree")) as { readonly frameTree: FrameTreeNode };
+  const outerNode = findFrameTreeNode(tree.frameTree, outerFrame.frameId);
+  if (outerNode === null) {
+    throw new Error("verifier: outer child frame disappeared before nested TSX resolution");
+  }
+  const candidates = outerNode.childFrames ?? [];
+  const document = (await session.send("DOM.getDocument", { depth: -1, pierce: true })) as {
+    readonly root: ProtocolDomNode;
+  };
+  const outerOwner = (await session.send("DOM.getFrameOwner", { frameId: outerFrame.frameId })) as {
+    readonly backendNodeId: number;
+  };
+  const outerDocument = findContentDocument(document.root, outerOwner.backendNodeId);
+  if (outerDocument === null) {
+    throw new Error("verifier: outer child document unavailable for nested TSX resolution");
+  }
+  if (hasDirectTsxMount(outerDocument)) {
+    if (candidates.length === 0) return outerFrame;
+    throw new Error(
+      `verifier: direct TSX mount is ambiguous with ${candidates.length} nested frame(s)`,
+    );
+  }
+  // The direct mount is the ONLY interactive-TSX model (nested
+  // sandboxed frames were removed); its absence is a mount failure,
+  // not a nested-frame lookup problem.
+  throw new Error(
+    "verifier: direct TSX mount is missing — the artifact frame did not render its renderer-owned mount",
+  );
+}
+
+/**
+ * Create an isolated execution world on the resolved child frame.
+ * `grantUniveralAccess` is intentionally `false` — the isolated world
+ * is sandboxed to the same origin as the child frame (opaque / about:
+ * srcdoc), so it has no network or localStorage surface. The protocol
+ * data returned by `Runtime.evaluate` calls inside this world is what
+ * the verifier compares against the untrusted page shim.
+ */
+export async function createIsolatedWorld(
+  session: VerifierCdpSession,
+  frameId: string,
+): Promise<{ readonly executionContextId: number }> {
+  const result = (await session.send("Page.createIsolatedWorld", {
+    frameId,
+    worldName: "facet-tier1-probe",
+    grantUniveralAccess: false,
+  })) as { executionContextId: number };
+  return { executionContextId: result.executionContextId };
+}

package/src/validation/tier1/harness-entry.ts

@@ -0,0 +1,261 @@
+/**
+ * Verifier harness — runs INSIDE the opaque-origin iframe.
+ *
+ * Bundled by `harness.ts` and embedded into the iframe srcdoc under a
+ * per-build nonce. The CSP rejects any script that does not carry that
+ * nonce, so this bundle is the only executable code reachable inside
+ * the frame.
+ *
+ * Renderer pipeline:
+ *   1. Wire the `window.message` handshake (verifier transfers the
+ *      port2 ends via postMessage).
+ *   2. Emit `boot-ready` on the control port.
+ *   3. Receive the artifact on the ingress port (one-shot).
+ *   4. Dispatch through the renderer registry supplied by the paired
+ *      type-specific entry. Its renderer modules are build-checked
+ *      against the gallery entry, so the gate verifies the actual
+ *      user-visible render, not a stand-in.
+ *      `test-adversary` payloads run the matching scenario instead
+ *      (the monkeypatch / forge paths live here).
+ *   5. Emit `render-complete` with the page-shim counts describing
+ *      what the page world sees (renderer-owned roots, errors, …).
+ *
+ * The page shim counts through the page world's `querySelectorAll` ON
+ * PURPOSE: a hostile page can monkey-patch it and lie — the verdict
+ * layer detects that lie against the protocol authority.
+ */
+
+import {
+  appendRenderError,
+  countPageShim,
+  dispatchRender,
+  type RendererRegistry,
+} from "../../gallery-web/frame/renderers/registry";
+import type { Renderer } from "../../shared/contracts/renderers";
+import { isTsxExecutionMode, type TsxExecutionMode } from "../../shared/tsx/execution";
+import { validateRenderer } from "../../gallery-web/frame/renderer-validation";
+
+type ArtifactMode = "raw" | "render";
+
+type ControlEvent =
+  | { type: "boot-ready" }
+  | { type: "render-complete"; observed: ReturnType<typeof countPageShim>; mode: ArtifactMode };
+
+declare global {
+  interface Window {
+    __facetHarnessLoaded?: boolean;
+  }
+}
+
+const containerElement = document.getElementById("artifact");
+if (containerElement === null) {
+  throw new Error("harness: #artifact container missing");
+}
+const container: HTMLElement = containerElement;
+const nonce = container.getAttribute("data-facet-nonce") ?? "";
+
+let controlPost: ((event: ControlEvent) => void) | null = null;
+let handshakeComplete = false;
+
+function adversarialMonkeypatch(): void {
+  // Replace querySelectorAll so the page-shim's count diverges from
+  // the protocol truth. The verifier MUST detect this divergence.
+  Object.defineProperty(document, "querySelectorAll", {
+    value: function (selectors: string) {
+      if (selectors === "svg") {
+        return { length: 2 } as unknown as NodeListOf<Element>;
+      }
+      if (selectors === "[data-facet-error]") {
+        return { length: 0 } as unknown as NodeListOf<Element>;
+      }
+      return { length: 0 } as unknown as NodeListOf<Element>;
+    },
+    configurable: true,
+  });
+}
+
+function adversarialHtmlCountMonkeypatch(): void {
+  const original = document.querySelectorAll.bind(document);
+  Object.defineProperty(document, "querySelectorAll", {
+    value: function (selectors: string) {
+      if (selectors === '[data-facet-renderer-root="true"]') {
+        return { length: 0 } as unknown as NodeListOf<Element>;
+      }
+      return original(selectors);
+    },
+    configurable: true,
+  });
+}
+
+function appendAdversarialCanvas(): void {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1;
+  canvas.height = 1;
+  container.appendChild(canvas);
+}
+
+function adversarialCanvasCountMonkeypatch(): void {
+  const originalQuerySelectorAll = document.querySelectorAll.bind(document);
+  Object.defineProperty(document, "querySelectorAll", {
+    value: function (selectors: string) {
+      if (selectors === "*") return { length: 0 } as unknown as NodeListOf<Element>;
+      return originalQuerySelectorAll(selectors);
+    },
+    configurable: true,
+  });
+}
+
+async function renderAdversarialJson(payload: unknown): Promise<void> {
+  if (typeof payload !== "object" || payload === null) {
+    appendRenderError(container, "adversarial: payload is not an object");
+    return;
+  }
+  const record = payload as Record<string, unknown>;
+  if (record["type"] !== "test-adversary") {
+    appendRenderError(container, "adversarial: missing type=test-adversary");
+    return;
+  }
+  const name = typeof record["name"] === "string" ? (record["name"] as string) : "";
+  if (name === "hostile-monkeypatch") {
+    adversarialMonkeypatch();
+    appendRenderError(container, "forced facet-error for monkeypatch scenario");
+    return;
+  }
+  if (name === "hostile-canvas-smuggle") {
+    appendAdversarialCanvas();
+    return;
+  }
+  if (name === "hostile-canvas-monkeypatch") {
+    appendAdversarialCanvas();
+    adversarialCanvasCountMonkeypatch();
+    return;
+  }
+  if (name === "html-forged-marker") {
+    const source = typeof record["source"] === "string" ? record["source"] : "";
+    container.innerHTML = source;
+    adversarialHtmlCountMonkeypatch();
+    return;
+  }
+  if (name === "html-shim-divergence") {
+    container.innerHTML = '<div data-facet-renderer-root="true"><h1>Observed report</h1></div>';
+    adversarialHtmlCountMonkeypatch();
+    return;
+  }
+  const source = typeof record["source"] === "string" ? (record["source"] as string) : null;
+  if (source !== null) {
+    container.innerHTML = source;
+    return;
+  }
+  appendRenderError(container, `adversarial: unknown name=${name}`);
+}
+
+async function renderArtifact(
+  registry: RendererRegistry,
+  artifactBytes: Uint8Array,
+  mode: ArtifactMode,
+  artifactType: string,
+  renderer: Renderer,
+  execution: TsxExecutionMode | undefined,
+): Promise<void> {
+  if (mode === "raw") {
+    const text = new TextDecoder("utf-8", { fatal: false }).decode(artifactBytes);
+    container.innerHTML = text;
+    return;
+  }
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(artifactBytes);
+  try {
+    const parsed = JSON.parse(text);
+    if (
+      typeof parsed === "object" &&
+      parsed !== null &&
+      (parsed as { type?: unknown }).type === "test-adversary"
+    ) {
+      await renderAdversarialJson(parsed);
+      return;
+    }
+  } catch {
+    // not JSON — fall through to the typed renderer dispatch
+  }
+  await dispatchRender(
+    registry,
+    { container, nonce, theme: "dark" },
+    {
+      artifactType,
+      renderer,
+      bytes: artifactBytes,
+      theme: "dark",
+      ...(execution === undefined ? {} : { execution }),
+    },
+  );
+}
+
+export function startTier1Harness(registry: RendererRegistry): void {
+  (window as unknown as { facetHarnessLoaded?: boolean }).facetHarnessLoaded = true;
+  window.addEventListener(
+    "message",
+    (event) => {
+      if (handshakeComplete || event.source !== window.parent) return;
+      const data = (event as MessageEvent).data as {
+        facetHandshake?: string;
+        nonce?: string;
+      } | null;
+      if (data === null || data.facetHandshake !== "ports" || data.nonce !== nonce) return;
+      const ports = (event as MessageEvent).ports;
+      if (!Array.isArray(ports) || ports.length !== 2) return;
+      const ingress = ports[0];
+      const control = ports[1];
+      if (ingress === undefined || control === undefined) return;
+      handshakeComplete = true;
+      controlPost = control.postMessage.bind(control) as (event: ControlEvent) => void;
+      // MessagePort.onmessage is required over addEventListener("message"):
+      // per spec a MessagePort queues messages until start() is called, and
+      // only the onmessage setter starts the port implicitly — with
+      // addEventListener alone the handshake never fires (verified on the
+      // pinned shell build; addEventListener+start() would also work).
+      // oxlint-disable-next-line unicorn/prefer-add-event-listener
+      ingress.onmessage = async (sourceEvent: MessageEvent) => {
+        const payload = sourceEvent.data as
+          | {
+              bytes: string;
+              mode: ArtifactMode;
+              artifactType?: string;
+              renderer?: string;
+              execution?: TsxExecutionMode;
+            }
+          | undefined;
+        if (payload === undefined) return;
+        ingress.close();
+        const bytes = Uint8Array.from(atob(payload.bytes), (char) => char.charCodeAt(0));
+        try {
+          const renderer = validateRenderer(payload.renderer);
+          if (payload.execution !== undefined && !isTsxExecutionMode(payload.execution)) {
+            throw new Error("artifact payload has invalid execution");
+          }
+          await renderArtifact(
+            registry,
+            bytes,
+            payload.mode,
+            payload.artifactType ?? "markdown",
+            renderer,
+            payload.execution,
+          );
+        } catch (error) {
+          appendRenderError(container, error instanceof Error ? error.message : String(error));
+        }
+        // Counts cross the control port ONLY after the render settled.
+        const report = countPageShim();
+        try {
+          controlPost?.({ type: "render-complete", observed: report, mode: payload.mode });
+        } catch {
+          // control channel already torn down — drop silently.
+        }
+      };
+      try {
+        controlPost({ type: "boot-ready" });
+      } catch {
+        // ditto
+      }
+    },
+    { once: false },
+  );
+}

package/src/validation/tier1/harness.ts

@@ -0,0 +1,215 @@
+/**
+ * Verifier harness bundle — the in-frame rendering pipeline the
+ * Tier 1 verifier drives via the pre-armed probe sequence.
+ *
+ * The harness is intentionally NOT the gallery frame: the gallery
+ * frame renders for the operator's interactive use; this harness
+ * renders for the verifier's adversarial probes.
+ *
+ * Build pipeline:
+ *   1. Bundle the artifact type's entry as ESM via bun.build. Its paired
+ *      gallery entry imports the SAME renderer modules, enforced by the
+ *      build-metafile parity test. The result is inlined under the nonce,
+ *      with no sibling `<script src>` for the file:// CSP to reject.
+ *   2. Build the harness srcdoc with the bootstrap inlined under a
+ *      per-frame nonce.
+ *   3. The host page points its iframe at the harness srcdoc via
+ *      file://. The bootstrap is the only executable code; the
+ *      verifier renders artifacts through the shared renderers.
+ */
+
+import { build } from "bun";
+
+import { ARTIFACT_TYPES, type ArtifactType } from "../../gallery-web/frame/renderers/registry";
+import frameChromeStyles from "../../gallery-web/frame/styles/frame.css" with { type: "text" };
+import { freshHarnessNonce } from "./nonce";
+import { frameBundlePlugins } from "../../shared/build/frame-bundle-plugins";
+import { FROZEN_CSP_TEMPLATE as HARNESS_CSP } from "../../shared/security/frozen-csp";
+
+export { FROZEN_CSP_TEMPLATE as HARNESS_CSP } from "../../shared/security/frozen-csp";
+
+const HARNESS_ENTRY_DIR = `${import.meta.dir}/entries`;
+
+/**
+ * Build one type-specific harness browser bundle, inlined as ESM.
+ * Returns the bundled JS plus its byte
+ * length. The bundle is inlined into the srcdoc under the per-frame
+ * nonce — the file:// CSP problem that blocks sibling `<script src>`
+ * does not apply to nonce-carrying inline script, so the REAL
+ * mermaid/markdown/vega renderers run inside the verifier frame.
+ */
+function parseArtifactType(artifactType: string): ArtifactType {
+  if ((ARTIFACT_TYPES as readonly string[]).includes(artifactType)) {
+    return artifactType as ArtifactType;
+  }
+  throw new Error(`Tier 1 harness has no renderer bundle for artifact type '${artifactType}'`);
+}
+
+async function buildBootstrapBundleUncached(artifactType: ArtifactType): Promise<{
+  readonly code: string;
+  readonly styles: string;
+  readonly bytes: number;
+}> {
+  const result = await build({
+    entrypoints: [`${HARNESS_ENTRY_DIR}/${artifactType}.ts`],
+    target: "browser",
+    minify: false,
+    format: "esm",
+    plugins: frameBundlePlugins(),
+  });
+  if (!result.success) {
+    throw new Error(`harness bundle failed: ${result.logs.map((log) => log.message).join("\n")}`);
+  }
+  const outputs = result.outputs;
+  const output = outputs.find((candidate) => candidate.path.endsWith(".js"));
+  if (output === undefined) {
+    throw new Error("harness bundle produced no output");
+  }
+  const styles = await Promise.all(
+    outputs
+      .filter((candidate) => candidate.path.endsWith(".css"))
+      .map((candidate) => candidate.text()),
+  );
+  const code = await output.text();
+  const styleText = styles.join("\n");
+  return { code, styles: styleText, bytes: code.length + styleText.length };
+}
+
+const bundlePromises = new Map<
+  ArtifactType,
+  Promise<{ readonly code: string; readonly styles: string; readonly bytes: number }>
+>();
+
+/**
+ * Each type-specific bundle is a pure function of the source tree, so
+ * rebuilding it per verification buys nothing and
+ * puts a heavyweight bundler invocation on every run's critical path.
+ * The per-frame nonce is applied to the srcdoc, not the bundle, so
+ * sharing the bytes across runs is sound.
+ */
+function buildBootstrapBundle(
+  artifactType: ArtifactType,
+): Promise<{ readonly code: string; readonly styles: string; readonly bytes: number }> {
+  let bundlePromise = bundlePromises.get(artifactType);
+  if (bundlePromise === undefined) {
+    bundlePromise = buildBootstrapBundleUncached(artifactType).catch((error: unknown) => {
+      // A failed build must not poison the cache for later runs.
+      bundlePromises.delete(artifactType);
+      throw error;
+    });
+    bundlePromises.set(artifactType, bundlePromise);
+  }
+  return bundlePromise;
+}
+
+/**
+ * Build the harness srcdoc with the bundled bootstrap inlined under
+ * a per-frame nonce. The renderers live inside the bundle itself so
+ * no external script is loaded. The CSP `script-src` only needs
+ * `'nonce-<NONCE>'` because the artifact bytes are inserted via
+ * `innerHTML` inside the page world (not as executable script).
+ *
+ * The script tag is `type="module"` on purpose: Vega's bundled source
+ * declares `function addEventListener(...)` at the top level, and a
+ * classic `<script>` would hoist that into `window.addEventListener`,
+ * replacing the native one before the harness's own
+ * `window.addEventListener("message", ...)` listener could be
+ * registered. The module script keeps top-level function declarations
+ * in the module scope instead of the global one.
+ */
+export async function buildHarnessSrcdoc(artifactType: string): Promise<{
+  readonly srcdoc: string;
+  readonly nonce: string;
+  readonly bundleBytes: number;
+}> {
+  const rendererType = parseArtifactType(artifactType);
+  const nonce = freshHarnessNonce();
+  const { code, styles, bytes } = await buildBootstrapBundle(rendererType);
+  const escaped = code.replace(/<\/script/gi, "<\\/script");
+  const csp = HARNESS_CSP.replace("<BOOTSTRAP_NONCE>", nonce);
+  const srcdoc =
+    "<!doctype html><html><head>" +
+    `<meta charset="utf-8">` +
+    `<meta http-equiv="Content-Security-Policy" content="${csp}">` +
+    `<style>html,body,#artifact{margin:0;min-height:100%;background:transparent}</style>` +
+    `<style>${frameChromeStyles.replace(/<\/style/gi, "<\\/style")}</style>` +
+    (styles.length === 0 ? "" : `<style>${styles.replace(/<\/style/gi, "<\\/style")}</style>`) +
+    "</head><body>" +
+    `<main id="artifact" data-facet-nonce="${nonce}"></main>` +
+    `<script type="module" nonce="${nonce}">${escaped}</script>` +
+    "</body></html>";
+  return { srcdoc, nonce, bundleBytes: bytes };
+}
+
+/**
+ * Write the harness document to `hostDir` and build the host page that
+ * transfers the artifact and ports into the frame. The host iframe loads the
+ * generated file, matching the file-backed Tier 1 launch path; the declared
+ * type travels with ingress so the harness dispatches the gallery renderer.
+ */
+export interface HostPageInputs {
+  readonly html: string;
+  readonly harnessBytes: number;
+  readonly harnessPath: string;
+}
+
+export async function buildHostPage(
+  artifactBytes: Uint8Array,
+  artifactMode: "raw" | "render",
+  hostDir: string,
+  artifactType: string,
+  renderer = "svg",
+  execution: "static" | "interactive" = "static",
+): Promise<HostPageInputs> {
+  const { srcdoc, nonce, bundleBytes: harnessBytes } = await buildHarnessSrcdoc(artifactType);
+  const harnessPath = `${hostDir}/harness.html`;
+  await Bun.write(harnessPath, srcdoc);
+  const b64 = Buffer.from(artifactBytes).toString("base64");
+  const html =
+    "<!doctype html><html><head>" +
+    `<meta charset="utf-8">` +
+    "<title>facet-tier1-host</title>" +
+    "<style>html,body{margin:0;min-height:100%;}iframe{border:0;width:100%;height:100vh;}</style>" +
+    "</head><body>" +
+    `<main id="host-root"></main>` +
+    "<script>" +
+    "(function(){" +
+    "var artifactB64=" +
+    JSON.stringify(b64) +
+    ";" +
+    "var artifactMode=" +
+    JSON.stringify(artifactMode) +
+    ";" +
+    "var artifactType=" +
+    JSON.stringify(artifactType) +
+    ";" +
+    "var renderer=" +
+    JSON.stringify(renderer) +
+    ";" +
+    "var execution=" +
+    JSON.stringify(execution) +
+    ";" +
+    "var harnessPath=" +
+    JSON.stringify(harnessPath) +
+    ";" +
+    "var harnessNonce=" +
+    JSON.stringify(nonce) +
+    ";" +
+    "var ingress=new MessageChannel();" +
+    "var control=new MessageChannel();" +
+    "window.__facetShimEvents=[];" +
+    "control.port1.onmessage=function(ev){window.__facetShimEvents.push(ev.data);};" +
+    "var frame=document.createElement('iframe');" +
+    "frame.setAttribute('sandbox','allow-scripts');" +
+    "frame.referrerPolicy='no-referrer';" +
+    "frame.src=harnessPath;" +
+    "frame.addEventListener('load',function(){" +
+    "frame.contentWindow.postMessage({facetHandshake:'ports',nonce:harnessNonce},'*',[ingress.port2,control.port2]);" +
+    "});" +
+    "document.getElementById('host-root').appendChild(frame);" +
+    "window.__facetHostArtifact={bytes:artifactB64,mode:artifactMode,artifactType:artifactType,renderer:renderer,execution:execution,ingress:ingress.port1,control:control.port1};" +
+    "})();" +
+    "</script>" +
+    "</body></html>";
+  return { html, harnessBytes, harnessPath };
+}