blume 2.0.1 → 2.0.2

package/src/ai/mcp/server.ts

@@ -2,7 +2,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import type { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import {
-  CallToolRequestSchema,
+  ErrorCode,
   ListResourcesRequestSchema,
   ListToolsRequestSchema,
   McpError,
@@ -11,6 +11,7 @@ import {
 import { z } from "zod";
 
 import { withBasePath } from "../../core/base-path.ts";
+import { readCappedText } from "../../core/request-body.ts";
 import type { McpData } from "./data.ts";
 import {
   createIndexProvider,
@@ -42,6 +43,12 @@ const RESOURCE_MIME_TYPE = "text/markdown";
 const RESOURCE_NOT_FOUND = -32_002;
 /** URI scheme for page resources when no `deployment.site` is configured. */
 const LOCAL_RESOURCE_SCHEME = "blume:";
+/**
+ * The largest request body the HTTP endpoint reads. A JSON-RPC call to these
+ * tools is a few hundred bytes; the cap keeps one oversized POST from being
+ * buffered whole, as the assistant route's does.
+ */
+const MCP_BODY_LIMIT_BYTES = 65_536;
 
 const CORS_HEADERS = {
   "Access-Control-Allow-Headers":
@@ -108,6 +115,20 @@ const resourceRoute = (uri: string, data: McpData): string =>
     data
   );
 
+/**
+ * The `tools/call` params, as far as the server reads them before dispatch:
+ * each tool validates its own `arguments` against `TOOL_INPUTS`.
+ */
+const TOOL_CALL_PARAMS = z.object({
+  arguments: z.record(z.string(), z.unknown()).optional(),
+  name: z.string(),
+});
+
+/** A tool call's `arguments` object, before the tool's own validation. */
+type ToolArguments = NonNullable<
+  z.output<typeof TOOL_CALL_PARAMS>["arguments"]
+>;
+
 /** A tool call's text result, marked as an error when `isError` is set. */
 const text = (value: string, isError = false) => {
   const content = [{ text: value, type: "text" as const }];
@@ -165,9 +186,7 @@ export const buildServer = (
     };
   });
 
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { arguments: args = {}, name } = request.params;
-
+  const callTool = async (name: string, args: ToolArguments) => {
     if (name === "search_docs") {
       const results = await searchDocs(
         data,
@@ -206,12 +225,44 @@ export const buildServer = (
       return text(JSON.stringify(result.navigation, null, 2));
     }
 
-    return text(`Unknown tool: ${name}`, true);
-  });
+    // The MCP spec answers an unknown tool with a protocol error, not a
+    // failed tool result.
+    throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${name}`);
+  };
+
+  // `tools/call` goes through the fallback handler rather than a registered
+  // one: the SDK parses a registered handler's request against its own
+  // schema first and reports a malformed call (`arguments` that aren't an
+  // object) as -32603 Internal error carrying a raw Zod dump. Reading the
+  // params here answers it as -32602 Invalid params with a short message.
+  server.fallbackRequestHandler = async (request) => {
+    if (request.method !== "tools/call") {
+      throw new McpError(ErrorCode.MethodNotFound, "Method not found");
+    }
+    const params = TOOL_CALL_PARAMS.safeParse(request.params);
+    if (!params.success) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        "Invalid tools/call params: `name` must be a string and `arguments`, when given, an object."
+      );
+    }
+    return await callTool(params.data.name, params.data.arguments ?? {});
+  };
 
   return server;
 };
 
+/** A JSON-RPC error response the transport would send, for errors raised before it runs. */
+const jsonRpcError = (
+  status: number,
+  code: number,
+  message: string
+): Response =>
+  Response.json(
+    { error: { code, message }, id: null, jsonrpc: "2.0" },
+    { headers: CORS_HEADERS, status }
+  );
+
 /**
  * Build a stateless Streamable-HTTP MCP request handler from a data snapshot.
  *
@@ -239,6 +290,26 @@ export const createMcpFetchHandler = (
       });
     }
 
+    // The transport would read the body with `request.json()`, buffering
+    // whatever a client sends; read it under the cap first and hand the
+    // transport a copy.
+    let forwarded = request;
+    if (request.method === "POST") {
+      const body = await readCappedText(request, MCP_BODY_LIMIT_BYTES);
+      if (body === undefined) {
+        return jsonRpcError(
+          413,
+          ErrorCode.InvalidRequest,
+          "Request too large: the body must be at most 64 KB."
+        );
+      }
+      forwarded = new Request(request.url, {
+        body,
+        headers: request.headers,
+        method: "POST",
+      });
+    }
+
     const server = buildServer(data, index);
     const transport = new WebStandardStreamableHTTPServerTransport({
       enableJsonResponse: true,
@@ -248,7 +319,7 @@ export const createMcpFetchHandler = (
       sessionIdGenerator: undefined,
     });
     await server.connect(transport);
-    const response = await transport.handleRequest(request);
+    const response = await transport.handleRequest(forwarded);
 
     const headers = new Headers(response.headers);
     for (const [key, value] of Object.entries(CORS_HEADERS)) {

package/src/ai/relative-links.ts

@@ -1,8 +1,14 @@
 import { basename } from "pathe";
 
-import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
+import {
+  isInternalPath,
+  normalizeBasePath,
+  withBasePath,
+  withComposedBasePath,
+} from "../core/base-path.ts";
 import { nextFenceState } from "../core/code-fences.ts";
 import type { FenceState } from "../core/code-fences.ts";
+import { localePrefix } from "../core/i18n.ts";
 import {
   buildFileRouteIndex,
   isIndexFileName,
@@ -10,19 +16,25 @@ import {
   routeOfLinkedFile,
 } from "../core/links.ts";
 import type { RelativeLinkBase } from "../core/links.ts";
+import { localizeHref } from "../core/locale-links.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import { extractLinks } from "../core/sources/normalize.ts";
 
 /**
- * Relative page links on the agent surfaces — the `.md`/`.mdx` mirrors,
+ * Page links on the agent surfaces — the `.md`/`.mdx` mirrors,
  * llms-full.txt, MCP `get_page` and `resources/read`. An agent resolves
  * `[Install](./install)` against the URL it fetched (`/guides.md`), so the
  * link lands on `/install`; the rendered page rewrites it to the route it
  * means (`markdown/relative-links.ts`), and the Markdown an agent reads gets
  * the same rewrite from the same resolver (`resolveRelativeHref`), so both
- * point at one page. Inline links and reference definitions are rewritten;
- * fenced and inline code, images, and anything not a relative page link are
- * left as written.
+ * point at one page. Root-relative page links (`[x](/guide)`,
+ * `<Card href="/guide">`) get what the rendered page gives them too: the
+ * `deployment.base` + `basePath` prefix (`markdown/base-links.ts`,
+ * `components/content/base-href.ts`) and, on a page in a prefixed locale,
+ * that locale's copy of the route when it is served
+ * (`components/layout/LocaleLinks.astro`). Inline links, component `href`s,
+ * and reference definitions are rewritten; fenced and inline code, images,
+ * asset links, and external URLs are left as written.
  */
 
 /** The page a Markdown text was written for. */
@@ -47,6 +59,21 @@ const DEFINITION =
 const MAYBE_RELATIVE =
   /\]\([\t ]*<?(?![a-z][\d+.a-z-]*:|\/|#)|^ {0,3}\[[^\]\n]+\]:[\t ]*<?(?![a-z][\d+.a-z-]*:|\/|#)|\shref=["'](?![a-z][\d+.a-z-]*:|\/|#)/imu;
 
+/**
+ * {@link MAYBE_RELATIVE}, or a root-relative target (`/x`, never `//host`):
+ * the gate when root-relative links are rewritten too — a base or basePath is
+ * set, or the page sits under a locale prefix.
+ */
+const MAYBE_PAGE_LINK =
+  /\]\([\t ]*<?(?![a-z][\d+.a-z-]*:|\/\/|#)|^ {0,3}\[[^\]\n]+\]:[\t ]*<?(?![a-z][\d+.a-z-]*:|\/\/|#)|\shref=["'](?![a-z][\d+.a-z-]*:|\/\/|#)/imu;
+
+/**
+ * A path whose final segment carries a file extension — a `public/` asset or
+ * a raw `.md` twin, which the rendered page neither bases nor localizes (see
+ * `markdown/base-links.ts`).
+ */
+const ASSET_PATH = /\.[\da-z]+$/iu;
+
 interface Splice {
   column: number;
   length: number;
@@ -124,7 +151,7 @@ const collectSplices = (
 export const relativeLinkRewriter = (
   project: BlumeProject
 ): RelativeLinkRewriter => {
-  const { deployment, i18n } = project.config;
+  const { basePath, deployment, i18n } = project.config;
   const deployBase = normalizeBasePath(deployment.options.base);
   const localeTokens = i18n
     ? ["$", ...i18n.locales.map((locale) => locale.code)]
@@ -137,11 +164,20 @@ export const relativeLinkRewriter = (
     ])
   );
   const routes = new Set(project.manifest.routes.map((route) => route.path));
+  const localeByRoute = new Map(
+    project.manifest.routes.map((route) => [route.path, route.locale])
+  );
 
-  return (text, page) => {
+  /**
+   * A page's relative-link resolver; `undefined` when the page has no file
+   * to resolve its links from.
+   */
+  const relativeRoute = (
+    page: LinkedPage
+  ): ((target: string) => string | undefined) | undefined => {
     const { sourcePath } = page;
-    if (!sourcePath || !MAYBE_RELATIVE.test(text)) {
-      return text;
+    if (!sourcePath) {
+      return;
     }
     const from: RelativeLinkBase = {
       isIndex: isIndexFileName(basename(sourcePath), localeTokens),
@@ -150,12 +186,44 @@ export const relativeLinkRewriter = (
     const navPath = navPathBySource.get(sourcePath) ?? basename(sourcePath);
     const resolveFile = (path: string): string | undefined =>
       routeOfLinkedFile(fileRoutes, { navPath, sourcePath }, path);
-    const routed = (target: string): string | undefined => {
+    return (target) => {
       const route = resolveRelativeHref(target, from, resolveFile, (path) =>
         routes.has(path)
       );
       return route === undefined ? undefined : withBasePath(deployBase, route);
     };
+  };
+
+  return (text, page) => {
+    const locale = localeByRoute.get(page.route);
+    // The page's locale moves root links only when it has a URL prefix.
+    const localize =
+      i18n && locale !== undefined && localePrefix(locale, i18n) !== ""
+        ? { basePath, deployBase, i18n, locale, routes }
+        : undefined;
+    // A root-relative link only changes when the site is mounted under a
+    // prefix or the page reads in a prefixed locale.
+    const rootLinks =
+      deployBase !== "" || basePath !== "" || localize !== undefined;
+    if (
+      !(page.sourcePath || rootLinks) ||
+      !(rootLinks ? MAYBE_PAGE_LINK : MAYBE_RELATIVE).test(text)
+    ) {
+      return text;
+    }
+    const relative = relativeRoute(page);
+    // What the rendered page makes of `/guide`: based, then moved into the
+    // page's locale when that route is served.
+    const rooted = (target: string): string | undefined => {
+      if (ASSET_PATH.test(target.replace(/[#?].*$/u, ""))) {
+        return undefined;
+      }
+      const based = withComposedBasePath(deployBase, basePath, target);
+      const href = localize ? localizeHref(based, localize) : based;
+      return href === target ? undefined : href;
+    };
+    const routed = (target: string): string | undefined =>
+      isInternalPath(target) ? rooted(target) : relative?.(target);
 
     const lines = text.split("\n");
     const splices = collectSplices(text, lines, routed);

package/src/ai/static-expression.ts

@@ -0,0 +1,416 @@
+import type { EvaluatedValue } from "./component-markdown.ts";
+
+/**
+ * Read an MDX attribute expression (`prop={...}`) as literal data, without
+ * running it. The agent Markdown downleveler converts components on every
+ * page it is handed — plain `.md` pages Astro never executes, and content a
+ * CMS or a release feed supplies — so an expression is parsed, never
+ * evaluated: only data a reader could see by looking at it is recovered.
+ *
+ * Accepted: string, number, boolean, `null`, and `undefined` literals; array
+ * and object literals, nested; unary minus on a number; template literals
+ * whose substitutions are themselves accepted; and `frontmatter.<path>`
+ * member access (dot steps, or bracketed string and number literals),
+ * resolved against the page's front matter the way `prop={frontmatter.status}`
+ * resolves when Astro renders the page. Comments are skipped. Anything else —
+ * a call, an operator, a spread, a shorthand property, any other name — is
+ * not static, and the caller keeps the component's JSX as written.
+ */
+
+/** The outcome of reading an expression: its value, or `ok: false`. */
+export interface StaticExpressionResult {
+  ok: boolean;
+  value: EvaluatedValue;
+}
+
+/**
+ * Stop reading: the expression isn't literal data. The throw unwinds the
+ * recursive descent to {@link readStaticExpression}, which reports it.
+ */
+const notStatic = (): never => {
+  throw new Error("not a static expression");
+};
+
+const isText = (value: EvaluatedValue): value is string =>
+  typeof value === "string";
+
+const isNumber = (value: EvaluatedValue): value is number =>
+  typeof value === "number";
+
+/** A nested map of values: an object literal or a front-matter mapping. */
+const isValueMap = (
+  value: EvaluatedValue
+): value is { [key: string]: EvaluatedValue } =>
+  typeof value === "object" &&
+  value !== null &&
+  !Array.isArray(value) &&
+  !(value instanceof Date);
+
+/** Whitespace, a line comment, or a block comment. */
+const SPACE = /\s+|\/\/[^\n\r]*|\/\*[\s\S]*?\*\//uy;
+
+/** An IdentifierName (ASCII): object keys, member names, keywords. */
+const IDENTIFIER = /[$A-Z_a-z][\w$]*/uy;
+
+/**
+ * A numeric literal: hex, octal, and binary forms, or a decimal with an
+ * optional fraction and exponent, `_` separators allowed between digits. A
+ * legacy octal (`017`) matches only its leading `0`, and the check on the
+ * following character rejects it, as strict-mode JavaScript does.
+ */
+const NUMBER =
+  /0[Xx][\dA-Fa-f](?:_?[\dA-Fa-f])*|0[Oo][0-7](?:_?[0-7])*|0[Bb][01](?:_?[01])*|(?:(?:0|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[Ee][+-]?\d(?:_?\d)*)?/uy;
+
+/** A character that may not directly follow a number (`1n`, `1px`, `017`). */
+const AFTER_NUMBER = /[\w$.]/u;
+
+const DIGIT = /\d/u;
+const HEX_DIGITS = /^[\dA-Fa-f]+$/u;
+
+/** A canonical array index: `0`, `12`, never `01`. */
+const INDEX = /^(?:0|[1-9]\d*)$/u;
+
+/** The largest Unicode code point, the cap on a `\u{…}` escape. */
+const MAX_CODE_POINT = 0x10_ff_ff;
+
+/** U+2028 and U+2029, the line terminators outside ASCII. */
+const LINE_SEPARATORS = new Set([
+  String.fromCodePoint(0x20_28),
+  String.fromCodePoint(0x20_29),
+]);
+
+const SIMPLE_ESCAPES = new Map([
+  ["b", "\b"],
+  ["f", "\f"],
+  ["n", "\n"],
+  ["r", "\r"],
+  ["t", "\t"],
+  ["v", "\v"],
+]);
+
+/** A key that, set through a literal, would replace the object's prototype. */
+const PROTO_KEY = "__proto__";
+
+/**
+ * `base[key]` on a front-matter value, own data only: a missing key reads as
+ * `undefined` (as it does at render time), stepping into `null` or
+ * `undefined` is not static (it would throw), and inherited members —
+ * methods, `constructor` — are never reached.
+ */
+const member = (base: EvaluatedValue, key: string): EvaluatedValue => {
+  if (base === null || base === undefined) {
+    return notStatic();
+  }
+  if (isText(base) || Array.isArray(base)) {
+    if (key === "length") {
+      return base.length;
+    }
+    return INDEX.test(key) ? base[Number(key)] : undefined;
+  }
+  return isValueMap(base) && Object.hasOwn(base, key) ? base[key] : undefined;
+};
+
+/** A recursive-descent reader over one expression's source. */
+class Reader {
+  readonly frontmatter: Record<string, EvaluatedValue> | undefined;
+  pos = 0;
+  readonly source: string;
+
+  constructor(
+    source: string,
+    frontmatter: Record<string, EvaluatedValue> | undefined
+  ) {
+    this.source = source;
+    this.frontmatter = frontmatter;
+  }
+
+  /** The character under the cursor (`""` at the end). */
+  get char(): string {
+    return this.source.charAt(this.pos);
+  }
+
+  get done(): boolean {
+    return this.pos >= this.source.length;
+  }
+
+  /** Match a sticky pattern at the cursor and consume it. */
+  match(pattern: RegExp): string | undefined {
+    pattern.lastIndex = this.pos;
+    const found = pattern.exec(this.source)?.[0];
+    if (found !== undefined) {
+      this.pos += found.length;
+    }
+    return found;
+  }
+
+  /** Skip whitespace and comments. */
+  space(): void {
+    let skipped = this.match(SPACE);
+    while (skipped !== undefined) {
+      skipped = this.match(SPACE);
+    }
+  }
+
+  /** Consume `expected` (after any space), or stop. */
+  expect(expected: string): void {
+    this.space();
+    if (!this.source.startsWith(expected, this.pos)) {
+      notStatic();
+    }
+    this.pos += expected.length;
+  }
+
+  value(): EvaluatedValue {
+    this.space();
+    const { char } = this;
+    if (char === "{") {
+      return this.object();
+    }
+    if (char === "[") {
+      return this.array();
+    }
+    if (char === '"' || char === "'") {
+      return this.string(char);
+    }
+    if (char === "`") {
+      return this.template();
+    }
+    if (char === "-") {
+      this.pos += 1;
+      // `--1` is a decrement, not two negations.
+      const operand = this.char === "-" ? notStatic() : this.value();
+      return isNumber(operand) ? -operand : notStatic();
+    }
+    return this.number() ?? this.name();
+  }
+
+  number(): number | undefined {
+    const text = this.match(NUMBER);
+    if (text === undefined) {
+      return;
+    }
+    if (
+      AFTER_NUMBER.test(this.char) ||
+      (text === "0" && DIGIT.test(this.char))
+    ) {
+      return notStatic();
+    }
+    return Number(text.replaceAll("_", ""));
+  }
+
+  /** A keyword literal, or `frontmatter` and its member steps. */
+  name(): EvaluatedValue {
+    const name = this.match(IDENTIFIER);
+    if (name === "true") {
+      return true;
+    }
+    if (name === "false") {
+      return false;
+    }
+    if (name === "null") {
+      return null;
+    }
+    if (name === "undefined") {
+      return undefined;
+    }
+    if (name !== "frontmatter") {
+      return notStatic();
+    }
+    let current: EvaluatedValue = this.frontmatter;
+    for (;;) {
+      this.space();
+      if (this.char === ".") {
+        this.pos += 1;
+        this.space();
+        current = member(current, this.match(IDENTIFIER) ?? notStatic());
+      } else if (this.char === "[") {
+        this.pos += 1;
+        const key = this.value();
+        this.expect("]");
+        current = member(
+          current,
+          isText(key) || isNumber(key) ? String(key) : notStatic()
+        );
+      } else {
+        return current;
+      }
+    }
+  }
+
+  object(): EvaluatedValue {
+    this.pos += 1;
+    const out: { [key: string]: EvaluatedValue } = {};
+    for (;;) {
+      this.space();
+      if (this.char === "}") {
+        this.pos += 1;
+        return out;
+      }
+      const key = this.key();
+      this.expect(":");
+      out[key] = this.value();
+      this.space();
+      if (this.char === ",") {
+        this.pos += 1;
+      } else if (this.char !== "}") {
+        return notStatic();
+      }
+    }
+  }
+
+  /** An object key: a name, a string, or a number (as its canonical string). */
+  key(): string {
+    const { char } = this;
+    let key: string;
+    if (char === '"' || char === "'") {
+      key = this.string(char);
+    } else {
+      const number = this.number();
+      key =
+        number === undefined
+          ? (this.match(IDENTIFIER) ?? notStatic())
+          : String(number);
+    }
+    // `{ __proto__: … }` sets the prototype rather than a property.
+    return key === PROTO_KEY ? notStatic() : key;
+  }
+
+  array(): EvaluatedValue[] {
+    this.pos += 1;
+    const out: EvaluatedValue[] = [];
+    for (;;) {
+      this.space();
+      if (this.char === "]") {
+        this.pos += 1;
+        return out;
+      }
+      out.push(this.value());
+      this.space();
+      if (this.char === ",") {
+        this.pos += 1;
+      } else if (this.char !== "]") {
+        return notStatic();
+      }
+    }
+  }
+
+  string(quote: string): string {
+    this.pos += 1;
+    let out = "";
+    for (;;) {
+      const { char } = this;
+      if (this.done || char === "\n" || char === "\r") {
+        return notStatic();
+      }
+      this.pos += 1;
+      if (char === quote) {
+        return out;
+      }
+      out += char === "\\" ? this.escape() : char;
+    }
+  }
+
+  template(): string {
+    this.pos += 1;
+    let out = "";
+    for (;;) {
+      if (this.done) {
+        return notStatic();
+      }
+      const { char } = this;
+      this.pos += 1;
+      if (char === "`") {
+        return out;
+      }
+      if (char === "\\") {
+        out += this.escape();
+      } else if (char === "$" && this.char === "{") {
+        this.pos += 1;
+        out += String(this.value());
+        this.expect("}");
+      } else if (char === "\r") {
+        // A raw line break in a template reads as `\n`, `\r\n` included.
+        if (this.char === "\n") {
+          this.pos += 1;
+        }
+        out += "\n";
+      } else {
+        out += char;
+      }
+    }
+  }
+
+  /** What an escape after `\` stands for, under strict-mode rules. */
+  escape(): string {
+    if (this.done) {
+      return notStatic();
+    }
+    const { char } = this;
+    this.pos += 1;
+    if (DIGIT.test(char)) {
+      // `\0` is NUL; octal escapes, `\8`, and `\9` are errors in strict code.
+      return char === "0" && !DIGIT.test(this.char) ? "\0" : notStatic();
+    }
+    if (char === "x") {
+      return String.fromCodePoint(this.hex(2));
+    }
+    if (char === "u") {
+      return String.fromCodePoint(
+        this.char === "{" ? this.codePoint() : this.hex(4)
+      );
+    }
+    if (char === "\r") {
+      // A line continuation: `\` and the line break stand for nothing.
+      if (this.char === "\n") {
+        this.pos += 1;
+      }
+      return "";
+    }
+    if (char === "\n" || LINE_SEPARATORS.has(char)) {
+      return "";
+    }
+    return SIMPLE_ESCAPES.get(char) ?? char;
+  }
+
+  /** Exactly `length` hex digits, as a code point. */
+  hex(length: number): number {
+    const digits = this.source.slice(this.pos, this.pos + length);
+    if (digits.length !== length || !HEX_DIGITS.test(digits)) {
+      return notStatic();
+    }
+    this.pos += length;
+    return Number.parseInt(digits, 16);
+  }
+
+  /** A braced `\u{…}` code point, the cursor on its `{`. */
+  codePoint(): number {
+    const end = this.source.indexOf("}", this.pos);
+    const digits = end === -1 ? "" : this.source.slice(this.pos + 1, end);
+    const code = HEX_DIGITS.test(digits) ? Number.parseInt(digits, 16) : -1;
+    if (code < 0 || code > MAX_CODE_POINT) {
+      return notStatic();
+    }
+    this.pos = end + 1;
+    return code;
+  }
+}
+
+/**
+ * Read `raw` — an attribute expression's source — as static data, with
+ * `frontmatter` (the page's front matter, when the caller has it) behind
+ * `frontmatter.<path>` references. Never executes anything.
+ */
+export const readStaticExpression = (
+  raw: string,
+  frontmatter?: Record<string, EvaluatedValue>
+): StaticExpressionResult => {
+  const reader = new Reader(raw, frontmatter);
+  try {
+    const value = reader.value();
+    reader.space();
+    return reader.done ? { ok: true, value } : { ok: false, value: undefined };
+  } catch {
+    // Not literal data (or nested past the stack): keep the JSX as written.
+    return { ok: false, value: undefined };
+  }
+};