fix(hub-client): tolerate empty render-components list entries

Empty strings in the YAML render-components list crashed the parser.
Skip empty entries silently rather than erroring.

Author: gordonwoodhull

hub-client/changelog.md

@@ -17,6 +17,7 @@ be in reverse chronological order (latest first).
 
 - [`979982bd`](https://github.com/quarto-dev/q2/commits/979982bd): Custom syntax highlighting now works in Quarto Hub projects (bd-izfv) — user-supplied tree-sitter grammars under `_quarto/grammars/<lang>/` now apply to code blocks even when the qmd file lives under a `_quarto.yml` ancestor, matching the single-file render path.
 - [`c8a684bd`](https://github.com/quarto-dev/q2/commits/c8a684bd): Fix bd-3gtn: WASM artifact-flush loop in `wasm-quarto-hub-client/src/lib.rs` was overwriting user-uploaded image bytes with empty content on every render. `ResourceCollectorTransform` produces manifest-only entries via `Artifact::from_path` whose absolute path collapsed via `Path::join`'s absolute-replace rule onto the user's VFS upload location. Both flush loops now skip empty-content artifacts, preserving manifest semantics for downstream consumers while keeping produced bytes (theme CSS, fonts, future engine-generated images) flowing. Discovered during Plan 2A review (2026-05-07) and routed-around by Plan 2B until now; the test in `assetManifestProject.wasm.test.ts` was reverted to its natural lifecycle (binary upload BEFORE render) for a bug-then-fix walk-through.
+- [`02da39a5`](https://github.com/quarto-dev/q2/commits/02da39a5): Fix iframe-host crash when typing `render-components:\n  -` (empty list bullet) into a document's YAML frontmatter. The path-extraction in `ReactRenderer.tsx`'s `componentPathsKey` useMemo yielded `undefined` for the null entry, which then crashed `resolveComponentPath(undefined, …)` with `Cannot read properties of undefined (reading 'startsWith')` — past the local ErrorBoundary (a descendant, not an ancestor of `ReactRenderer`), so the page went blank and the user couldn't finish typing. Now filters extracted paths to keep only non-empty strings; empty entries are skipped silently. Two regression tests cover the `MetaList c: [null]` and `MetaList c: [{t: 'MetaInlines', c: []}]` mid-type shapes.
 - [`3b064478`](https://github.com/quarto-dev/q2/commits/3b064478): Plan 2D q2-preview body container + title block. `PreviewDocument.tsx` now emits the `<div id="quarto-content"><main class="content">` wrapper mirroring `template.rs:185-247`, applies `body-classes` imperatively to `document.body`, and re-implements the Rust `title-block` transform's minimal-mode `<h1>` synthesis React-side (the transform itself stays in `Q2_PREVIEW_TRANSFORM_EXCLUDED`). Iframe `document.title` now tracks `meta.pagetitle ?? meta.title`. New `q2-preview/custom/PreviewTitleBlock.tsx` mirrors `template.rs:211-240` byte-for-byte and is registered under the synthetic `__title_block__` registry key; user TSX overrides can full-replace or compose via the `__Q2_PREVIEW_RENDERER__.PreviewTitleBlock` exposure. Phase 6.0 framework extraction lifts `inlinesToPlainText` / `blocksToPlainText` to `framework/plainText.ts` and adds `framework/meta.ts` (`extractMetaString` / `extractMetaBool` / `extractMetaStringList`); `FormatRegistry` gains typed optional entries for both synthetic keys. The slide renderer's private `extractMetaString` is replaced by the framework helper (deliberate behavior change for inline-markup in slide titles, locked by a regression test); `meta.format` extraction in `ReactRenderer.tsx` and `getQ2Format.ts` consolidates onto the same helper. Tests: 27 framework unit, 18 PreviewDocument integration, 17 PreviewTitleBlock integration (incl. composition idiom), explicit synthetic-key assertion closing a pre-existing `__fallback__` gap; 11 smoke-all q2-preview fixtures (body-container + body-classes + title-block).
 - [`c8a684bd`](https://github.com/quarto-dev/q2/commits/c8a684bd): Fix bd-3gtn: WASM artifact-flush loop in `wasm-quarto-hub-client/src/lib.rs` was overwriting user-uploaded image bytes with empty content on every render. `ResourceCollectorTransform` produces manifest-only entries via `Artifact::from_path` whose absolute path collapsed via the absolute-replace rule of `Path::join` onto the user's VFS upload location. Both flush loops now skip empty-content artifacts, preserving manifest semantics for downstream consumers while keeping produced bytes (theme CSS, fonts, future engine-generated images) flowing. Discovered during Plan 2A review (2026-05-07) and routed-around by Plan 2B until now; the test in `assetManifestProject.wasm.test.ts` was reverted to its natural lifecycle (binary upload BEFORE render) for a bug-then-fix walk-through.
 - [`d91150c4`](https://github.com/quarto-dev/q2/commits/d91150c4): Plan 2B Phase 5.2 and 5.3: smoke-all `q2-preview/image-with-attrs.qmd` fixture (with a 1x1 PNG sibling) and the `assetManifestProject.wasm.test.ts` WASM-bridge safety net. The smoke fixture asserts the parent-side asset walker mints a blob URL, propagates the width attribute, and round-trips alt text. The WASM test mirrors `themeFingerprint.wasm.test.ts` and renders a `_quarto.yml`-rooted project doc with a project-relative Image, then exercises the walker against the parsed AST and project-relative `currentFilePath`. Catches default-project resolution bugs analogous to the Plan 2A theme path mismatch (commit e6381abd). 82/82 WASM tests pass.

hub-client/src/components/render/ReactRenderer.integration.test.tsx

@@ -264,4 +264,90 @@ describe('ReactRenderer render-components gate (Plan 2A item 13)', () => {
       '/elliot/simple.tsx': 'JS:export const Para = () => null;',
     });
   });
+
+  it('skips empty `render-components` list entries without crashing', () => {
+    // Reproduces the bug observed while typing in the YAML frontmatter:
+    //
+    //     render-components:
+    //       -
+    //
+    // The parser produces a MetaList with a single empty / null entry
+    // (no MetaInlines, no Str). Before the fix, the path extraction
+    // emitted `[undefined]`, which then crashed `resolveComponentPath`
+    // mid-type with `Cannot read properties of undefined (reading
+    // 'startsWith')`. No upstream ErrorBoundary, so the iframe-host
+    // page went blank and the user couldn't finish typing.
+    //
+    // The renderer should tolerate empty entries by skipping them,
+    // leaving the customComponentsCode map empty.
+    const malformedAst = JSON.stringify({
+      'pandoc-api-version': [1, 23, 0],
+      meta: {
+        'render-components': {
+          t: 'MetaList',
+          // single empty bullet: the parser commonly produces `null`,
+          // sometimes `{t: 'MetaString', c: ''}`, occasionally an
+          // empty MetaInlines. All three shapes must not crash.
+          c: [null],
+        },
+      },
+      blocks: [],
+    });
+
+    expect(() => {
+      render(
+        <ReactRenderer
+          astJson={malformedAst}
+          currentFilePath="elliot/index.qmd"
+          files={[]}
+          fileContents={new Map()}
+          onNavigateToDocument={() => {}}
+          setAst={() => {}}
+          format="q2-preview"
+        />,
+      );
+    }).not.toThrow();
+    expect(lastCapturedPreviewCode()).toEqual({});
+  });
+
+  it('skips `render-components` entries that resolve to empty strings', () => {
+    // Same defensive coverage for the case where the YAML entry parsed
+    // as a MetaInlines with no children (or a Str of empty text). The
+    // path extraction yields '' which would also crash downstream
+    // (well, technically empty string would skip resolveComponentPath
+    // but still attempt a `fileContents.get('')` lookup and a noisy
+    // console.warn). Treating empty paths as absent keeps the warn
+    // surface clean while the user is mid-typing.
+    const partiallyTypedAst = JSON.stringify({
+      'pandoc-api-version': [1, 23, 0],
+      meta: {
+        'render-components': {
+          t: 'MetaList',
+          c: [{ t: 'MetaInlines', c: [] }],
+        },
+      },
+      blocks: [],
+    });
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    expect(() => {
+      render(
+        <ReactRenderer
+          astJson={partiallyTypedAst}
+          currentFilePath="elliot/index.qmd"
+          files={[]}
+          fileContents={new Map()}
+          onNavigateToDocument={() => {}}
+          setAst={() => {}}
+          format="q2-preview"
+        />,
+      );
+    }).not.toThrow();
+    expect(lastCapturedPreviewCode()).toEqual({});
+    // Empty-string paths should be skipped without warning — they
+    // arise from mid-typing the YAML and aren't a user error worth
+    // surfacing.
+    expect(warnSpy).not.toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
 });

hub-client/src/components/render/ReactRenderer.tsx

@@ -116,7 +116,20 @@ function ReactRenderer({
     }
 
     const ast = JSON.parse(astJson);
-    const componentPaths = ast?.meta?.['render-components']?.c?.map?.((o: any) => o?.c?.[0]?.c) ?? [];
+    // Walk the MetaList → MetaInlines → Str(c) chain. Entries that
+    // don't resolve to a non-empty string are dropped: this includes
+    // (a) `render-components:\n  -` mid-typing, where the bullet has
+    // no value and parses to `null`, and (b) an empty MetaInlines
+    // (the user typed the path-string-open delimiter but no content
+    // yet). Without this filter, `resolveComponentPath(undefined …)`
+    // throws inside this useMemo and the iframe-host page goes blank
+    // with no upstream ErrorBoundary to catch it.
+    const rawPaths: unknown[] =
+      ast?.meta?.['render-components']?.c?.map?.((o: any) => o?.c?.[0]?.c) ??
+      [];
+    const componentPaths = rawPaths.filter(
+      (p): p is string => typeof p === 'string' && p.length > 0,
+    );
 
     return JSON.stringify(componentPaths);
   }, [format, astJson]);