feat(website): AI search optimization — Search Console harness, structured data, and measurement

.gitignore

@@ -67,3 +67,6 @@ libs/licensing/src/lib/license-public-key.generated.ts
 examples/ag-ui/angular/src/environments/generated-keys.local.ts
 # Chat example generated API keys (injected from .env at build time)
 examples/chat/angular/src/environments/generated-keys.local.ts
+
+# Local service-account keys (GSC, etc). Never commit these.
+keys/

apps/website/.gitignore

@@ -0,0 +1 @@
+.gsc/

apps/website/content/blog/2026-05-17-build-a-streaming-chat-ui-in-angular-with-langgraph.mdx

@@ -17,7 +17,7 @@ Most AI chat features still ship without streaming — they buffer the full resp
 - Wire a real LangGraph backend to the UI without writing any transport code.
 - Cover the three production patterns that matter once the scaffold works: errors, threads, and generative UI.
 
-## Why streaming matters
+## Why does streaming matter?
 
 A user reads at roughly 200 to 300 words per minute; a modern model produces tokens faster than that. If you stream, the user starts reading before the model has finished. If you buffer, every response feels like a page load with no progress indicator.
 
@@ -160,7 +160,7 @@ The slot pattern is intentional: the chat doesn't set your welcome copy, pick yo
 
 Theming is a separate concern. The chat reads from CSS custom properties — `--chat-bg`, `--chat-fg`, `--chat-accent`, and a few dozen more. If you already use a design system, map your tokens onto theirs in a single stylesheet and the chat picks them up.
 
-## What's happening under the hood
+## What's happening under the hood?
 
 Let's peek at the contract. The adapter exposes a small surface, the chat consumes it, and everything else is implementation detail.
 

apps/website/content/blog/2026-05-21-build-fullstack-agentic-angular-apps-using-ag-ui.mdx

@@ -57,7 +57,7 @@ Three boxes. Two seams.
 
 **The wire.** Server-Sent Events. Plain HTTP, no WebSocket gymnastics, no custom binary framing. Your firewall, load balancer, and reverse proxy already know what to do with it.
 
-**The Angular side.** This is what ThreadPlane provides. `@threadplane/ag-ui` is the adapter. It consumes the AG-UI event stream and exposes a runtime-neutral `Agent` contract built from signals. `@threadplane/chat` is the UI. It reads from that contract and renders. The two are decoupled on purpose. We'll get to why.
+**The Angular side.** This is what Threadplane provides. `@threadplane/ag-ui` is the adapter. It consumes the AG-UI event stream and exposes a runtime-neutral `Agent` contract built from signals. `@threadplane/chat` is the UI. It reads from that contract and renders. The two are decoupled on purpose. We'll get to why.
 
 ## Let's wire it up
 
@@ -152,7 +152,7 @@ No `EventSource`. No reducer. No manual subscribe-and-render plumbing. No store.
 
 Spin up your agent backend, point `url` at it, and the chat just works.
 
-## How AG-UI events become signals
+## How do AG-UI events become signals?
 
 The AG-UI protocol has seventeen event types, grouped into five families:
 
@@ -164,7 +164,7 @@ The AG-UI protocol has seventeen event types, grouped into five families:
 
 The families each do specific work. Lifecycle answers "is something happening?" Text messages are the streaming triad familiar from chat UIs. Tool calls are deliberately incremental so you can render the *intent* before the arguments are fully formed. State sync uses RFC 6902 JSON Patch so the wire stays small even when the agent's state is large.
 
-ThreadPlane's `@threadplane/ag-ui` runs each event through a small reducer that updates a handful of signals on the `Agent` contract:
+Threadplane's `@threadplane/ag-ui` runs each event through a small reducer that updates a handful of signals on the `Agent` contract:
 
 - `messages()`: `Message[]`, the chat history. `TEXT_MESSAGE_CONTENT` appends a delta to the in-flight assistant message.
 - `status()`: `'idle' | 'running' | 'error' | 'paused'`. Driven by the `RUN_*` events.
