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

Typing
    render-components:
      -
into a document's YAML frontmatter crashed the iframe-host page. The
YAML parser produces a MetaList with a `null` (or empty MetaInlines)
entry; `ReactRenderer.tsx`'s path-extraction expression
`o?.c?.[0]?.c` returned `undefined`, which then crashed
`resolveComponentPath(undefined, …)` inside the same `useMemo` with
`Cannot read properties of undefined (reading 'startsWith')`. The
throw bubbles past the local ErrorBoundary (the boundary is a JSX
descendant of `ReactRenderer`, not an ancestor) and blanks the page —
user can't even finish typing.

Fix: filter the extracted paths to keep only non-empty strings. Empty
list entries and empty-MetaInlines entries are skipped silently (no
`console.warn` — they're transient editor states, not user errors
worth surfacing).

Two regression tests added to `ReactRenderer.integration.test.tsx`:
one for `MetaList c: [null]` (the literal "type a bullet, no value"
shape), one for `MetaList c: [{t: 'MetaInlines', c: []}]` (the
"opened the string delimiter, no content yet" shape). Both fail
before the fix with the exact TypeError above; both pass after.

Author: gordonwoodhull

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]);