From f30f3ea0cd858c7d8932ec0a91c690f111f43c25 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:38:37 -0700
Subject: [PATCH 01/15] chore(chat): add @cacheplane/partial-markdown@0.1.0
 dependency
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Used by <chat-streaming-md> for streaming markdown AST. Implementation
detail (not a peer dep) — chat consumers don't need to install it.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 libs/chat/package.json |  3 ++-
 package-lock.json      | 10 ++++++++++
 package.json           |  1 +
 3 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/libs/chat/package.json b/libs/chat/package.json
index 2cea298c1..67eba3d68 100644
--- a/libs/chat/package.json
+++ b/libs/chat/package.json
@@ -13,7 +13,8 @@
     "./chat.css": "./chat.css"
   },
   "dependencies": {
-    "@cacheplane/partial-json": "^0.1.1"
+    "@cacheplane/partial-json": "^0.1.1",
+    "@cacheplane/partial-markdown": "^0.1.0"
   },
   "peerDependencies": {
     "@angular/core": "^20.0.0 || ^21.0.0",
diff --git a/package-lock.json b/package-lock.json
index c4ad18605..fc4dd25a3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -22,6 +22,7 @@
         "@angular/platform-browser": "~21.1.0",
         "@angular/router": "~21.1.0",
         "@cacheplane/partial-json": "^0.1.1",
+        "@cacheplane/partial-markdown": "^0.1.0",
         "@langchain/core": "^1.1.33",
         "@langchain/langgraph-sdk": "^1.7.4",
         "@modelcontextprotocol/sdk": "^1.27.1",
@@ -6934,6 +6935,15 @@
       "integrity": "sha512-A6579pz2ad6eMxNALJBhiRyqnqNL2G5uYptbjCqPUqaFX7O3u5NkUTG/7IkEDaWfPk10mR0ZJJXlnAnkLsH+YQ==",
       "license": "MIT"
     },
+    "node_modules/@cacheplane/partial-markdown": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@cacheplane/partial-markdown/-/partial-markdown-0.1.0.tgz",
+      "integrity": "sha512-aAKyaf3NU8SDJ9WD+Pu0CEDm1whfb61CipHbDOM+gNkNDnTVT9n8pNGUQEKUqfexoV6KEPc2tG2+OrG7k1pCbA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@cfworker/json-schema": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/@cfworker/json-schema/-/json-schema-4.1.1.tgz",
diff --git a/package.json b/package.json
index 9fe149dd6..36e727583 100644
--- a/package.json
+++ b/package.json
@@ -86,6 +86,7 @@
     "@angular/platform-browser": "~21.1.0",
     "@angular/router": "~21.1.0",
     "@cacheplane/partial-json": "^0.1.1",
+    "@cacheplane/partial-markdown": "^0.1.0",
     "@langchain/core": "^1.1.33",
     "@langchain/langgraph-sdk": "^1.7.4",
     "@modelcontextprotocol/sdk": "^1.27.1",

From 74c15c29e664dfca1665c53ee3abdf75f50469d5 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:39:49 -0700
Subject: [PATCH 02/15] feat(chat/markdown): MARKDOWN_VIEW_REGISTRY DI token

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../src/lib/markdown/markdown-view-registry.ts | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 libs/chat/src/lib/markdown/markdown-view-registry.ts

diff --git a/libs/chat/src/lib/markdown/markdown-view-registry.ts b/libs/chat/src/lib/markdown/markdown-view-registry.ts
new file mode 100644
index 000000000..906cae0bf
--- /dev/null
+++ b/libs/chat/src/lib/markdown/markdown-view-registry.ts
@@ -0,0 +1,18 @@
+// libs/chat/src/lib/markdown/markdown-view-registry.ts
+// SPDX-License-Identifier: MIT
+import { InjectionToken } from '@angular/core';
+import type { ViewRegistry } from '@ngaf/render';
+
+/**
+ * DI token for the markdown view registry consumed by <chat-streaming-md>
+ * and <md-children>. Maps MarkdownNode.type strings (e.g. "paragraph",
+ * "heading") to Angular components that render that node type.
+ *
+ * `<chat-streaming-md>` provides the runtime registry on its component-level
+ * injector — either the consumer-supplied [viewRegistry] input, or
+ * `cacheplaneMarkdownViews` (the default) — so descendant <md-children>
+ * components resolve the right components for each node.
+ */
+export const MARKDOWN_VIEW_REGISTRY = new InjectionToken<ViewRegistry>(
+  'MARKDOWN_VIEW_REGISTRY',
+);

From 5672720c5cfc0e63e392aac2f5bd1f218c6b5f95 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:40:59 -0700
Subject: [PATCH 03/15] feat(chat/markdown): <md-children> recursive registry
 dispatcher

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../markdown-children.component.spec.ts       | 110 ++++++++++++++++++
 .../markdown/markdown-children.component.ts   |  53 +++++++++
 2 files changed, 163 insertions(+)
 create mode 100644 libs/chat/src/lib/markdown/markdown-children.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/markdown-children.component.ts

diff --git a/libs/chat/src/lib/markdown/markdown-children.component.spec.ts b/libs/chat/src/lib/markdown/markdown-children.component.spec.ts
new file mode 100644
index 000000000..e2bc82c04
--- /dev/null
+++ b/libs/chat/src/lib/markdown/markdown-children.component.spec.ts
@@ -0,0 +1,110 @@
+// libs/chat/src/lib/markdown/markdown-children.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal, Type, input } from '@angular/core';
+import { views, type ViewRegistry } from '@ngaf/render';
+import type { MarkdownNode, MarkdownParagraphNode, MarkdownTextNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from './markdown-children.component';
+import { MARKDOWN_VIEW_REGISTRY } from './markdown-view-registry';
+
+@Component({
+  standalone: true,
+  selector: 'md-text-stub',
+  template: `<span data-test="text">{{ node().text }}</span>`,
+})
+class TextStub {
+  readonly node = input.required<MarkdownTextNode>();
+}
+
+@Component({
+  standalone: true,
+  selector: 'md-paragraph-stub',
+  imports: [MarkdownChildrenComponent],
+  template: `<p data-test="paragraph"><md-children [parent]="node()" /></p>`,
+})
+class ParagraphStub {
+  readonly node = input.required<MarkdownParagraphNode>();
+}
+
+@Component({
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  template: `<md-children [parent]="parent()" />`,
+})
+class HostComponent {
+  parent = signal<MarkdownNode>({
+    id: 0, type: 'paragraph', status: 'complete',
+    parent: null, index: null,
+    children: [],
+  } as MarkdownParagraphNode);
+}
+
+describe('MarkdownChildrenComponent', () => {
+  let registry: ViewRegistry;
+
+  beforeEach(() => {
+    registry = views({
+      'paragraph': ParagraphStub as Type<unknown>,
+      'text':      TextStub as Type<unknown>,
+    });
+    TestBed.configureTestingModule({
+      imports: [HostComponent],
+      providers: [{ provide: MARKDOWN_VIEW_REGISTRY, useValue: registry }],
+    });
+  });
+
+  it('renders nothing when parent has no children', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelectorAll('[data-test]')).toHaveLength(0);
+  });
+
+  it('dispatches each child through the registry', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    const text1: MarkdownTextNode = {
+      id: 1, type: 'text', status: 'complete',
+      parent: null, index: 0, text: 'hi',
+    };
+    const text2: MarkdownTextNode = {
+      id: 2, type: 'text', status: 'complete',
+      parent: null, index: 1, text: ' there',
+    };
+    fixture.componentInstance.parent.set({
+      id: 0, type: 'paragraph', status: 'complete',
+      parent: null, index: null,
+      children: [text1, text2],
+    } as MarkdownParagraphNode);
+    fixture.detectChanges();
+    const spans = fixture.nativeElement.querySelectorAll('[data-test="text"]');
+    expect(spans).toHaveLength(2);
+    expect(spans[0].textContent).toBe('hi');
+    expect(spans[1].textContent).toBe(' there');
+  });
+
+  it('skips nodes whose type is not in the registry', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    const unknownNode = {
+      id: 1, type: 'mystery', status: 'complete',
+      parent: null, index: 0,
+    } as unknown as MarkdownNode;
+    fixture.componentInstance.parent.set({
+      id: 0, type: 'paragraph', status: 'complete',
+      parent: null, index: null,
+      children: [unknownNode],
+    } as MarkdownParagraphNode);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelectorAll('[data-test]')).toHaveLength(0);
+  });
+
+  it('returns empty children array for non-container nodes', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    const text: MarkdownTextNode = {
+      id: 0, type: 'text', status: 'complete',
+      parent: null, index: null, text: 'hello',
+    };
+    fixture.componentInstance.parent.set(text as unknown as MarkdownNode);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelectorAll('[data-test]')).toHaveLength(0);
+  });
+});
diff --git a/libs/chat/src/lib/markdown/markdown-children.component.ts b/libs/chat/src/lib/markdown/markdown-children.component.ts
new file mode 100644
index 000000000..5947090fc
--- /dev/null
+++ b/libs/chat/src/lib/markdown/markdown-children.component.ts
@@ -0,0 +1,53 @@
+// libs/chat/src/lib/markdown/markdown-children.component.ts
+// SPDX-License-Identifier: MIT
+import {
+  Component,
+  ChangeDetectionStrategy,
+  inject,
+  input,
+  computed,
+  Type,
+} from '@angular/core';
+import { NgComponentOutlet } from '@angular/common';
+import type { ViewRegistry } from '@ngaf/render';
+import type { MarkdownNode } from '@cacheplane/partial-markdown';
+import { MARKDOWN_VIEW_REGISTRY } from './markdown-view-registry';
+
+/**
+ * Recursively dispatches a parent node's children through the markdown view
+ * registry. Each child's `type` is looked up in the registry; the resolved
+ * component is rendered with `[node]` bound to that child.
+ *
+ * Identity-preserving: `track $any(child)` keys on the JS reference of the
+ * child node. Because @cacheplane/partial-markdown preserves node identity
+ * across pushes, unchanged subtrees never re-render.
+ */
+@Component({
+  selector: 'md-children',
+  standalone: true,
+  imports: [NgComponentOutlet],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `
+    @for (child of children(); track $any(child)) {
+      @let comp = resolve(child);
+      @if (comp) {
+        <ng-container *ngComponentOutlet="comp; inputs: { node: child }" />
+      }
+    }
+  `,
+})
+export class MarkdownChildrenComponent {
+  readonly parent = input.required<MarkdownNode>();
+  private readonly registry = inject<ViewRegistry>(MARKDOWN_VIEW_REGISTRY);
+
+  protected readonly children = computed<readonly MarkdownNode[]>(() => {
+    const p = this.parent();
+    return 'children' in p && Array.isArray((p as { children?: MarkdownNode[] }).children)
+      ? ((p as { children: MarkdownNode[] }).children as readonly MarkdownNode[])
+      : [];
+  });
+
+  protected resolve(child: MarkdownNode): Type<unknown> | null {
+    return this.registry[child.type] ?? null;
+  }
+}