@@ -267,7 +267,7 @@ How you scope threads — per project, per task, per user session — is a produ
 
 If you want a starting point, `@threadplane/chat` exposes a `<chat-sidebar>` primitive that handles the layout without locking you into a persistence model.
 
-## Swap the backend without changing the UI
+## Can you swap the backend without changing the UI?
 
 This is the part that pays off the protocol bet.
 
@@ -300,6 +300,6 @@ Each of those is its own post. The point here is just that the protocol-to-signa
 
 ## Conclusion
 
-AG-UI standardizes the wire between the agent and the UI: it's small enough to hold in your head, and the event model maps onto Angular signals cleanly. With ThreadPlane (`@threadplane/ag-ui` and `@threadplane/chat` on npm), the wiring is three lines — a provider, an inject, and a `<chat>` — which leaves the interesting work (tool cards, interrupt flows, generative UI, your design system) as the part you spend the day on.
+AG-UI standardizes the wire between the agent and the UI: it's small enough to hold in your head, and the event model maps onto Angular signals cleanly. With Threadplane (`@threadplane/ag-ui` and `@threadplane/chat` on npm), the wiring is three lines — a provider, an inject, and a `<chat>` — which leaves the interesting work (tool cards, interrupt flows, generative UI, your design system) as the part you spend the day on.
 
 The adapters are MIT; `@threadplane/chat` is source-available with a free non-commercial tier. If you're building this inside an enterprise Angular app (design system, multi-tenant, regulated), [talk to us](/contact?source=blog_ag_ui_pillar&track=enterprise).

apps/website/content/blog/2026-05-28-human-in-the-loop-langgraph-agents-in-angular.mdx

