/** * The artifact smoke render, as it runs INSIDE the sandbox. * * This module is never imported by a host. It is bundled (React, the component * barrel, the tools proxy and all) into one self-contained script by * `bundleSmokeHarness`, and that script is what the QuickJS sandbox evaluates. * Nothing here runs in the trusted server process — which is the entire point, * since the code it renders was written by a model. * * The contract with the host is one global function and a JSON-shaped result: * `__executorSmokeRender(code)` resolves to `SmokeRenderResult`. It never * rejects; a render throw is a value, not an exception, so the host never has * to distinguish "the artifact is broken" from "the sandbox is broken". * * ## Host primitives QuickJS does not have * * `./smoke-harness-shims` supplies the few React's server renderer needs and * QuickJS lacks. It is imported first and for its side effects only: a bundler * initialises imports in order and before the importing module's own * statements, so that import is what guarantees the shims exist by the time * react-dom's module scope runs. */ // MUST be first: installs MessageChannel/TextEncoder/ReadableStream before // react-dom's module scope reaches for them. import "./smoke-harness-shims"; import { StrictMode, createElement } from "react"; import { renderToReadableStream } from "react-dom/server.browser"; import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; import { compileJsx, evaluateComponent } from "./component-runtime"; import * as Components from "./components"; import { createToolsProxy } from "./tools-proxy"; import type { SmokeRenderResult } from "./smoke-render-result"; /** The sandbox global, as a bag of names — the entry point is installed on it * for the host to call. Same reasoning as in `./smoke-harness-shims`. */ const sandboxGlobal = globalThis as unknown as Record; // -------------------------------------------------------------------------- // The render itself. Mirrors the inner renderer's provider stack exactly, so a // component that renders here renders in the frame. // -------------------------------------------------------------------------- /** The QueryClient the inner renderer builds, to the same defaults. */ const makeQueryClient = (): QueryClient => new QueryClient({ defaultOptions: { queries: { retry: false, refetchOnWindowFocus: false }, mutations: { retry: false }, }, }); /** * A transport whose promise never settles. * * Not a rejection and not a canned value: a rejection would put every query * into its error branch (so the smoke render would only ever exercise the error * path, and a component with no error handling would look broken when it is * not), and a canned value would be a data-shape guess. Pending is the honest * answer — nothing was fetched — and it is the state the real frame is in for * the first paint. */ const neverSettles = (): Promise => new Promise(() => {}); /** React 19 passes `{ componentStack }` as the second argument to `onError`. */ type RenderErrorInfo = { readonly componentStack?: string }; /** * How much markup may come back out of the sandbox. * * The stream is drained regardless — that is how a late child's throw is * observed — so this caps only what is KEPT and carried across the boundary. * A loading-state render of an ordinary artifact is a few kilobytes; anything * past this is a component that inlined something enormous, and the honest * answer there is no preview rather than a row nobody can load. Collection * stops at the cap, so a pathological render costs bounded memory too. */ const MARKUP_LIMIT_BYTES = 128 * 1024; const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error); const render = async (code: string): Promise => { // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: this function's whole purpose is turning a render throw into a value try { const compiled = compileJsx(code); const evaluated = evaluateComponent(compiled, createToolsProxy(neverSettles)); if ("error" in evaluated) return { status: "failed", message: evaluated.error }; // React reports the throw through `onError` (which is where the component // stack lives) AND rejects the stream. The handler captures the FIRST // error, since a shell error boundary would have caught it there too. let failure: { message: string; componentStack?: string } | undefined; const tree = createElement( StrictMode, null, createElement( Components.TooltipProvider, null, createElement( QueryClientProvider, { client: makeQueryClient() }, createElement(evaluated.component), ), ), ); // The drained chunks, kept up to the cap. Draining is still what drives the // render to completion so a throw in a late child is observed; keeping the // bytes is what turns that same pass into the gallery's preview. const decoder = new TextDecoder(); let markup = ""; let truncated = false; // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: same reason, for the render itself try { const stream = await renderToReadableStream(tree, { onError: (error: unknown, info: RenderErrorInfo) => { failure ??= { message: messageOf(error), ...(info.componentStack === undefined ? {} : { componentStack: info.componentStack }), }; }, }); const reader = (stream as unknown as ReadableStream).getReader(); for (;;) { const { done, value } = await reader.read(); if (done) break; if (truncated) continue; markup += typeof value === "string" ? value : decoder.decode(value as unknown as Uint8Array); // Past the cap the markup is unusable as a whole — a partial DOM tree // is not a preview — so stop keeping it and let the drain finish. if (markup.length > MARKUP_LIMIT_BYTES) { truncated = true; markup = ""; } } } catch { // The stream's own rejection carries no component stack, so `onError`'s // record is preferred. if (failure) return { status: "failed", ...failure }; return { status: "ok" }; } if (failure) return { status: "failed", ...failure }; // An empty render is `ok` with no markup: nothing to preview, and the // caller must not read "" as "this artifact renders blank on purpose". return markup === "" ? { status: "ok" } : { status: "ok", markup }; } catch (error) { // A throw from `compileJsx` or `evaluateComponent` — a syntax error, or // generated code that blew up at module scope. Same class, same answer. return { status: "failed", message: messageOf(error) }; } }; /** * The sandbox's entry point, named for the host that calls it. * * Returns a JSON string rather than an object: the host reads the result out of * QuickJS across a boundary that only carries primitives, and a string keeps * that transfer explicit at both ends. */ sandboxGlobal["__executorSmokeRender"] = async (code: string): Promise => JSON.stringify(await render(code));