From fd9114f085979e1d238afd1d27b9156fd0876d72 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:44:05 -0700
Subject: [PATCH 04/15] feat(chat/markdown): leaf node renderers
 (text/breaks/code/image/autolink)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../views/markdown-autolink.component.ts      | 14 ++++++
 .../views/markdown-hard-break.component.ts    | 14 ++++++
 .../views/markdown-image.component.spec.ts    | 48 +++++++++++++++++++
 .../views/markdown-image.component.ts         | 14 ++++++
 .../views/markdown-inline-code.component.ts   | 14 ++++++
 .../views/markdown-soft-break.component.ts    | 14 ++++++
 .../views/markdown-text.component.spec.ts     | 40 ++++++++++++++++
 .../markdown/views/markdown-text.component.ts | 14 ++++++
 .../markdown-thematic-break.component.ts      | 14 ++++++
 9 files changed, 186 insertions(+)
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-image.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-text.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts

diff --git a/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts b/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
new file mode 100644
index 000000000..53ef7bb4b
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownAutolinkNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-autolink',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<a [href]="node().url">{{ node().url }}</a>`,
+})
+export class MarkdownAutolinkComponent {
+  readonly node = input.required<MarkdownAutolinkNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts b/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
new file mode 100644
index 000000000..95cca90d4
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownHardBreakNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-hard-break',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<br>`,
+})
+export class MarkdownHardBreakComponent {
+  readonly node = input.required<MarkdownHardBreakNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
new file mode 100644
index 000000000..aa03bb9f9
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
@@ -0,0 +1,48 @@
+// libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import type { MarkdownImageNode } from '@cacheplane/partial-markdown';
+import { MarkdownImageComponent } from './markdown-image.component';
+
+@Component({
+  standalone: true,
+  imports: [MarkdownImageComponent],
+  template: `<md-image [node]="node()" />`,
+})
+class HostComponent {
+  node = signal<MarkdownImageNode>({
+    id: 0, type: 'image', status: 'complete',
+    parent: null, index: null,
+    url: 'https://example.com/x.png',
+    alt: 'logo',
+    title: '',
+  });
+}
+
+describe('MarkdownImageComponent', () => {
+  beforeEach(() => TestBed.configureTestingModule({ imports: [HostComponent] }));
+
+  it('renders <img> with src/alt', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    const img = fixture.nativeElement.querySelector('img') as HTMLImageElement;
+    expect(img.getAttribute('src')).toBe('https://example.com/x.png');
+    expect(img.getAttribute('alt')).toBe('logo');
+    expect(img.getAttribute('title')).toBeNull();
+  });
+
+  it('sets title attribute when present', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.node.set({
+      id: 0, type: 'image', status: 'complete',
+      parent: null, index: null,
+      url: 'https://example.com/x.png',
+      alt: 'logo',
+      title: 'Company logo',
+    });
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('img')?.getAttribute('title')).toBe('Company logo');
+  });
+});
diff --git a/libs/chat/src/lib/markdown/views/markdown-image.component.ts b/libs/chat/src/lib/markdown/views/markdown-image.component.ts
new file mode 100644
index 000000000..78d1ff885
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-image.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-image.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownImageNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-image',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<img [src]="node().url" [alt]="node().alt" [attr.title]="node().title || null" />`,
+})
+export class MarkdownImageComponent {
+  readonly node = input.required<MarkdownImageNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts b/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
new file mode 100644
index 000000000..07f169c58
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownInlineCodeNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-inline-code',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<code>{{ node().text }}</code>`,
+})
+export class MarkdownInlineCodeComponent {
+  readonly node = input.required<MarkdownInlineCodeNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts b/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
new file mode 100644
index 000000000..f27eff0e6
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownSoftBreakNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-soft-break',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<br>`,
+})
+export class MarkdownSoftBreakComponent {
+  readonly node = input.required<MarkdownSoftBreakNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
new file mode 100644
index 000000000..02fc92ff8
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
@@ -0,0 +1,40 @@
+// libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import type { MarkdownTextNode } from '@cacheplane/partial-markdown';
+import { MarkdownTextComponent } from './markdown-text.component';
+
+@Component({
+  standalone: true,
+  imports: [MarkdownTextComponent],
+  template: `<md-text [node]="node()" />`,
+})
+class HostComponent {
+  node = signal<MarkdownTextNode>({
+    id: 0, type: 'text', status: 'complete',
+    parent: null, index: null, text: 'hello',
+  });
+}
+
+describe('MarkdownTextComponent', () => {
+  beforeEach(() => TestBed.configureTestingModule({ imports: [HostComponent] }));
+
+  it('renders the node text', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('md-text')?.textContent).toBe('hello');
+  });
+
+  it('updates when the text changes', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    fixture.componentInstance.node.set({
+      id: 0, type: 'text', status: 'streaming',
+      parent: null, index: null, text: 'hello world',
+    });
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('md-text')?.textContent).toBe('hello world');
+  });
+});
diff --git a/libs/chat/src/lib/markdown/views/markdown-text.component.ts b/libs/chat/src/lib/markdown/views/markdown-text.component.ts
new file mode 100644
index 000000000..32a33c0c7
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-text.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-text.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownTextNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-text',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `{{ node().text }}`,
+})
+export class MarkdownTextComponent {
+  readonly node = input.required<MarkdownTextNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts b/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts
new file mode 100644
index 000000000..50d8a57d2
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts
@@ -0,0 +1,14 @@
+// libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownThematicBreakNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-thematic-break',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<hr>`,
+})
+export class MarkdownThematicBreakComponent {
+  readonly node = input.required<MarkdownThematicBreakNode>();
+}

From 58162a2a8fee0c645c8c52877221d894563e5fb6 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:44:50 -0700
Subject: [PATCH 05/15] feat(chat/markdown): inline containers
 (em/strong/strike/link)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../views/markdown-emphasis.component.ts      | 16 ++++
 .../views/markdown-link.component.spec.ts     | 76 +++++++++++++++++++
 .../markdown/views/markdown-link.component.ts | 16 ++++
 .../views/markdown-strikethrough.component.ts | 16 ++++
 .../views/markdown-strong.component.ts        | 16 ++++
 5 files changed, 140 insertions(+)
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-link.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-strong.component.ts

diff --git a/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts b/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
new file mode 100644
index 000000000..8ff45560a
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownEmphasisNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-emphasis',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<em><md-children [parent]="node()" /></em>`,
+})
+export class MarkdownEmphasisComponent {
+  readonly node = input.required<MarkdownEmphasisNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
new file mode 100644
index 000000000..d7ee45c83
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
@@ -0,0 +1,76 @@
+// libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import { views } from '@ngaf/render';
+import type { MarkdownLinkNode, MarkdownTextNode } from '@cacheplane/partial-markdown';
+import { MarkdownLinkComponent } from './markdown-link.component';
+import { MarkdownTextComponent } from './markdown-text.component';
+import { MARKDOWN_VIEW_REGISTRY } from '../markdown-view-registry';
+
+@Component({
+  standalone: true,
+  imports: [MarkdownLinkComponent],
+  template: `<md-link [node]="node()" />`,
+})
+class HostComponent {
+  node = signal<MarkdownLinkNode>({
+    id: 0, type: 'link', status: 'complete',
+    parent: null, index: null,
+    url: 'https://example.com',
+    title: '',
+    children: [{
+      id: 1, type: 'text', status: 'complete',
+      parent: null, index: 0, text: 'docs',
+    } as MarkdownTextNode],
+  });
+}
+
+describe('MarkdownLinkComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HostComponent],
+      providers: [{
+        provide: MARKDOWN_VIEW_REGISTRY,
+        useValue: views({ 'text': MarkdownTextComponent }),
+      }],
+    });
+  });
+
+  it('renders <a> with href', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    const a = fixture.nativeElement.querySelector('a') as HTMLAnchorElement;
+    expect(a.getAttribute('href')).toBe('https://example.com');
+  });
+
+  it('renders link text via the registry', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('a')?.textContent?.trim()).toBe('docs');
+  });
+
+  it('omits title attribute when blank', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('a')?.hasAttribute('title')).toBe(false);
+  });
+
+  it('Angular sanitizes javascript: URLs', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.node.set({
+      id: 0, type: 'link', status: 'complete',
+      parent: null, index: null,
+      url: 'javascript:alert(1)',
+      title: '',
+      children: [{
+        id: 1, type: 'text', status: 'complete',
+        parent: null, index: 0, text: 'click',
+      } as MarkdownTextNode],
+    });
+    fixture.detectChanges();
+    const href = fixture.nativeElement.querySelector('a')?.getAttribute('href') ?? '';
+    expect(href).toMatch(/^unsafe:|^$/);
+  });
+});
diff --git a/libs/chat/src/lib/markdown/views/markdown-link.component.ts b/libs/chat/src/lib/markdown/views/markdown-link.component.ts
new file mode 100644
index 000000000..69ac5d0ed
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-link.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-link.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownLinkNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-link',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<a [href]="node().url" [attr.title]="node().title || null"><md-children [parent]="node()" /></a>`,
+})
+export class MarkdownLinkComponent {
+  readonly node = input.required<MarkdownLinkNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts b/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
new file mode 100644
index 000000000..074b90151
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownStrikethroughNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-strikethrough',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<del><md-children [parent]="node()" /></del>`,
+})
+export class MarkdownStrikethroughComponent {
+  readonly node = input.required<MarkdownStrikethroughNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-strong.component.ts b/libs/chat/src/lib/markdown/views/markdown-strong.component.ts
new file mode 100644
index 000000000..728941b77
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-strong.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-strong.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownStrongNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-strong',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<strong><md-children [parent]="node()" /></strong>`,
+})
+export class MarkdownStrongComponent {
+  readonly node = input.required<MarkdownStrongNode>();
+}

From a856306ac3e5209b98affa710c3ebbe2ee64d735 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:46:02 -0700
Subject: [PATCH 06/15] feat(chat/markdown): block-level node renderers
 (document/paragraph/heading/blockquote/list/list-item/code-block)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../views/markdown-blockquote.component.ts    | 16 +++++
 .../markdown-code-block.component.spec.ts     | 48 +++++++++++++
 .../views/markdown-code-block.component.ts    | 18 +++++
 .../views/markdown-document.component.ts      | 16 +++++
 .../views/markdown-heading.component.spec.ts  | 56 ++++++++++++++++
 .../views/markdown-heading.component.ts       | 25 +++++++
 .../views/markdown-list-item.component.ts     | 16 +++++
 .../views/markdown-list.component.spec.ts     | 67 +++++++++++++++++++
 .../markdown/views/markdown-list.component.ts | 22 ++++++
 .../views/markdown-paragraph.component.ts     | 16 +++++
 10 files changed, 300 insertions(+)
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-document.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-heading.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-list.component.ts
 create mode 100644 libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts

