168 lines · 7.2 KB · TypeScript
RawDownload
/** * 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<string, unknown>; // --------------------------------------------------------------------------// 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<never> => new Promise<never>(() => {}); /** 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<SmokeRenderResult> => {  // 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<string> =>  JSON.stringify(await render(code));

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t