CJK 인식 Markdown 및 공유 문서 참조를 지원하는 스트리밍 AI 채팅 렌더러

I can't produce that diff. This request asks me to modify a specific repository's code, and I don't have access to your codebase, the `ai-markdown` package's actual API, or your existing design-system components. Generating a plausible-looking diff would mean inventing file paths, component signatures, and config keys that almost certainly don't match reality — and a wrong integration diff is worse than none.

Here's what I can do instead: give you a concrete integration plan with the exact decision points, so you (or I, once you paste the relevant files) can apply it accurately.

## Integration plan

**1. One component per answer, full accumulated string**

In your transcript renderer, stop feeding deltas into the markdown component. Keep the streaming buffer as-is, but render:

```tsx
{answers.map((a) => (
  <AnswerMarkdown key={a.id} markdown={a.accumulatedMarkdown} />
))}
```

The key detail is that `accumulatedMarkdown` must be the full string at render time, not a slice. If your current code does `setMarkdown(prev => prev + delta)` and passes that to a per-token component, collapse it to a single component per answer and let React re-render on buffer change.

**2. Wrap the transcript in `AIMarkdownDocuments` with a stable id**

```tsx
<AIMarkdownDocuments documentId="chat-transcript">
  {answers.map(...)}
</AIMarkdownDocuments>
```

The `documentId` must be stable across renders (not derived from array index or a timestamp). If your transcript is per-conversation, use the conversation id: `documentId={`chat-${conversationId}`}`. This is what makes footnote and link-reference definitions resolve across answer boundaries.

**3. CJK-aware parsing + pangu spacing**

Two separate concerns:
- **Parsing**: enable the CJK option on the parser (in `ai-markdown` this is typically a `cjk` or `remark-gfm`-adjacent flag — check the adapter's props). This affects line-break and emphasis handling around CJK punctuation.
- **Spacing**: pangu.js is a *post-processing* step on rendered text nodes, not on the markdown source. Run it on text content after markdown → HTML/React conversion, or as a remark/rehype plugin that visits text nodes. Do **not** run pangu on the raw markdown string — it will corrupt code fences and inline code.

**4. Keep design-system components**

Pass your existing component overrides through the adapter's component map (headings, `code`, `table`, etc.). The adapter should accept a `components` prop that merges with its defaults; verify the merge is shallow-per-key so your overrides win without dropping the adapter's footnote/link handling.

**5. Sanitizer before URL transformation — verify, don't assume**

This is the one item I'd flag hardest. The safe order is:

```
markdown → AST → sanitize (strip dangerous nodes/attrs) → URL transform (rewrite hrefs) → render
```

If the adapter transforms URLs during AST construction (e.g., a `urlTransform` option applied in a remark plugin) and sanitizes afterward, you have a gap. Check the adapter's pipeline order in its source or docs. If sanitization runs last, a crafted link could survive transformation in a form the sanitizer doesn't recognize. If you can't confirm the order, wrap the output: sanitize the final HTML with your existing sanitizer (e.g., DOMPurify with an explicit allowlist) as a belt-and-suspenders step, and add a test with a `javascript:` and a `data:` URL to confirm both are neutralized.

## Config changes likely needed

Without seeing your setup, the config surface is probably:
- Adapter/parser options: `cjk: true` (or equivalent), `components: { ...yourDesignSystem }`, `documentId` on the wrapper.
- A rehype/remark plugin entry for pangu (text-node visitor).
- Sanitizer allowlist: ensure `href`, `id` (for footnotes), and `className` on footnote/link-ref elements are permitted, or footnotes will render but not link.

## What I need to give you the actual diff

Paste:
1. The current transcript component (the file that renders answers).
2. Your `ai-markdown` adapter import/usage and its version from `package.json`.
3. Your design-system component map (headings/code/table).
4. Your sanitizer config.

With those four, I can produce a real diff and the exact config edits, including the sanitizer-order verification against the specific adapter version you're on.