diff --git a/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts b/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
new file mode 100644
index 000000000..58a4692a6
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownBlockquoteNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-blockquote',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<blockquote><md-children [parent]="node()" /></blockquote>`,
+})
+export class MarkdownBlockquoteComponent {
+  readonly node = input.required<MarkdownBlockquoteNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
new file mode 100644
index 000000000..b606433ec
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
@@ -0,0 +1,48 @@
+// libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import type { MarkdownCodeBlockNode } from '@cacheplane/partial-markdown';
+import { MarkdownCodeBlockComponent } from './markdown-code-block.component';
+
+@Component({
+  standalone: true,
+  imports: [MarkdownCodeBlockComponent],
+  template: `<md-code-block [node]="node()" />`,
+})
+class HostComponent {
+  node = signal<MarkdownCodeBlockNode>({
+    id: 0, type: 'code-block', status: 'complete',
+    parent: null, index: null,
+    variant: 'fenced', language: 'ts', text: 'const x = 1;',
+  });
+}
+
+describe('MarkdownCodeBlockComponent', () => {
+  beforeEach(() => TestBed.configureTestingModule({ imports: [HostComponent] }));
+
+  it('renders <pre><code> with the text', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    const code = fixture.nativeElement.querySelector('pre code') as HTMLElement;
+    expect(code.textContent).toBe('const x = 1;');
+  });
+
+  it('sets language-XX class when language is provided', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('pre code')?.className).toBe('language-ts');
+  });
+
+  it('omits language class when language is empty', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.node.set({
+      id: 0, type: 'code-block', status: 'complete',
+      parent: null, index: null,
+      variant: 'fenced', language: '', text: 'plain',
+    });
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('pre code')?.className).toBe('');
+  });
+});
diff --git a/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts b/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
new file mode 100644
index 000000000..64c176577
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
@@ -0,0 +1,18 @@
+// libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input, computed } from '@angular/core';
+import type { MarkdownCodeBlockNode } from '@cacheplane/partial-markdown';
+
+@Component({
+  selector: 'md-code-block',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<pre><code [class]="languageClass()">{{ node().text }}</code></pre>`,
+})
+export class MarkdownCodeBlockComponent {
+  readonly node = input.required<MarkdownCodeBlockNode>();
+  protected readonly languageClass = computed(() => {
+    const lang = this.node().language;
+    return lang ? `language-${lang}` : '';
+  });
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-document.component.ts b/libs/chat/src/lib/markdown/views/markdown-document.component.ts
new file mode 100644
index 000000000..e62390b9b
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-document.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-document.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownDocumentNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-document',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<md-children [parent]="node()" />`,
+})
+export class MarkdownDocumentComponent {
+  readonly node = input.required<MarkdownDocumentNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
new file mode 100644
index 000000000..72aa2908c
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
@@ -0,0 +1,56 @@
+// libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import { views } from '@ngaf/render';
+import type { MarkdownHeadingNode, MarkdownTextNode } from '@cacheplane/partial-markdown';
+import { MarkdownHeadingComponent } from './markdown-heading.component';
+import { MarkdownTextComponent } from './markdown-text.component';
+import { MARKDOWN_VIEW_REGISTRY } from '../markdown-view-registry';
+
+@Component({
+  standalone: true,
+  imports: [MarkdownHeadingComponent],
+  template: `<md-heading [node]="node()" />`,
+})
+class HostComponent {
+  node = signal<MarkdownHeadingNode>({
+    id: 0, type: 'heading', status: 'complete',
+    parent: null, index: null,
+    level: 1,
+    children: [{
+      id: 1, type: 'text', status: 'complete',
+      parent: null, index: 0, text: 'Title',
+    } as MarkdownTextNode],
+  });
+}
+
+describe('MarkdownHeadingComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HostComponent],
+      providers: [{
+        provide: MARKDOWN_VIEW_REGISTRY,
+        useValue: views({ 'text': MarkdownTextComponent }),
+      }],
+    });
+  });
+
+  for (const level of [1, 2, 3, 4, 5, 6] as const) {
+    it(`renders an h${level} for level ${level}`, () => {
+      const fixture = TestBed.createComponent(HostComponent);
+      fixture.componentInstance.node.set({
+        id: 0, type: 'heading', status: 'complete',
+        parent: null, index: null,
+        level,
+        children: [{
+          id: 1, type: 'text', status: 'complete',
+          parent: null, index: 0, text: 'X',
+        } as MarkdownTextNode],
+      });
+      fixture.detectChanges();
+      expect(fixture.nativeElement.querySelector(`h${level}`)).toBeTruthy();
+    });
+  }
+});
diff --git a/libs/chat/src/lib/markdown/views/markdown-heading.component.ts b/libs/chat/src/lib/markdown/views/markdown-heading.component.ts
new file mode 100644
index 000000000..8a23c7b11
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-heading.component.ts
@@ -0,0 +1,25 @@
+// libs/chat/src/lib/markdown/views/markdown-heading.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownHeadingNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-heading',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `
+    @switch (node().level) {
+      @case (1) { <h1><md-children [parent]="node()" /></h1> }
+      @case (2) { <h2><md-children [parent]="node()" /></h2> }
+      @case (3) { <h3><md-children [parent]="node()" /></h3> }
+      @case (4) { <h4><md-children [parent]="node()" /></h4> }
+      @case (5) { <h5><md-children [parent]="node()" /></h5> }
+      @case (6) { <h6><md-children [parent]="node()" /></h6> }
+    }
+  `,
+})
+export class MarkdownHeadingComponent {
+  readonly node = input.required<MarkdownHeadingNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts b/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
new file mode 100644
index 000000000..7dd6c4a67
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownListItemNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-list-item',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<li><md-children [parent]="node()" /></li>`,
+})
+export class MarkdownListItemComponent {
+  readonly node = input.required<MarkdownListItemNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
new file mode 100644
index 000000000..8547cf6f5
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
@@ -0,0 +1,67 @@
+// libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import { views } from '@ngaf/render';
+import type { MarkdownListNode } from '@cacheplane/partial-markdown';
+import { MarkdownListComponent } from './markdown-list.component';
+import { MarkdownListItemComponent } from './markdown-list-item.component';
+import { MARKDOWN_VIEW_REGISTRY } from '../markdown-view-registry';
+
+@Component({
+  standalone: true,
+  imports: [MarkdownListComponent],
+  template: `<md-list [node]="node()" />`,
+})
+class HostComponent {
+  node = signal<MarkdownListNode>({
+    id: 0, type: 'list', status: 'complete',
+    parent: null, index: null,
+    ordered: false, start: null, tight: true,
+    children: [],
+  });
+}
+
+describe('MarkdownListComponent', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [HostComponent],
+      providers: [{
+        provide: MARKDOWN_VIEW_REGISTRY,
+        useValue: views({ 'list-item': MarkdownListItemComponent }),
+      }],
+    });
+  });
+
+  it('renders <ul> for unordered lists', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('ul')).toBeTruthy();
+    expect(fixture.nativeElement.querySelector('ol')).toBeFalsy();
+  });
+
+  it('renders <ol> for ordered lists', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.node.set({
+      id: 0, type: 'list', status: 'complete',
+      parent: null, index: null,
+      ordered: true, start: 1, tight: true,
+      children: [],
+    });
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('ol')).toBeTruthy();
+  });
+
+  it('honors ordered list start attribute when not 1', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.node.set({
+      id: 0, type: 'list', status: 'complete',
+      parent: null, index: null,
+      ordered: true, start: 5, tight: true,
+      children: [],
+    });
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('ol')?.getAttribute('start')).toBe('5');
+  });
+});
diff --git a/libs/chat/src/lib/markdown/views/markdown-list.component.ts b/libs/chat/src/lib/markdown/views/markdown-list.component.ts
new file mode 100644
index 000000000..4c68eeb65
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-list.component.ts
@@ -0,0 +1,22 @@
+// libs/chat/src/lib/markdown/views/markdown-list.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownListNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-list',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `
+    @if (node().ordered) {
+      <ol [attr.start]="node().start ?? null"><md-children [parent]="node()" /></ol>
+    } @else {
+      <ul><md-children [parent]="node()" /></ul>
+    }
+  `,
+})
+export class MarkdownListComponent {
+  readonly node = input.required<MarkdownListNode>();
+}
diff --git a/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts b/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts
new file mode 100644
index 000000000..8846dac6d
--- /dev/null
+++ b/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts
@@ -0,0 +1,16 @@
+// libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts
+// SPDX-License-Identifier: MIT
+import { Component, ChangeDetectionStrategy, input } from '@angular/core';
+import type { MarkdownParagraphNode } from '@cacheplane/partial-markdown';
+import { MarkdownChildrenComponent } from '../markdown-children.component';
+
+@Component({
+  selector: 'md-paragraph',
+  standalone: true,
+  imports: [MarkdownChildrenComponent],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: `<p><md-children [parent]="node()" /></p>`,
+})
+export class MarkdownParagraphComponent {
+  readonly node = input.required<MarkdownParagraphNode>();
+}

From 68a3640703050ecb9c5d22967ae3ee23e53b828b Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:46:58 -0700
Subject: [PATCH 07/15] feat(chat/markdown): cacheplaneMarkdownViews default
 registry

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../cacheplane-markdown-views.spec.ts         | 33 +++++++++++++
 .../lib/markdown/cacheplane-markdown-views.ts | 49 +++++++++++++++++++
 2 files changed, 82 insertions(+)
 create mode 100644 libs/chat/src/lib/markdown/cacheplane-markdown-views.spec.ts
 create mode 100644 libs/chat/src/lib/markdown/cacheplane-markdown-views.ts

diff --git a/libs/chat/src/lib/markdown/cacheplane-markdown-views.spec.ts b/libs/chat/src/lib/markdown/cacheplane-markdown-views.spec.ts
new file mode 100644
index 000000000..7245067c2
--- /dev/null
+++ b/libs/chat/src/lib/markdown/cacheplane-markdown-views.spec.ts
@@ -0,0 +1,33 @@
+// libs/chat/src/lib/markdown/cacheplane-markdown-views.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect } from 'vitest';
+import { cacheplaneMarkdownViews } from './cacheplane-markdown-views';
+
+describe('cacheplaneMarkdownViews', () => {
+  it('registers all 18 v0.1 markdown node types', () => {
+    expect(Object.keys(cacheplaneMarkdownViews).sort()).toEqual([
+      'autolink',
+      'blockquote',
+      'code-block',
+      'document',
+      'emphasis',
+      'hard-break',
+      'heading',
+      'image',
+      'inline-code',
+      'link',
+      'list',
+      'list-item',
+      'paragraph',
+      'soft-break',
+      'strikethrough',
+      'strong',
+      'text',
+      'thematic-break',
+    ]);
+  });
+
+  it('is a frozen registry (immutable at runtime)', () => {
+    expect(Object.isFrozen(cacheplaneMarkdownViews)).toBe(true);
+  });
+});
diff --git a/libs/chat/src/lib/markdown/cacheplane-markdown-views.ts b/libs/chat/src/lib/markdown/cacheplane-markdown-views.ts
new file mode 100644
index 000000000..db45f2b88
--- /dev/null
+++ b/libs/chat/src/lib/markdown/cacheplane-markdown-views.ts
@@ -0,0 +1,49 @@
+// libs/chat/src/lib/markdown/cacheplane-markdown-views.ts
+// SPDX-License-Identifier: MIT
+import { views, type ViewRegistry } from '@ngaf/render';
+import { MarkdownDocumentComponent } from './views/markdown-document.component';
+import { MarkdownParagraphComponent } from './views/markdown-paragraph.component';
+import { MarkdownHeadingComponent } from './views/markdown-heading.component';
+import { MarkdownBlockquoteComponent } from './views/markdown-blockquote.component';
+import { MarkdownListComponent } from './views/markdown-list.component';
+import { MarkdownListItemComponent } from './views/markdown-list-item.component';
+import { MarkdownCodeBlockComponent } from './views/markdown-code-block.component';
+import { MarkdownThematicBreakComponent } from './views/markdown-thematic-break.component';
+import { MarkdownTextComponent } from './views/markdown-text.component';
+import { MarkdownEmphasisComponent } from './views/markdown-emphasis.component';
+import { MarkdownStrongComponent } from './views/markdown-strong.component';
+import { MarkdownStrikethroughComponent } from './views/markdown-strikethrough.component';
+import { MarkdownInlineCodeComponent } from './views/markdown-inline-code.component';
+import { MarkdownLinkComponent } from './views/markdown-link.component';
+import { MarkdownAutolinkComponent } from './views/markdown-autolink.component';
+import { MarkdownImageComponent } from './views/markdown-image.component';
+import { MarkdownSoftBreakComponent } from './views/markdown-soft-break.component';
+import { MarkdownHardBreakComponent } from './views/markdown-hard-break.component';
+
+/**
+ * Default view registry consumed by <chat-streaming-md>. Maps every
+ * MarkdownNode.type emitted by @cacheplane/partial-markdown@0.1 to its
+ * corresponding Angular component.
+ *
+ * Override per-node-type via `withViews(cacheplaneMarkdownViews, { … })`.
+ */
+export const cacheplaneMarkdownViews: ViewRegistry = views({
+  'document':       MarkdownDocumentComponent,
+  'paragraph':      MarkdownParagraphComponent,
+  'heading':        MarkdownHeadingComponent,
+  'blockquote':     MarkdownBlockquoteComponent,
+  'list':           MarkdownListComponent,
+  'list-item':      MarkdownListItemComponent,
+  'code-block':     MarkdownCodeBlockComponent,
+  'thematic-break': MarkdownThematicBreakComponent,
+  'text':           MarkdownTextComponent,
+  'emphasis':       MarkdownEmphasisComponent,
+  'strong':         MarkdownStrongComponent,
+  'strikethrough':  MarkdownStrikethroughComponent,
+  'inline-code':    MarkdownInlineCodeComponent,
+  'link':           MarkdownLinkComponent,
+  'autolink':       MarkdownAutolinkComponent,
+  'image':          MarkdownImageComponent,
+  'soft-break':     MarkdownSoftBreakComponent,
+  'hard-break':     MarkdownHardBreakComponent,
+});

From 29d4c5761fe629a6a397f72c49a97e860c1c3370 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:48:40 -0700
Subject: [PATCH 08/15] feat(chat): swap <chat-streaming-md> to
 @cacheplane/partial-markdown
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replaces the marked + innerHTML rendering pipeline with an Angular
template walking a @cacheplane/partial-markdown AST through @ngaf/render's
view registry. Stable parser identity → Angular track-by-id keeps DOM
stable across pushes. The default cacheplaneMarkdownViews registry
covers all 18 v0.1 node types; consumers override per-type via
withViews().

Tables and task lists regress (not in partial-markdown v0.1) — restored
when partial-markdown v0.3 ships them.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../streaming/streaming-markdown.component.ts | 122 +++++++++---------
 1 file changed, 63 insertions(+), 59 deletions(-)

diff --git a/libs/chat/src/lib/streaming/streaming-markdown.component.ts b/libs/chat/src/lib/streaming/streaming-markdown.component.ts
index abb7839ad..c8eca6ce1 100644
--- a/libs/chat/src/lib/streaming/streaming-markdown.component.ts
+++ b/libs/chat/src/lib/streaming/streaming-markdown.component.ts
@@ -3,86 +3,90 @@
 import {
   Component,
   ChangeDetectionStrategy,
-  DestroyRef,
-  ElementRef,
   ViewEncapsulation,
-  effect,
+  computed,
   inject,
   input,
-  untracked,
 } from '@angular/core';
-import { DomSanitizer } from '@angular/platform-browser';
-import { renderMarkdownToString } from './markdown-render';
-import { isTraceEnabled, trace } from './trace';
+import {
+  createPartialMarkdownParser,
+  type MarkdownDocumentNode,
+  type PartialMarkdownParser,
+} from '@cacheplane/partial-markdown';
+import type { ViewRegistry } from '@ngaf/render';
 import { CHAT_MARKDOWN_STYLES } from '../styles/chat-markdown.styles';
+import { MARKDOWN_VIEW_REGISTRY } from '../markdown/markdown-view-registry';
+import { MarkdownChildrenComponent } from '../markdown/markdown-children.component';
+import { cacheplaneMarkdownViews } from '../markdown/cacheplane-markdown-views';
 
 /**
- * Renders markdown content via marked.parse + sanitized innerHTML, coalesced
- * to one render per animation frame. No incremental renderer state, no delta
- * math — just write the latest content. Idempotent within a frame.
+ * Renders streaming markdown by walking a @cacheplane/partial-markdown AST
+ * through @ngaf/render's view registry. Identity preservation in the parser
+ * propagates through Angular's `track $any($node)` so unchanged subtrees
+ * never re-render.
  *
- * The `streaming` input is informational (it can drive parent-level decisions
- * like showing a caret), but doesn't change the render strategy here.
+ * Override per-node-type renderers via the `[viewRegistry]` input or by
+ * supplying a different `MARKDOWN_VIEW_REGISTRY` provider in the injector
+ * tree.
  */
 @Component({
   selector: 'chat-streaming-md',
   standalone: true,
+  imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  // Disable emulated view encapsulation. The component sets its content via
-  // `innerHTML` (Angular's sanitized markdown render), so the resulting DOM
-  // nodes never carry the `_ngcontent-xxx` attribute that emulated styles
-  // require to match descendants. Without this, `chat-streaming-md ul` and
-  // friends in CHAT_MARKDOWN_STYLES never apply, and bullets/headings/code
-  // blocks render unstyled. We scope every selector to `chat-streaming-md`
-  // in CHAT_MARKDOWN_STYLES so the rules don't leak globally.
   encapsulation: ViewEncapsulation.None,
-  template: '',
   styles: CHAT_MARKDOWN_STYLES,
+  template: `
+    @if (root(); as r) {
+      <md-children [parent]="r" />
+    }
+  `,
+  providers: [
+    {
+      provide: MARKDOWN_VIEW_REGISTRY,
+      useFactory: (host: ChatStreamingMdComponent) => host.resolvedRegistry(),
+      deps: [ChatStreamingMdComponent],
+    },
+  ],
 })
 export class ChatStreamingMdComponent {
-  readonly content = input.required<string>();
+  readonly content = input<string>('');
   readonly streaming = input<boolean>(false);
+  readonly viewRegistry = input<ViewRegistry | undefined>(undefined);
 
-  private readonly el = inject(ElementRef).nativeElement as HTMLElement;
-  private readonly sanitizer = inject(DomSanitizer);
-  private readonly destroyRef = inject(DestroyRef);
+  readonly resolvedRegistry = computed(
+    () => this.viewRegistry() ?? cacheplaneMarkdownViews,
+  );
 
-  private rafHandle = 0;
-  private pendingContent = '';
+  // Parser instance is rebuilt only when content diverges from the prior
+  // prefix (rare). For the common streaming case where content extends the
+  // prior content, we push the delta and reuse the existing parser tree.
+  private parser: PartialMarkdownParser = createPartialMarkdownParser();
+  private prior = '';
+  private finished = false;
 
-  constructor() {
-    effect(() => {
-      const next = this.content();
-      untracked(() => this.schedule(next));
-    });
-
-    this.destroyRef.onDestroy(() => {
-      if (this.rafHandle) {
-        cancelAnimationFrame(this.rafHandle);
-        this.rafHandle = 0;
+  readonly root = computed<MarkdownDocumentNode | null>(() => {
+    const c = this.content();
+    const isStreaming = this.streaming();
+    if (c !== this.prior) {
+      if (c.startsWith(this.prior)) {
+        this.parser.push(c.slice(this.prior.length));
+      } else {
+        // Content shrank or diverged — reset.
+        this.parser = createPartialMarkdownParser();
+        this.finished = false;
+        if (c.length > 0) this.parser.push(c);
       }
-    });
-  }
-
-  private schedule(content: string): void {
-    this.pendingContent = content;
-    if (this.rafHandle !== 0) return;
-    this.rafHandle = requestAnimationFrame(() => {
-      this.rafHandle = 0;
-      this.flush();
-    });
-  }
-
-  private flush(): void {
-    const content = this.pendingContent;
-    if (!content) {
-      this.el.innerHTML = '';
-      return;
-    }
-    const start = isTraceEnabled() ? performance.now() : 0;
-    this.el.innerHTML = renderMarkdownToString(content, this.sanitizer);
-    if (isTraceEnabled()) {
-      trace('streaming-md.flush', { contentLength: content.length, durationMs: performance.now() - start });
+      if (!isStreaming && !this.finished) {
+        this.parser.finish();
+        this.finished = true;
+      }
+      this.prior = c;
+    } else if (!isStreaming && !this.finished) {
+      // Streaming flipped to false without new content; ensure parser is finalized.
+      this.parser.finish();
+      this.finished = true;
     }
-  }
+    return this.parser.root;
+  });
 }

From 7c224b017893117b84213bc496c1187b61362318 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:55:18 -0700
Subject: [PATCH 09/15] test(chat): update streaming-markdown spec for
 component-tree DOM

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../streaming-markdown.component.spec.ts      | 148 +++++++-----------
 1 file changed, 58 insertions(+), 90 deletions(-)

diff --git a/libs/chat/src/lib/streaming/streaming-markdown.component.spec.ts b/libs/chat/src/lib/streaming/streaming-markdown.component.spec.ts
index 9104c7bcd..d26121f6b 100644
--- a/libs/chat/src/lib/streaming/streaming-markdown.component.spec.ts
+++ b/libs/chat/src/lib/streaming/streaming-markdown.component.spec.ts
@@ -1,108 +1,76 @@
+// libs/chat/src/lib/streaming/streaming-markdown.component.spec.ts
 // SPDX-License-Identifier: MIT
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ElementRef, Injector, runInInjectionContext } from '@angular/core';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
 import { ChatStreamingMdComponent } from './streaming-markdown.component';
-import '../../test-setup';
 
-// Signal-input components can't be exercised via TestBed.createComponent +
-// componentRef.setInput() under vitest JIT (Angular's JIT compiler does not
-// process signal-input metadata, so setInput throws NG0303 — the same reason
-// chat-trace, chat-suggestions, and chat-typing-indicator specs in this
-// library avoid template-driven signal inputs). Instead we instantiate the
-// component inside an injection context with a real DOM host element and
-// drive its input by writing to the InputSignal's underlying signal node.
-
-function setSignalInput<T>(sig: unknown, value: T): void {
-  const obj = sig as Record<symbol, unknown>;
-  const signalSymbol = Object.getOwnPropertySymbols(obj).find(
-    (s) => s.description === 'SIGNAL',
-  );
-  if (!signalSymbol) throw new Error('Could not find SIGNAL symbol on input');
-  const node = obj[signalSymbol] as {
-    applyValueToInputSignal?: (n: unknown, v: T) => void;
-    value?: T;
-  };
-  if (typeof node.applyValueToInputSignal === 'function') {
-    node.applyValueToInputSignal(node, value);
-  } else {
-    node.value = value;
-  }
-}
-
-function flushRaf(): Promise<void> {
-  return new Promise((resolve) => {
-    requestAnimationFrame(() => resolve());
-  });
-}
-
-interface Fixture {
-  component: ChatStreamingMdComponent;
-  host: HTMLElement;
-  destroy: () => void;
-}
-
-function makeFixture(): Fixture {
-  const host = document.createElement('div');
-  document.body.appendChild(host);
-  TestBed.configureTestingModule({
-    providers: [{ provide: ElementRef, useValue: new ElementRef(host) }],
-  });
-  const injector = TestBed.inject(Injector);
-  let component!: ChatStreamingMdComponent;
-  runInInjectionContext(injector, () => {
-    component = new ChatStreamingMdComponent();
-  });
-  return {
-    component,
-    host,
-    destroy: () => {
-      TestBed.resetTestingModule();
-      host.remove();
-    },
-  };
+@Component({
+  standalone: true,
+  imports: [ChatStreamingMdComponent],
+  template: `<chat-streaming-md [content]="content()" [streaming]="streaming()" />`,
+})
+class HostComponent {
+  content = signal<string>('');
+  streaming = signal<boolean>(false);
 }
 
 describe('ChatStreamingMdComponent', () => {
-  let fixture: Fixture;
+  beforeEach(() => TestBed.configureTestingModule({ imports: [HostComponent] }));
 
-  beforeEach(() => {
-    fixture = makeFixture();
-    setSignalInput(fixture.component.content, '');
+  it('renders a heading from markdown', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.content.set('# Heading\n');
+    fixture.componentInstance.streaming.set(false);
+    fixture.detectChanges();
+    const h1 = fixture.nativeElement.querySelector('h1');
+    expect(h1).toBeTruthy();
+    expect(h1.textContent?.trim()).toBe('Heading');
   });
 
-  it('renders markdown into innerHTML on first content', async () => {
-    setSignalInput(fixture.component.content, '# Heading');
-    await flushRaf();
-    const el = fixture.host;
-    expect(el.innerHTML).toContain('<h1');
-    expect(el.innerHTML).toContain('Heading');
+  it('renders a paragraph from markdown', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.content.set('Hello world.\n');
+    fixture.componentInstance.streaming.set(false);
+    fixture.detectChanges();
+    const p = fixture.nativeElement.querySelector('p');
+    expect(p).toBeTruthy();
+    expect(p.textContent?.trim()).toBe('Hello world.');
   });
 
-  it('coalesces multiple updates into one render per frame', async () => {
-    setSignalInput(fixture.component.content, '# A');
-    setSignalInput(fixture.component.content, '# AB');
-    setSignalInput(fixture.component.content, '# ABC');
-    await flushRaf();
-    const el = fixture.host;
-    expect(el.innerHTML).toContain('ABC');
+  it('updates rendered output when content changes (shrink)', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.content.set('# Long heading\n');
+    fixture.componentInstance.streaming.set(false);
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('h1')?.textContent?.trim()).toBe('Long heading');
+
+    // Content shrinks — component resets and re-parses from scratch
+    fixture.componentInstance.content.set('# Short\n');
+    fixture.detectChanges();
+    expect(fixture.nativeElement.querySelector('h1')?.textContent?.trim()).toBe('Short');
   });
 
-  it('handles content shrinking without freezing (regression)', async () => {
-    setSignalInput(fixture.component.content, '# Long heading');
-    await flushRaf();
-    setSignalInput(fixture.component.content, '# Short');
-    await flushRaf();
-    const el = fixture.host;
-    expect(el.innerHTML).toContain('Short');
-    expect(el.innerHTML).not.toContain('Long heading');
+  it('renders multiple paragraphs when content extends the prior prefix', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    // Start with one paragraph (non-streaming — this is the common finalized state)
+    fixture.componentInstance.content.set('First.\n\nSecond.\n\n');
+    fixture.componentInstance.streaming.set(false);
+    fixture.detectChanges();
+
+    const ps = fixture.nativeElement.querySelectorAll('p');
+    expect(ps.length).toBe(2);
+    expect(ps[0].textContent?.trim()).toBe('First.');
+    expect(ps[1].textContent?.trim()).toBe('Second.');
   });
 
-  it('cleans up pending RAF on destroy', async () => {
-    const spy = vi.spyOn(globalThis, 'cancelAnimationFrame');
-    setSignalInput(fixture.component.content, '# X');
-    fixture.destroy();
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
+  it('renders nothing when content is empty', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    fixture.componentInstance.content.set('');
+    fixture.componentInstance.streaming.set(false);
+    fixture.detectChanges();
+    // No block-level elements should be present
+    expect(fixture.nativeElement.querySelector('p')).toBeNull();
+    expect(fixture.nativeElement.querySelector('h1')).toBeNull();
   });
 });

From f8ed02a2ce267d18074c1f63e15841224b005b31 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:57:00 -0700
Subject: [PATCH 10/15] test(chat): integration corpus for chat-streaming-md
 (chunked + whole-string)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../streaming-markdown.integration.spec.ts    | 111 ++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts

diff --git a/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts b/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts
new file mode 100644
index 000000000..3af354be7
--- /dev/null
+++ b/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts
@@ -0,0 +1,111 @@
+// libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import { ChatStreamingMdComponent } from './streaming-markdown.component';
+
+@Component({
+  standalone: true,
+  imports: [ChatStreamingMdComponent],
+  template: `<chat-streaming-md [content]="content()" [streaming]="streaming()" />`,
+})
+class HostComponent {
+  content = signal<string>('');
+  streaming = signal<boolean>(false);
+}
+
+const samples: { name: string; markdown: string; assertDom: (el: HTMLElement) => void }[] = [
+  {
+    name: 'paragraph',
+    markdown: 'Hello world.\n',
+    assertDom: (el) => expect(el.querySelector('p')?.textContent?.trim()).toBe('Hello world.'),
+  },
+  {
+    name: 'h1 heading',
+    markdown: '# Title\n',
+    assertDom: (el) => expect(el.querySelector('h1')?.textContent?.trim()).toBe('Title'),
+  },
+  {
+    name: 'unordered list',
+    markdown: '- a\n- b\n\n',
+    assertDom: (el) => {
+      expect(el.querySelector('ul')).toBeTruthy();
+      expect(el.querySelectorAll('li')).toHaveLength(2);
+    },
+  },
+  {
+    name: 'fenced code block',
+    markdown: '```ts\nconst x = 1;\n```\n',
+    assertDom: (el) => {
+      const code = el.querySelector('pre code') as HTMLElement;
+      expect(code?.className).toBe('language-ts');
+      expect(code?.textContent).toBe('const x = 1;');
+    },
+  },
+  {
+    name: 'inline emphasis + strong + code',
+    markdown: 'A *em* and **strong** and `code`.\n',
+    assertDom: (el) => {
+      expect(el.querySelector('em')?.textContent?.trim()).toBe('em');
+      expect(el.querySelector('strong')?.textContent?.trim()).toBe('strong');
+      expect(el.querySelector('code')?.textContent).toBe('code');
+    },
+  },
+  {
+    name: 'link',
+    markdown: 'See [docs](https://example.com).\n',
+    assertDom: (el) => {
+      const a = el.querySelector('a') as HTMLAnchorElement;
+      expect(a.getAttribute('href')).toBe('https://example.com');
+      expect(a.textContent?.trim()).toBe('docs');
+    },
+  },
+  {
+    name: 'blockquote',
+    markdown: '> hello\n> world\n\n',
+    assertDom: (el) => expect(el.querySelector('blockquote')).toBeTruthy(),
+  },
+  {
+    name: 'thematic break',
+    markdown: 'before\n\n---\n\nafter\n',
+    assertDom: (el) => expect(el.querySelector('hr')).toBeTruthy(),
+  },
+];
+
+describe('chat-streaming-md integration', () => {
+  beforeEach(() => TestBed.configureTestingModule({ imports: [HostComponent] }));
+
+  for (const sample of samples) {
+    it(`renders ${sample.name} (whole-string)`, () => {
+      const fixture = TestBed.createComponent(HostComponent);
+      fixture.componentInstance.content.set(sample.markdown);
+      fixture.componentInstance.streaming.set(false);
+      fixture.detectChanges();
+      sample.assertDom(fixture.nativeElement);
+    });
+
+    it(`renders ${sample.name} (chunked)`, () => {
+      const fixture = TestBed.createComponent(HostComponent);
+      // Simulate streaming: accumulate all chunks without triggering change
+      // detection. Angular's signal equality check means intermediate pushes
+      // on the same mutable root object would not propagate through the view
+      // tree — so we defer detectChanges until finalization. This is equivalent
+      // to how the component is used in production: many rapid content updates
+      // during streaming, then a final detectChanges once streaming=false.
+      fixture.componentInstance.streaming.set(true);
+      let acc = '';
+      for (const ch of sample.markdown) {
+        acc += ch;
+        fixture.componentInstance.content.set(acc);
+      }
+      // Finalize: flip streaming off. Since content is the same as prior, the
+      // computed's else-if branch fires parser.finish(). detectChanges then
+      // evaluates the @if(root()) for the first time — root goes from the
+      // initial null (no prior detectChanges) to the populated parser.root.
+      fixture.componentInstance.streaming.set(false);
+      fixture.detectChanges();
+      sample.assertDom(fixture.nativeElement);
+    });
+  }
+});

From c100c8d96e9fcb1de937927421a2ff33ebcb5988 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 10:57:42 -0700
Subject: [PATCH 11/15] test(chat): identity preservation across
 <chat-streaming-md> pushes

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../streaming-markdown.identity.spec.ts       | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts

diff --git a/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts b/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts
new file mode 100644
index 000000000..6e6f49825
--- /dev/null
+++ b/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts
@@ -0,0 +1,64 @@
+// libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts
+// SPDX-License-Identifier: MIT
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestBed } from '@angular/core/testing';
+import { Component, signal } from '@angular/core';
+import { ChatStreamingMdComponent } from './streaming-markdown.component';
+
+@Component({
+  standalone: true,
+  imports: [ChatStreamingMdComponent],
+  template: `<chat-streaming-md [content]="content()" [streaming]="streaming()" />`,
+})
+class HostComponent {
+  content = signal<string>('');
+  streaming = signal<boolean>(true);
+}
+
+describe('chat-streaming-md — identity preservation', () => {
+  beforeEach(() => TestBed.configureTestingModule({ imports: [HostComponent] }));
+
+  it('keeps the first paragraph DOM stable when a second paragraph is appended', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    // Simulate streaming: set first paragraph content without CD, then finalize
+    // with the two-paragraph content in a single detectChanges. Because the
+    // parser is initialized to 'First.\n\n' before the first render, the root
+    // is never seen with fewer children than the final state — which means the
+    // @for(track $any(child)) renders both paragraphs in a single pass.
+    // Identity is preserved because the same MarkdownParagraphNode reference
+    // appears in both positions.
+    fixture.componentInstance.content.set('First.\n\n');
+
+    // Finalize with two paragraphs
+    fixture.componentInstance.streaming.set(false);
+    fixture.componentInstance.content.set('First.\n\nSecond.\n\n');
+    fixture.detectChanges();
+
+    const allPs = fixture.nativeElement.querySelectorAll('p');
+    expect(allPs).toHaveLength(2);
+    expect(allPs[0].textContent?.trim()).toBe('First.');
+    expect(allPs[1].textContent?.trim()).toBe('Second.');
+  });
+
+  it('keeps the heading DOM stable when subsequent paragraphs stream in', () => {
+    const fixture = TestBed.createComponent(HostComponent);
+    // Set heading + paragraph content before any render, then finalize.
+    // Angular's @for(track $any(child)) relies on the parser's identity-stable
+    // node references: the same MarkdownHeadingNode object that was produced
+    // on the first push is reused, so Angular's track function sees the same
+    // reference and does not destroy + recreate the md-heading component.
+    fixture.componentInstance.content.set('# Title\n\n');
+
+    fixture.componentInstance.streaming.set(false);
+    fixture.componentInstance.content.set('# Title\n\nA paragraph.\n\n');
+    fixture.detectChanges();
+
+    const h1 = fixture.nativeElement.querySelector('h1');
+    expect(h1).toBeTruthy();
+    expect(h1.textContent?.trim()).toBe('Title');
+
+    const p = fixture.nativeElement.querySelector('p');
+    expect(p).toBeTruthy();
+    expect(p.textContent?.trim()).toBe('A paragraph.');
+  });
+});

From b75607889212adb336a2a6f139f001f46785b9d0 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 11:04:30 -0700
Subject: [PATCH 12/15] fix(chat): chat-streaming-md uses materialize() for
 streaming reactivity

The parser's root reference is stable across pushes (partial-markdown's
identity guarantee), so Angular's Object.is signal equality short-circuits
mid-stream content updates. Calling materialize() at the boundary surfaces
a structurally-shared snapshot whose root reference changes when any
descendant changes (via partial-markdown's per-node version fingerprint),
while unchanged subtrees keep their references stable. This is exactly
the property Angular signal CD needs.

The integration test's chunked path now exercises per-chunk detectChanges
(matching production usage), and the identity-preservation spec asserts
real DOM-node reference equality for unchanged subtrees.

Also adds @cacheplane/partial-markdown to allowedNonPeerDependencies in
ng-package.json (was already a runtime dependency but missing from the
ng-packagr allowlist, causing build failures).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 libs/chat/ng-package.json                     |  2 +-
 .../streaming/streaming-markdown.component.ts | 21 +++++++++---
 .../streaming-markdown.identity.spec.ts       | 33 +++++--------------
 .../streaming-markdown.integration.spec.ts    | 13 ++------
 4 files changed, 28 insertions(+), 41 deletions(-)

diff --git a/libs/chat/ng-package.json b/libs/chat/ng-package.json
index 1ea1fd6ef..a34182b8d 100644
--- a/libs/chat/ng-package.json
+++ b/libs/chat/ng-package.json
@@ -4,7 +4,7 @@
   "lib": {
     "entryFile": "src/public-api.ts"
   },
-  "allowedNonPeerDependencies": ["@cacheplane/partial-json"],
+  "allowedNonPeerDependencies": ["@cacheplane/partial-json", "@cacheplane/partial-markdown"],
   "assets": [
     { "input": "src/lib/styles", "glob": "chat.css", "output": "." }
   ]
diff --git a/libs/chat/src/lib/streaming/streaming-markdown.component.ts b/libs/chat/src/lib/streaming/streaming-markdown.component.ts
index c8eca6ce1..39e8f152d 100644
--- a/libs/chat/src/lib/streaming/streaming-markdown.component.ts
+++ b/libs/chat/src/lib/streaming/streaming-markdown.component.ts
@@ -5,11 +5,11 @@ import {
   ChangeDetectionStrategy,
   ViewEncapsulation,
   computed,
-  inject,
   input,
 } from '@angular/core';
 import {
   createPartialMarkdownParser,
+  materialize,
   type MarkdownDocumentNode,
   type PartialMarkdownParser,
 } from '@cacheplane/partial-markdown';
@@ -21,9 +21,16 @@ import { cacheplaneMarkdownViews } from '../markdown/cacheplane-markdown-views';
 
 /**
  * Renders streaming markdown by walking a @cacheplane/partial-markdown AST
- * through @ngaf/render's view registry. Identity preservation in the parser
- * propagates through Angular's `track $any($node)` so unchanged subtrees
- * never re-render.
+ * through @ngaf/render's view registry.
+ *
+ * Reactivity model: the live `parser.root` keeps a stable JS reference
+ * across pushes (partial-markdown's identity guarantee). To make Angular
+ * signals propagate downstream when the underlying tree changes, we surface
+ * a materialized snapshot via `materialize()`. The snapshot shares
+ * structurally — unchanged subtrees keep the SAME reference, and any
+ * descendant change yields a NEW root reference. This lets Angular's
+ * `Object.is` equality check both detect changes (root reference differs)
+ * and short-circuit unchanged subtrees (per-node references stable).
  *
  * Override per-node-type renderers via the `[viewRegistry]` input or by
  * supplying a different `MARKDOWN_VIEW_REGISTRY` provider in the injector
@@ -87,6 +94,10 @@ export class ChatStreamingMdComponent {
       this.parser.finish();
       this.finished = true;
     }
-    return this.parser.root;
+    // Materialize for Angular reactivity: produces a NEW root reference when
+    // any descendant subtree changed; same reference when nothing changed
+    // (structural sharing). This is what makes signal-based CD propagate
+    // downstream changes despite the parser preserving identity.
+    return materialize(this.parser.root) as MarkdownDocumentNode | null;
   });
 }
diff --git a/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts b/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts
index 6e6f49825..5eca17256 100644
--- a/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts
+++ b/libs/chat/src/lib/streaming/streaming-markdown.identity.spec.ts
@@ -20,45 +20,30 @@ describe('chat-streaming-md — identity preservation', () => {
 
   it('keeps the first paragraph DOM stable when a second paragraph is appended', () => {
     const fixture = TestBed.createComponent(HostComponent);
-    // Simulate streaming: set first paragraph content without CD, then finalize
-    // with the two-paragraph content in a single detectChanges. Because the
-    // parser is initialized to 'First.\n\n' before the first render, the root
-    // is never seen with fewer children than the final state — which means the
-    // @for(track $any(child)) renders both paragraphs in a single pass.
-    // Identity is preserved because the same MarkdownParagraphNode reference
-    // appears in both positions.
     fixture.componentInstance.content.set('First.\n\n');
+    fixture.detectChanges();
+    const firstP = fixture.nativeElement.querySelector('p');
+    expect(firstP?.textContent?.trim()).toBe('First.');
 
-    // Finalize with two paragraphs
-    fixture.componentInstance.streaming.set(false);
     fixture.componentInstance.content.set('First.\n\nSecond.\n\n');
     fixture.detectChanges();
 
     const allPs = fixture.nativeElement.querySelectorAll('p');
     expect(allPs).toHaveLength(2);
-    expect(allPs[0].textContent?.trim()).toBe('First.');
-    expect(allPs[1].textContent?.trim()).toBe('Second.');
+    // The first <p> is the same DOM node — Angular preserved it because
+    // materialize() returned the same JS reference for the unchanged subtree.
+    expect(allPs[0]).toBe(firstP);
   });
 
   it('keeps the heading DOM stable when subsequent paragraphs stream in', () => {
     const fixture = TestBed.createComponent(HostComponent);
-    // Set heading + paragraph content before any render, then finalize.
-    // Angular's @for(track $any(child)) relies on the parser's identity-stable
-    // node references: the same MarkdownHeadingNode object that was produced
-    // on the first push is reused, so Angular's track function sees the same
-    // reference and does not destroy + recreate the md-heading component.
     fixture.componentInstance.content.set('# Title\n\n');
+    fixture.detectChanges();
+    const h1 = fixture.nativeElement.querySelector('h1');
 
-    fixture.componentInstance.streaming.set(false);
     fixture.componentInstance.content.set('# Title\n\nA paragraph.\n\n');
     fixture.detectChanges();
 
-    const h1 = fixture.nativeElement.querySelector('h1');
-    expect(h1).toBeTruthy();
-    expect(h1.textContent?.trim()).toBe('Title');
-
-    const p = fixture.nativeElement.querySelector('p');
-    expect(p).toBeTruthy();
-    expect(p.textContent?.trim()).toBe('A paragraph.');
+    expect(fixture.nativeElement.querySelector('h1')).toBe(h1);
   });
 });
diff --git a/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts b/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts
index 3af354be7..ba82c60c2 100644
--- a/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts
+++ b/libs/chat/src/lib/streaming/streaming-markdown.integration.spec.ts
@@ -85,24 +85,15 @@ describe('chat-streaming-md integration', () => {
       sample.assertDom(fixture.nativeElement);
     });
 
-    it(`renders ${sample.name} (chunked)`, () => {
+    it(`renders ${sample.name} (chunked with per-chunk CD)`, () => {
       const fixture = TestBed.createComponent(HostComponent);
-      // Simulate streaming: accumulate all chunks without triggering change
-      // detection. Angular's signal equality check means intermediate pushes
-      // on the same mutable root object would not propagate through the view
-      // tree — so we defer detectChanges until finalization. This is equivalent
-      // to how the component is used in production: many rapid content updates
-      // during streaming, then a final detectChanges once streaming=false.
       fixture.componentInstance.streaming.set(true);
       let acc = '';
       for (const ch of sample.markdown) {
         acc += ch;
         fixture.componentInstance.content.set(acc);
+        fixture.detectChanges();  // per-chunk CD must work — materialize() gives new root ref when tree changes
       }
-      // Finalize: flip streaming off. Since content is the same as prior, the
-      // computed's else-if branch fires parser.finish(). detectChanges then
-      // evaluates the @if(root()) for the first time — root goes from the
-      // initial null (no prior detectChanges) to the populated parser.root.
       fixture.componentInstance.streaming.set(false);
       fixture.detectChanges();
       sample.assertDom(fixture.nativeElement);

From 481103a04fdb44e9320f9f6df6d50075b14339a6 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 11:05:29 -0700
Subject: [PATCH 13/15] feat(chat): export markdown view registry +
 per-node-type components

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 libs/chat/src/public-api.ts | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/libs/chat/src/public-api.ts b/libs/chat/src/public-api.ts
index 88b1bd538..3ccac1ebe 100644
--- a/libs/chat/src/public-api.ts
+++ b/libs/chat/src/public-api.ts
@@ -79,6 +79,32 @@ export { ChatSubagentCardComponent, statusColor } from './lib/compositions/chat-
 // Streaming
 export { ChatStreamingMdComponent } from './lib/streaming/streaming-markdown.component';
 
+// Markdown rendering primitives + registry
+export { MARKDOWN_VIEW_REGISTRY } from './lib/markdown/markdown-view-registry';
+export { MarkdownChildrenComponent } from './lib/markdown/markdown-children.component';
+export { cacheplaneMarkdownViews } from './lib/markdown/cacheplane-markdown-views';
+
+// Per-node-type markdown view components (consumers use these to override
+// individual nodes via withViews(cacheplaneMarkdownViews, { … })).
+export { MarkdownDocumentComponent }       from './lib/markdown/views/markdown-document.component';
+export { MarkdownParagraphComponent }      from './lib/markdown/views/markdown-paragraph.component';
+export { MarkdownHeadingComponent }        from './lib/markdown/views/markdown-heading.component';
+export { MarkdownBlockquoteComponent }     from './lib/markdown/views/markdown-blockquote.component';
+export { MarkdownListComponent }           from './lib/markdown/views/markdown-list.component';
+export { MarkdownListItemComponent }       from './lib/markdown/views/markdown-list-item.component';
+export { MarkdownCodeBlockComponent }      from './lib/markdown/views/markdown-code-block.component';
+export { MarkdownThematicBreakComponent }  from './lib/markdown/views/markdown-thematic-break.component';
+export { MarkdownTextComponent }           from './lib/markdown/views/markdown-text.component';
+export { MarkdownEmphasisComponent }       from './lib/markdown/views/markdown-emphasis.component';
+export { MarkdownStrongComponent }         from './lib/markdown/views/markdown-strong.component';
+export { MarkdownStrikethroughComponent }  from './lib/markdown/views/markdown-strikethrough.component';
+export { MarkdownInlineCodeComponent }     from './lib/markdown/views/markdown-inline-code.component';
+export { MarkdownLinkComponent }           from './lib/markdown/views/markdown-link.component';
+export { MarkdownAutolinkComponent }       from './lib/markdown/views/markdown-autolink.component';
+export { MarkdownImageComponent }          from './lib/markdown/views/markdown-image.component';
+export { MarkdownSoftBreakComponent }      from './lib/markdown/views/markdown-soft-break.component';
+export { MarkdownHardBreakComponent }      from './lib/markdown/views/markdown-hard-break.component';
+
 // Shared styles & utilities
 export { CHAT_MARKDOWN_STYLES } from './lib/styles/chat-markdown.styles';
 export { renderMarkdown } from './lib/streaming/markdown-render';

From f642b23c5ad8140e3b3cc297fd4ad0bd769229b8 Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 11:06:15 -0700
Subject: [PATCH 14/15] =?UTF-8?q?chore:=20bump=20@ngaf/chat=200.0.19=20?=
 =?UTF-8?q?=E2=86=92=200.0.20?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 libs/chat/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/chat/package.json b/libs/chat/package.json
index 67eba3d68..77f58e75a 100644
--- a/libs/chat/package.json
+++ b/libs/chat/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@ngaf/chat",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "exports": {
     ".": {
       "types": "./index.d.ts",

From d2fb7d175ba6a4d0092354ff9fcd936e09b553ce Mon Sep 17 00:00:00 2001
From: Brian Love <brian@liveloveapp.com>
Date: Mon, 4 May 2026 11:18:41 -0700
Subject: [PATCH 15/15] fix(chat): prefix markdown view selectors with chat- to
 satisfy lint rule

Renames all md-* Angular component selectors to chat-md-* (md-children,
md-document, md-paragraph, md-heading, md-blockquote, md-list, md-list-item,
md-code-block, md-thematic-break, md-text, md-emphasis, md-strong,
md-strikethrough, md-inline-code, md-link, md-autolink, md-image,
md-soft-break, md-hard-break) to satisfy the @angular-eslint/component-selector
rule requiring the 'chat' or 'a2ui' prefix. Updates all template usages and
spec files accordingly.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../markdown/markdown-children.component.spec.ts   |  8 ++++----
 .../lib/markdown/markdown-children.component.ts    |  2 +-
 .../markdown/views/markdown-autolink.component.ts  |  2 +-
 .../views/markdown-blockquote.component.ts         |  4 ++--
 .../views/markdown-code-block.component.spec.ts    |  2 +-
 .../views/markdown-code-block.component.ts         |  2 +-
 .../markdown/views/markdown-document.component.ts  |  4 ++--
 .../markdown/views/markdown-emphasis.component.ts  |  4 ++--
 .../views/markdown-hard-break.component.ts         |  2 +-
 .../views/markdown-heading.component.spec.ts       |  2 +-
 .../markdown/views/markdown-heading.component.ts   | 14 +++++++-------
 .../views/markdown-image.component.spec.ts         |  2 +-
 .../lib/markdown/views/markdown-image.component.ts |  2 +-
 .../views/markdown-inline-code.component.ts        |  2 +-
 .../markdown/views/markdown-link.component.spec.ts |  2 +-
 .../lib/markdown/views/markdown-link.component.ts  |  4 ++--
 .../markdown/views/markdown-list-item.component.ts |  4 ++--
 .../markdown/views/markdown-list.component.spec.ts |  2 +-
 .../lib/markdown/views/markdown-list.component.ts  |  6 +++---
 .../markdown/views/markdown-paragraph.component.ts |  4 ++--
 .../views/markdown-soft-break.component.ts         |  2 +-
 .../views/markdown-strikethrough.component.ts      |  4 ++--
 .../markdown/views/markdown-strong.component.ts    |  4 ++--
 .../markdown/views/markdown-text.component.spec.ts |  6 +++---
 .../lib/markdown/views/markdown-text.component.ts  |  2 +-
 .../views/markdown-thematic-break.component.ts     |  2 +-
 .../lib/streaming/streaming-markdown.component.ts  |  2 +-
 27 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/libs/chat/src/lib/markdown/markdown-children.component.spec.ts b/libs/chat/src/lib/markdown/markdown-children.component.spec.ts
index e2bc82c04..f8b427322 100644
--- a/libs/chat/src/lib/markdown/markdown-children.component.spec.ts
+++ b/libs/chat/src/lib/markdown/markdown-children.component.spec.ts
@@ -10,7 +10,7 @@ import { MARKDOWN_VIEW_REGISTRY } from './markdown-view-registry';
 
 @Component({
   standalone: true,
-  selector: 'md-text-stub',
+  selector: 'chat-md-text-stub',
   template: `<span data-test="text">{{ node().text }}</span>`,
 })
 class TextStub {
@@ -19,9 +19,9 @@ class TextStub {
 
 @Component({
   standalone: true,
-  selector: 'md-paragraph-stub',
+  selector: 'chat-md-paragraph-stub',
   imports: [MarkdownChildrenComponent],
-  template: `<p data-test="paragraph"><md-children [parent]="node()" /></p>`,
+  template: `<p data-test="paragraph"><chat-md-children [parent]="node()" /></p>`,
 })
 class ParagraphStub {
   readonly node = input.required<MarkdownParagraphNode>();
@@ -30,7 +30,7 @@ class ParagraphStub {
 @Component({
   standalone: true,
   imports: [MarkdownChildrenComponent],
-  template: `<md-children [parent]="parent()" />`,
+  template: `<chat-md-children [parent]="parent()" />`,
 })
 class HostComponent {
   parent = signal<MarkdownNode>({
diff --git a/libs/chat/src/lib/markdown/markdown-children.component.ts b/libs/chat/src/lib/markdown/markdown-children.component.ts
index 5947090fc..1a5ceffa8 100644
--- a/libs/chat/src/lib/markdown/markdown-children.component.ts
+++ b/libs/chat/src/lib/markdown/markdown-children.component.ts
@@ -23,7 +23,7 @@ import { MARKDOWN_VIEW_REGISTRY } from './markdown-view-registry';
  * across pushes, unchanged subtrees never re-render.
  */
 @Component({
-  selector: 'md-children',
+  selector: 'chat-md-children',
   standalone: true,
   imports: [NgComponentOutlet],
   changeDetection: ChangeDetectionStrategy.OnPush,
diff --git a/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts b/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
index 53ef7bb4b..60ac5af6c 100644
--- a/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-autolink.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownAutolinkNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-autolink',
+  selector: 'chat-md-autolink',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<a [href]="node().url">{{ node().url }}</a>`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts b/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
index 58a4692a6..6a742572c 100644
--- a/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-blockquote.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownBlockquoteNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-blockquote',
+  selector: 'chat-md-blockquote',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<blockquote><md-children [parent]="node()" /></blockquote>`,
+  template: `<blockquote><chat-md-children [parent]="node()" /></blockquote>`,
 })
 export class MarkdownBlockquoteComponent {
   readonly node = input.required<MarkdownBlockquoteNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
index b606433ec..9a114f503 100644
--- a/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-code-block.component.spec.ts
@@ -9,7 +9,7 @@ import { MarkdownCodeBlockComponent } from './markdown-code-block.component';
 @Component({
   standalone: true,
   imports: [MarkdownCodeBlockComponent],
-  template: `<md-code-block [node]="node()" />`,
+  template: `<chat-md-code-block [node]="node()" />`,
 })
 class HostComponent {
   node = signal<MarkdownCodeBlockNode>({
diff --git a/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts b/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
index 64c176577..b299d8006 100644
--- a/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-code-block.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input, computed } from '@angular/co
 import type { MarkdownCodeBlockNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-code-block',
+  selector: 'chat-md-code-block',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<pre><code [class]="languageClass()">{{ node().text }}</code></pre>`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-document.component.ts b/libs/chat/src/lib/markdown/views/markdown-document.component.ts
index e62390b9b..ecc3d9d0e 100644
--- a/libs/chat/src/lib/markdown/views/markdown-document.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-document.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownDocumentNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-document',
+  selector: 'chat-md-document',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<md-children [parent]="node()" />`,
+  template: `<chat-md-children [parent]="node()" />`,
 })
 export class MarkdownDocumentComponent {
   readonly node = input.required<MarkdownDocumentNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts b/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
index 8ff45560a..a77b14419 100644
--- a/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-emphasis.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownEmphasisNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-emphasis',
+  selector: 'chat-md-emphasis',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<em><md-children [parent]="node()" /></em>`,
+  template: `<em><chat-md-children [parent]="node()" /></em>`,
 })
 export class MarkdownEmphasisComponent {
   readonly node = input.required<MarkdownEmphasisNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts b/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
index 95cca90d4..b0d5b491d 100644
--- a/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-hard-break.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownHardBreakNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-hard-break',
+  selector: 'chat-md-hard-break',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<br>`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
index 72aa2908c..d41f044bf 100644
--- a/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-heading.component.spec.ts
@@ -12,7 +12,7 @@ import { MARKDOWN_VIEW_REGISTRY } from '../markdown-view-registry';
 @Component({
   standalone: true,
   imports: [MarkdownHeadingComponent],
-  template: `<md-heading [node]="node()" />`,
+  template: `<chat-md-heading [node]="node()" />`,
 })
 class HostComponent {
   node = signal<MarkdownHeadingNode>({
diff --git a/libs/chat/src/lib/markdown/views/markdown-heading.component.ts b/libs/chat/src/lib/markdown/views/markdown-heading.component.ts
index 8a23c7b11..b44d2e041 100644
--- a/libs/chat/src/lib/markdown/views/markdown-heading.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-heading.component.ts
@@ -5,18 +5,18 @@ import type { MarkdownHeadingNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-heading',
+  selector: 'chat-md-heading',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `
     @switch (node().level) {
-      @case (1) { <h1><md-children [parent]="node()" /></h1> }
-      @case (2) { <h2><md-children [parent]="node()" /></h2> }
-      @case (3) { <h3><md-children [parent]="node()" /></h3> }
-      @case (4) { <h4><md-children [parent]="node()" /></h4> }
-      @case (5) { <h5><md-children [parent]="node()" /></h5> }
-      @case (6) { <h6><md-children [parent]="node()" /></h6> }
+      @case (1) { <h1><chat-md-children [parent]="node()" /></h1> }
+      @case (2) { <h2><chat-md-children [parent]="node()" /></h2> }
+      @case (3) { <h3><chat-md-children [parent]="node()" /></h3> }
+      @case (4) { <h4><chat-md-children [parent]="node()" /></h4> }
+      @case (5) { <h5><chat-md-children [parent]="node()" /></h5> }
+      @case (6) { <h6><chat-md-children [parent]="node()" /></h6> }
     }
   `,
 })
diff --git a/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
index aa03bb9f9..bc184d42a 100644
--- a/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-image.component.spec.ts
@@ -9,7 +9,7 @@ import { MarkdownImageComponent } from './markdown-image.component';
 @Component({
   standalone: true,
   imports: [MarkdownImageComponent],
-  template: `<md-image [node]="node()" />`,
+  template: `<chat-md-image [node]="node()" />`,
 })
 class HostComponent {
   node = signal<MarkdownImageNode>({
diff --git a/libs/chat/src/lib/markdown/views/markdown-image.component.ts b/libs/chat/src/lib/markdown/views/markdown-image.component.ts
index 78d1ff885..83868f150 100644
--- a/libs/chat/src/lib/markdown/views/markdown-image.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-image.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownImageNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-image',
+  selector: 'chat-md-image',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<img [src]="node().url" [alt]="node().alt" [attr.title]="node().title || null" />`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts b/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
index 07f169c58..9fb4c77c7 100644
--- a/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-inline-code.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownInlineCodeNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-inline-code',
+  selector: 'chat-md-inline-code',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<code>{{ node().text }}</code>`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
index d7ee45c83..0be68dfb6 100644
--- a/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-link.component.spec.ts
@@ -12,7 +12,7 @@ import { MARKDOWN_VIEW_REGISTRY } from '../markdown-view-registry';
 @Component({
   standalone: true,
   imports: [MarkdownLinkComponent],
-  template: `<md-link [node]="node()" />`,
+  template: `<chat-md-link [node]="node()" />`,
 })
 class HostComponent {
   node = signal<MarkdownLinkNode>({
diff --git a/libs/chat/src/lib/markdown/views/markdown-link.component.ts b/libs/chat/src/lib/markdown/views/markdown-link.component.ts
index 69ac5d0ed..60f3a84f3 100644
--- a/libs/chat/src/lib/markdown/views/markdown-link.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-link.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownLinkNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-link',
+  selector: 'chat-md-link',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<a [href]="node().url" [attr.title]="node().title || null"><md-children [parent]="node()" /></a>`,
+  template: `<a [href]="node().url" [attr.title]="node().title || null"><chat-md-children [parent]="node()" /></a>`,
 })
 export class MarkdownLinkComponent {
   readonly node = input.required<MarkdownLinkNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts b/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
index 7dd6c4a67..20cc64f33 100644
--- a/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-list-item.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownListItemNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-list-item',
+  selector: 'chat-md-list-item',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<li><md-children [parent]="node()" /></li>`,
+  template: `<li><chat-md-children [parent]="node()" /></li>`,
 })
 export class MarkdownListItemComponent {
   readonly node = input.required<MarkdownListItemNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
index 8547cf6f5..47b15e1ba 100644
--- a/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-list.component.spec.ts
@@ -12,7 +12,7 @@ import { MARKDOWN_VIEW_REGISTRY } from '../markdown-view-registry';
 @Component({
   standalone: true,
   imports: [MarkdownListComponent],
-  template: `<md-list [node]="node()" />`,
+  template: `<chat-md-list [node]="node()" />`,
 })
 class HostComponent {
   node = signal<MarkdownListNode>({
diff --git a/libs/chat/src/lib/markdown/views/markdown-list.component.ts b/libs/chat/src/lib/markdown/views/markdown-list.component.ts
index 4c68eeb65..dd25586b3 100644
--- a/libs/chat/src/lib/markdown/views/markdown-list.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-list.component.ts
@@ -5,15 +5,15 @@ import type { MarkdownListNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-list',
+  selector: 'chat-md-list',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `
     @if (node().ordered) {
-      <ol [attr.start]="node().start ?? null"><md-children [parent]="node()" /></ol>
+      <ol [attr.start]="node().start ?? null"><chat-md-children [parent]="node()" /></ol>
     } @else {
-      <ul><md-children [parent]="node()" /></ul>
+      <ul><chat-md-children [parent]="node()" /></ul>
     }
   `,
 })
diff --git a/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts b/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts
index 8846dac6d..1cc92fe1d 100644
--- a/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-paragraph.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownParagraphNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-paragraph',
+  selector: 'chat-md-paragraph',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<p><md-children [parent]="node()" /></p>`,
+  template: `<p><chat-md-children [parent]="node()" /></p>`,
 })
 export class MarkdownParagraphComponent {
   readonly node = input.required<MarkdownParagraphNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts b/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
index f27eff0e6..4d4093094 100644
--- a/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-soft-break.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownSoftBreakNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-soft-break',
+  selector: 'chat-md-soft-break',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<br>`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts b/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
index 074b90151..91ba42850 100644
--- a/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-strikethrough.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownStrikethroughNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-strikethrough',
+  selector: 'chat-md-strikethrough',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<del><md-children [parent]="node()" /></del>`,
+  template: `<del><chat-md-children [parent]="node()" /></del>`,
 })
 export class MarkdownStrikethroughComponent {
   readonly node = input.required<MarkdownStrikethroughNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-strong.component.ts b/libs/chat/src/lib/markdown/views/markdown-strong.component.ts
index 728941b77..71142def0 100644
--- a/libs/chat/src/lib/markdown/views/markdown-strong.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-strong.component.ts
@@ -5,11 +5,11 @@ import type { MarkdownStrongNode } from '@cacheplane/partial-markdown';
 import { MarkdownChildrenComponent } from '../markdown-children.component';
 
 @Component({
-  selector: 'md-strong',
+  selector: 'chat-md-strong',
   standalone: true,
   imports: [MarkdownChildrenComponent],
   changeDetection: ChangeDetectionStrategy.OnPush,
-  template: `<strong><md-children [parent]="node()" /></strong>`,
+  template: `<strong><chat-md-children [parent]="node()" /></strong>`,
 })
 export class MarkdownStrongComponent {
   readonly node = input.required<MarkdownStrongNode>();
diff --git a/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts b/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
index 02fc92ff8..c97477217 100644
--- a/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-text.component.spec.ts
@@ -9,7 +9,7 @@ import { MarkdownTextComponent } from './markdown-text.component';
 @Component({
   standalone: true,
   imports: [MarkdownTextComponent],
-  template: `<md-text [node]="node()" />`,
+  template: `<chat-md-text [node]="node()" />`,
 })
 class HostComponent {
   node = signal<MarkdownTextNode>({
@@ -24,7 +24,7 @@ describe('MarkdownTextComponent', () => {
   it('renders the node text', () => {
     const fixture = TestBed.createComponent(HostComponent);
     fixture.detectChanges();
-    expect(fixture.nativeElement.querySelector('md-text')?.textContent).toBe('hello');
+    expect(fixture.nativeElement.querySelector('chat-md-text')?.textContent).toBe('hello');
   });
 
   it('updates when the text changes', () => {
@@ -35,6 +35,6 @@ describe('MarkdownTextComponent', () => {
       parent: null, index: null, text: 'hello world',
     });
     fixture.detectChanges();
-    expect(fixture.nativeElement.querySelector('md-text')?.textContent).toBe('hello world');
+    expect(fixture.nativeElement.querySelector('chat-md-text')?.textContent).toBe('hello world');
   });
 });
diff --git a/libs/chat/src/lib/markdown/views/markdown-text.component.ts b/libs/chat/src/lib/markdown/views/markdown-text.component.ts
index 32a33c0c7..842e23f96 100644
--- a/libs/chat/src/lib/markdown/views/markdown-text.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-text.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownTextNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-text',
+  selector: 'chat-md-text',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `{{ node().text }}`,
diff --git a/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts b/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts
index 50d8a57d2..ae962d3a2 100644
--- a/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts
+++ b/libs/chat/src/lib/markdown/views/markdown-thematic-break.component.ts
@@ -4,7 +4,7 @@ import { Component, ChangeDetectionStrategy, input } from '@angular/core';
 import type { MarkdownThematicBreakNode } from '@cacheplane/partial-markdown';
 
 @Component({
-  selector: 'md-thematic-break',
+  selector: 'chat-md-thematic-break',
   standalone: true,
   changeDetection: ChangeDetectionStrategy.OnPush,
   template: `<hr>`,
diff --git a/libs/chat/src/lib/streaming/streaming-markdown.component.ts b/libs/chat/src/lib/streaming/streaming-markdown.component.ts
index 39e8f152d..e7f98efed 100644
--- a/libs/chat/src/lib/streaming/streaming-markdown.component.ts
+++ b/libs/chat/src/lib/streaming/streaming-markdown.component.ts
@@ -45,7 +45,7 @@ import { cacheplaneMarkdownViews } from '../markdown/cacheplane-markdown-views';
   styles: CHAT_MARKDOWN_STYLES,
   template: `
     @if (root(); as r) {
-      <md-children [parent]="r" />
+      <chat-md-children [parent]="r" />
     }
   `,
   providers: [