@@ -30,7 +30,7 @@ Everything below is running code from the cockpit example at `cockpit/langgraph/
 - Render the approval dialog in Angular with the `<chat-approval-card>` composition.
 - Resume, reject, or edit-then-resume — with a distinct path for each.
 
-## When to use an interrupt
+## When should you use an interrupt?
 
 Most tool calls don't need approval. Reads, searches, and lookups can run unattended. Reach for an interrupt when a tool does something the operator wouldn't want to undo by hand: moves money, sends a customer-facing message, deletes a record, or triggers a deploy.
 

apps/website/content/blog/2026-06-04-human-in-the-loop-ag-ui-agents-in-angular.mdx

@@ -48,7 +48,7 @@ That's the whole client-side delta. The rest of the file — the template bindin
 
 `<chat-approval-card>` reads `agent.interrupt()` (a `Signal<AgentInterrupt | undefined>`), and `submit({ resume })` is part of the runtime-neutral `Agent` contract declared in `@threadplane/chat`. Both adapters populate the signal and forward the resume; the chat surface above doesn't see the wire format.
 
-## When to use an interrupt
+## When should you use an interrupt?
 
 Most tool calls don't need approval. Reads, searches, and lookups can run unattended. Reach for an interrupt when a tool does something the operator wouldn't want to undo by hand: moves money, sends a customer-facing message, deletes a record, or triggers a deploy.
 

apps/website/content/blog/2026-08-09-agentic-ui-in-angular-production-patterns.mdx

@@ -78,6 +78,8 @@ Let the adapter own accumulation, deduplication, and lifecycle transitions.
 Let the component read the result.
 The [Signals guide](/docs/langgraph/concepts/angular-signals) shows the boundary in practice.
 
+![LangGraph stream chunks and AG-UI SSE events both enter a runtime adapter that owns accumulation, deduplication and lifecycle transitions, and the adapter publishes one Agent contract of Angular signals - messages, status, toolCalls, state, error and interrupt - that chat components and an approved component registry read, with user intent travelling back through the same contract.](/blog/diagrams/agent-contract-boundary.svg)
+
 The tradeoff is that normalization can hide useful runtime detail.
 Keep an explicit event escape hatch for information that isn't durable UI state, but don't publish messages or tool calls through two competing sources.
 Two sources of truth create timing bugs that are difficult to reproduce and even harder to explain to a user.

apps/website/content/blog/2026-08-13-angular-chat-app-tutorial-with-ag-ui.mdx

@@ -47,6 +47,8 @@ A reading list. The user asks the assistant to save something; the assistant cal
 
 Three tools, three different shapes, and the server implements none of them.
 
+![The Angular chat component declares its action, view and ask client tools; the catalog travels to the FastAPI /agent endpoint where bind_client_tools binds it to the model for that run, the graph ends its turn and streams AG-UI events back over SSE, the @threadplane/ag-ui adapter reduces them into Angular signals, and the tool result the browser produces starts the next run.](/blog/diagrams/ag-ui-event-flow.svg)
+
 ## How do we get an AG-UI endpoint running?
 
 Install the integration:

apps/website/content/blog/2026-08-13-angular-chat-app-tutorial-with-langchain-langgraph.mdx

@@ -51,6 +51,8 @@ Two Angular pieces, and they read from different places.
 
 That split is the thing to hold onto. The agent knows about one conversation. The thread adapter knows about all of them.
 
+![chat-sidenav renders every conversation from LangGraphThreadsAdapter while chat renders the active one from the @threadplane/langgraph agent; selecting a row sets the ACTIVE_THREAD signal, the agent adapter watches that signal and switches conversations, and onThreadId writes a newly created thread id back into it.](/blog/diagrams/langgraph-threads-and-runs.svg)
+
 ## How do we get a LangGraph server running?
 
 Let's do the backend first, because the Angular side has nothing to bind to without it.

apps/website/e2e/blog.spec.ts

@@ -6,7 +6,7 @@ test.describe('Blog landing page', () => {
 
     // Brand eyebrow + H1
     await expect(page.getByText('Blog', { exact: true }).first()).toBeVisible();
-    await expect(page.getByRole('heading', { level: 1, name: /Articles from ThreadPlane/i })).toBeVisible();
+    await expect(page.getByRole('heading', { level: 1, name: /Articles from Threadplane/i })).toBeVisible();
 
     // Filter row contains the "All" chip in active state
     await expect(page.getByText('All', { exact: true })).toBeVisible();

apps/website/e2e/docs.spec.ts

@@ -89,6 +89,24 @@ test.describe('Docs slug page', () => {
     expect(id?.length).toBeGreaterThan(0);
   });
 
+  test('heading permalinks carry no glyph in the text, only a CSS ::before', async ({ page }) => {
+    await page.goto(route);
+    const h2 = page.locator('article h2').first();
+    await expect(h2).toBeVisible();
+
+    // The `#` must never be a text node: extracted heading text feeds search
+    // snippets, the page outline, and anything summarizing the DOM.
+    expect((await h2.textContent())?.trim()).not.toContain('#');
+
+    // ...which means the visible affordance hangs entirely on one CSS rule
+    // (`.docs-prose h2 .heading-anchor::before` in global.css). jsdom cannot
+    // resolve pseudo-element content, so this is the only place it is guarded.
+    const anchor = h2.locator('a.heading-anchor');
+    await expect(anchor).toHaveCount(1);
+    const glyph = await anchor.evaluate((el) => getComputedStyle(el, '::before').content);
+    expect(glyph).toBe('"#"');
+  });
+
   test('breadcrumb renders exactly once', async ({ page }) => {
     await page.goto('/docs/langgraph/getting-started/introduction');
     await expect(page.locator('nav[aria-label="Breadcrumb"]')).toHaveCount(1);

apps/website/e2e/website.spec.ts

@@ -237,15 +237,15 @@ test('docs pages render canonical and social metadata', async ({ page }) => {
   );
   await expect(page.locator('meta[property="og:title"]')).toHaveAttribute(
     'content',
-    'Streaming - LangGraph Docs - Threadplane',
+    'Streaming — LangGraph Docs — Threadplane',
   );
   await expect(page.locator('meta[property="og:url"]')).toHaveAttribute(
     'content',
     'https://threadplane.ai/docs/langgraph/guides/streaming',
   );
   await expect(page.locator('meta[name="twitter:title"]')).toHaveAttribute(
     'content',
-    'Streaming - LangGraph Docs - Threadplane',
+    'Streaming — LangGraph Docs — Threadplane',
   );
 });