@cms.ai/brand_brain 0.0.1 → 0.1.0

package/README.md

@@ -1,47 +1,26 @@
 # @cms.ai/brand_brain
 
-Client-side SDK for building **CMS.ai Brand Brain (Guide)** experiences directly into your own website UI — your own chat, your own layout — instead of the drop-in overlay. It handles the visitor session, streaming chat across every guide skill, conversation history, and lead capture, all against your branded CMS.ai host.
+Client-side SDK for building **CMS.ai Brand Brain (Guide)** experiences directly into your own website UI — your own chat, your own layout — instead of the drop-in overlay. It handles the visitor session, streaming chat across every guide skill, structured deliverables (documents, recommendations, how-tos, playlists, business cases, solution designs, assessments), conversation history, and lead capture, all against your branded CMS.ai host.
 
 Framework-agnostic core + an optional React binding.
 
+> Machine-readable reference: [`llms.txt`](./llms.txt) ships in this package — point your AI coding tool at it for the full wire contract.
+
 ## Install
 
 ```bash
 npm install @cms.ai/brand_brain
 ```
 
-## Quick start (vanilla JS/TS)
-
-```ts
-import { initGuide } from "@cms.ai/brand_brain";
-
-const guide = await initGuide({
-  baseUrl: "https://guide.yourcompany.com", // your branded CMS.ai host
-  slug: "default", // which guide to load
-});
-
-// Stream a reply into your own UI:
-for await (const event of guide.ask("How does pricing work?")) {
-  if (event.type === "text") {
-    appendToChatBubble(event.delta); // your render fn
-  } else if (event.type === "gate") {
-    // The guide is asking for an email before continuing.
-    await guide.submitGate("visitor@acme.com");
-  }
-}
-```
-
-> **`baseUrl` must be your branded CMS.ai host on your own root domain** (e.g. `guide.yourcompany.com`, the CNAME we provision). That keeps the visitor cookies same-site, so identity + analytics work in every browser without any third-party-cookie caveats.
-
 ## Quick start (React)
 
 ```tsx
 import { useGuide } from "@cms.ai/brand_brain/react";
 
 function Chat() {
-  const { messages, ask, isStreaming, isReady } = useGuide({
-    baseUrl: "https://guide.yourcompany.com",
-    slug: "default",
+  const { messages, skillTurn, gate, ask, submitGate, retryLastAsk, isReady, isStreaming } = useGuide({
+    baseUrl: "https://guide.yourcompany.com", // your branded CMS.ai host
+    slug: "default", // which guide to load
   });
 
   return (
@@ -51,6 +30,33 @@ function Chat() {
           {m.content}
         </p>
       ))}
+
+      {/* Structured deliverable for the current turn — see "Rendering skills" */}
+      {skillTurn && skillTurn.documents.length > 0 && (
+        <ul>
+          {skillTurn.documents.map((d) => (
+            <li key={d.id}>
+              <a href={d.url}>{d.title}</a>
+            </li>
+          ))}
+        </ul>
+      )}
+
+      {/* The guide may ask for an email before finishing a turn */}
+      {gate && (
+        <form
+          onSubmit={async (e) => {
+            e.preventDefault();
+            const email = new FormData(e.currentTarget).get("email") as string;
+            const result = await submitGate(email);
+            if (result.success && !result.needsVerification) await retryLastAsk();
+          }}
+        >
+          <input name="email" type="email" required placeholder="Work email" />
+          <button type="submit">Continue</button>
+        </form>
+      )}
+
       <button disabled={!isReady || isStreaming} onClick={() => ask("What can you help me with?")}>
         Ask
       </button>
@@ -59,23 +65,140 @@ function Chat() {
 }
 ```
 
+`useGuide` bootstraps the client, streams replies into `messages`, folds every structured skill event into `skillTurn`, surfaces email gates on `gate`, and cleans the session up on unmount. Pass `onEvent` in the config to observe every raw stream event.
+
+## Quick start (vanilla JS/TS)
+
+```ts
+import { createSkillTurn, initGuide, reduceSkillEvent } from "@cms.ai/brand_brain";
+
+const guide = await initGuide({
+  baseUrl: "https://guide.yourcompany.com",
+  slug: "default",
+});
+
+let turn = createSkillTurn();
+for await (const event of guide.ask("How does pricing work?")) {
+  if (event.type === "text") {
+    appendToChatBubble(event.delta); // your render fn
+  } else if (event.type === "skill") {
+    turn = reduceSkillEvent(turn, event); // fold structured payloads into renderable state
+    renderSkill(turn);
+  } else if (event.type === "gate") {
+    const email = await promptForEmail(); // your UI
+    await guide.submitGate(email);
+  }
+}
+```
+
+## `baseUrl` and where this runs
+
+**`baseUrl` should be your branded CMS.ai host on your own root domain** (e.g. `guide.yourcompany.com`, the CNAME we provision). Same-site requests mean the visitor identity cookies attach in every browser with no third-party-cookie caveats.
+
+If your app runs on a different site than the guide host (e.g. a preview on `*.lovable.app` talking to `*.guides.navless.ai`), everything still works — chat, skills, lead capture — but Safari and other browsers that block third-party cookies will treat the visitor as anonymous on each page load (no cross-visit identity, no conversation resume). Build the UI so nothing depends on the visitor being remembered, and move to a same-site branded host for production.
+
 ## The `ask()` event stream
 
-`ask()` returns an async iterator of `GuideStreamEvent`s. The common case is `text`; `skill` carries every structured deliverable (documents, recommendations, how-to steps, diagnose questions, business cases, solution designs, …), discriminated by its `name`.
+`ask()` returns an async iterator of `GuideStreamEvent`s:
+
+| `event.type`                             | Meaning                                                                                        |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `run-started` / `run-finished`           | Turn lifecycle                                                                                 |
+| `message-start` / `text` / `message-end` | The streamed chat reply (`text.delta` is the token chunk)                                      |
+| `skill`                                  | A structured skill payload, fully typed and discriminated by `name` — see below                |
+| `gate`                                   | The guide needs an email before continuing — `submitGate(email)`, then re-send the message     |
+| `error`                                  | A run or skill error — `{ message, code?, retryable?, retryHint? }`                            |
+| `skill-unknown`                          | Forward-compat escape hatch for structured events newer than this SDK version — safe to ignore |
+
+Every turn runs exactly one **skill** (plain answers are the `answer` skill). Skill routing is automatic — the server picks the skill from the message. Force one with `guide.ask(text, { forcedSkill: SkillResponseType.HowTo })`.
+
+A turn's skill events always follow the same lifecycle:
+
+```text
+skill_start { skill, messageId }        ← which skill is running
+  …payload events (see per-skill list)…
+skill_end   { skillInstanceId? }        ← deliverable persisted; id usable with guide.skills.*
+```
+
+You rarely need to handle the events by hand: `reduceSkillEvent` (used internally by `useGuide`) folds them into a `GuideSkillTurn` — one flat, renderable state object.
+
+## Rendering skills
+
+What fills in on `GuideSkillTurn` depends on `skillTurn.skill`. Everything not listed stays at its empty default.
+
+### `answer` — grounded Q&A (always enabled)
+
+The reply streams as `text` events into the chat bubble. Alongside it:
+
+- `documents: GuideDocument[]` — the sources behind the answer. Render as source/citation cards: `title`, optional `url`, `thumbnailUrl`, and `citationIndex` matching `[N]` marks in the reply text.
+- `followUpRecommendations: SkillRecommendation[]` — follow-up pills. On click: `ask(rec.prompt, { forcedSkill: rec.skill })`.
+- `ctas: SkillCTA[]` — render the **first** CTA below the response. Discriminated on `kind`: `url` (button opening `href`), `form` (in-guide form `formId`), `product` (card linking to `href`), `scheduler` (button opening the `url` meeting link).
+
+### `howto` — step-by-step guide
+
+1. `howToOutline` arrives first: `{ title, steps: [{ id, title }] }`. Render immediately as a numbered skeleton.
+2. `howToSteps` then replaces the skeleton with detailed steps: `{ id, title, description, icon?, content? }`. `content` is an optional source card (`title`, `url`, `excerpt`, `thumbnailUrl`).
+
+Suggested UI: numbered checklist with step cards; a progress affordance (steps completed) works well. The persisted instance (`skillInstanceId`) supports saving progress via `guide.skills.update`.
+
+### `recommend` — content recommendations
+
+`contentRecommendations: ContentRecommendation[]` — cards with `title`, `rationale`, and `confidence` (`high`/`medium`/`low`). On click: `ask(rec.prompt, { forcedSkill: rec.targetSkill })`.
 
-| `event.type`                             | Meaning                                                                        |
-| ---------------------------------------- | ------------------------------------------------------------------------------ |
-| `run-started` / `run-finished`           | Turn lifecycle                                                                 |
-| `message-start` / `text` / `message-end` | The streamed chat reply (`text.delta` is the token chunk)                      |
-| `skill`                                  | A structured skill payload — `{ name, value }`, where `name` is a `GuideEvent` |
-| `gate`                                   | The guide needs an email before continuing — call `guide.submitGate(email)`    |
-| `error`                                  | A run or skill error — `{ message, code? }`                                    |
+### `playlist` — curated content playlist
 
-Skill routing is automatic (the server picks the skill from the message). Force one with `guide.ask(text, { forcedSkill: SkillResponseType.HowTo })`.
+- `playlistHeader: { title, description }`
+- `playlistItems: PlaylistItem[]` — content cards: `title`, `description`, `contentType` (e.g. `video_youtube`, `pdf`, `url`), `url`, `thumbnailUrl`. `rationale` streams in **late** per item — render it when it appears.
+
+### `diagnose` — self-assessment
+
+- `diagnoseHeader: { targetTopic, subtitle, questionCount, subtype? }`
+- `diagnoseQuestions` **append one at a time** — render a stepper (`questionCount` sizes it). Each question has `category`, `questionText`, and single-choice `options` (`label` A–D, `text`, optional `score`).
+
+There is no correct answer — it's a self-assessment. In `standalone` mode, use `score` per option to compute per-`category` results for a summary chart. In `context_gathering` mode (`subtype`), after the user answers, send a follow-up message summarizing their answers (see `followUpSkill`).
+
+### `businesscase` — generated business case
+
+1. `businessCaseFormats` + `businessCaseDrafts` arrive: render the formats (`label`, `description`, `icon`) as a chooser.
+2. When the user picks one, send its label as a new `ask(...)`. The draft then streams into `businessCaseContent[subType]` as markdown — render with your markdown component.
+
+### `solutiondesign` — architecture diagram
+
+- `solutionDesignHeader: { title, summary }`
+- `solutionDesignNodes` / `solutionDesignEdges` — a flowchart: nodes have `label`, `description`, `nodeType` (`process`, `decision`, `datastore`, `external`, `trigger`, `start`, `end`), and a Lucide `icon` name; edges connect node ids with optional labels. Render with any diagram library — or fall back to a grouped list of nodes with their descriptions.
+
+## The email gate
+
+Guides can be configured to require an email before delivering a skill. Mid-turn you'll get a `gate` event (the stream then ends), and in React `gate` becomes non-null. Flow:
+
+1. Render an email form.
+2. `await submitGate(email)` — the pending gate's context is attached automatically.
+3. If `result.needsVerification` is true, tell the user to check their inbox (magic link). Otherwise call `retryLastAsk()` to re-send the message and finish the turn.
+
+## Theming
+
+`guide.theme` (a `BrandKitTheme`) carries the brand's design tokens as CSS color strings (hex or `oklch(...)`), named shadcn-style: `primary`, `primaryForeground`, `secondary`, `secondaryForeground`, `background`, `foreground`, `muted`, `mutedForeground`, `border`, `input`, `ring`. All optional — absent tokens mean "keep your default".
+
+```tsx
+const { guide } = useGuide({ baseUrl, slug: "default" });
+
+const style = guide?.theme
+  ? ({
+      "--primary": guide.theme.primary,
+      "--primary-foreground": guide.theme.primaryForeground,
+      "--background": guide.theme.background,
+      "--foreground": guide.theme.foreground,
+    } as React.CSSProperties)
+  : undefined;
+
+return <div style={style}>…</div>;
+```
+
+Also on `guide`: `logoUrl`, `faviconUrl`, `heroImageUrl`, `companyName`, and `customization` (per-guide copy overrides — `welcomeMessage`, `chatInputPlaceholders`, `suggestionsTitle`, …). Use `customization.welcomeMessage` as the empty-state greeting and `chatInputPlaceholders` as rotating input placeholders. `skillIconStyle` customizes skill icon colors (`mode`: `default` | `mono` | `per_skill`).
 
 ## API
 
-`initGuide(config)` → `GuideClient`. Config: `baseUrl`, `slug`, optional `domain` (defaults to `window.location.hostname`), `consent` (`"auto"` | `{ functional?, analytical? }` | `false`), `trackLoad` (default `true`), `fetch`.
+`initGuide(config)` → `GuideClient`. Config: `baseUrl`, `slug`, optional `domain` (defaults to the `baseUrl` hostname, which is the registered account domain), `consent` (`"auto"` | `{ functional?, analytical? }` | `false`), `trackLoad` (default `true`), `fetch`.
 
 `GuideClient`:
 
@@ -85,10 +208,14 @@ Skill routing is automatic (the server picks the skill from the message). Force
 - `setConsent({ functional?, analytical? })` / `getStatus()`
 - `submitGate(email, options?)` — capture a lead (magic link when verification is required)
 - `track(eventType, properties?)` / `trackPageView(url?)` — analytics (call `trackPageView` on SPA route changes)
-- `endSession()` — end the visit (call on `pagehide`)
+- `endSession()` — end the visit (call on `pagehide`; `useGuide` does this on unmount)
 - `conversations` — `getOrCreate()`, `list()`, `get(id, { cursor?, limit? })`, `delete(id)`
 - `skills` — `listHistory()`, `get(id)`, `update(id, data)`, `selectDraft(id)`, `markShared(id)`, `importShared(id)`
 
+Core helpers: `createSkillTurn()` / `reduceSkillEvent(turn, event)` fold skill events into a `GuideSkillTurn` outside React.
+
+`useGuide(config)` (from `@cms.ai/brand_brain/react`) returns `{ client, guide, messages, skillTurn, gate, isReady, isStreaming, error, ask, submitGate, retryLastAsk, reset }`. Config additionally accepts `onEvent(event)`.
+
 ## Notes
 
 - The SDK calls the existing public CMS.ai API — it introduces no new endpoints.

package/dist/index.cjs

@@ -1386,7 +1386,11 @@ const SSEMessageType = {
 	TextMessageEnd: "TEXT_MESSAGE_END",
 	Custom: "CUSTOM"
 };
-/** The `name` on `CUSTOM` guide events (skill payloads). */
+/**
+* The `name` on `CUSTOM` guide events (skill payloads). `SkillGate` and
+* `SkillError` never surface as `skill` stream events — the SDK re-maps them to
+* the dedicated `gate` / `error` {@link GuideStreamEvent} variants.
+*/
 const GuideEvent = {
 	SkillStart: "skill_start",
 	SkillContent: "skill_content",
@@ -1406,8 +1410,7 @@ const GuideEvent = {
 	SkillSolutionDesignDiagram: "skill_solutiondesign_diagram",
 	SkillEnd: "skill_end",
 	SkillError: "skill_error",
-	SkillGate: "skill_gate",
-	InputSuggestions: "input_suggestions"
+	SkillGate: "skill_gate"
 };
 /** The guide skill types. `answer` is always on; the rest are enabled per-guide. */
 const SkillResponseType = {
@@ -1433,6 +1436,74 @@ const EmbedTrackingEvent = {
 	EmbedSideTabClicked: "embed_side_tab_clicked",
 	EmbedSideTabDismissed: "embed_side_tab_dismissed"
 };
+/** How a brand kit colors the guide's skill icons. */
+const SkillIconColorMode = {
+	Default: "default",
+	Mono: "mono",
+	PerSkill: "per_skill"
+};
+/** Kind of content a document/playlist item points at. */
+const ContentType = {
+	PDF: "pdf",
+	DOCX: "docx",
+	PPTX: "pptx",
+	Image: "image",
+	VideoNative: "video_native",
+	VideoYouTube: "video_youtube",
+	VideoWistia: "video_wistia",
+	Document: "document",
+	URL: "url",
+	Text: "text",
+	Markdown: "markdown"
+};
+/** Confidence level attached to a content recommendation. */
+const Confidence = {
+	High: "high",
+	Medium: "medium",
+	Low: "low"
+};
+/** The render kind of a surfaced call-to-action. */
+const SkillCtaKind = {
+	Url: "url",
+	Form: "form",
+	Product: "product",
+	Scheduler: "scheduler"
+};
+/** Where a surfaced CTA renders. One slot today: below the skill response. */
+const CtaPlacement = { ResponseFooter: "response_footer" };
+/** Which scheduler embed a scheduler CTA loads. */
+const SchedulerProvider = {
+	HubSpot: "hubspot",
+	Calendly: "calendly"
+};
+/** Diagnose skill mode. */
+const DiagnoseSubtype = {
+	Standalone: "standalone",
+	ContextGathering: "context_gathering"
+};
+/** Answer option labels for diagnose questions. */
+const DiagnoseOptionLabel = {
+	A: "A",
+	B: "B",
+	C: "C",
+	D: "D"
+};
+/** Business case format sub-types. */
+const BusinessCaseSubType = {
+	RoiAnalysis: "roi-analysis",
+	StakeholderBrief: "stakeholder-brief",
+	VendorComparison: "vendor-comparison"
+};
+/** Node types in a solution design diagram. */
+const SolutionDesignNodeType = {
+	Process: "process",
+	Decision: "decision",
+	Datastore: "datastore",
+	External: "external",
+	Trigger: "trigger",
+	Start: "start",
+	End: "end"
+};
 //#endregion
 //#region src/chat-stream.ts
 const DATA_PREFIX = "data:";
@@ -1460,7 +1531,13 @@ async function* streamConversation(params) {
 		body: JSON.stringify(body),
 		signal
 	});
-	if (!response.ok || !response.body) throw new Error(`[brand_brain] Conversation request failed with status ${response.status}`);
+	if (!response.ok || !response.body) {
+		let detail = "";
+		try {
+			detail = (await response.text()).trim();
+		} catch {}
+		throw new Error(`[brand_brain] Conversation request failed with status ${response.status}${detail ? `: ${detail}` : ""}`);
+	}
 	const reader = response.body.getReader();
 	const decoder = new TextDecoder();
 	let buffer = "";
@@ -1519,6 +1596,13 @@ function mapFrame(frame) {
 		default: return null;
 	}
 }
+/**
+* Names that surface as typed `skill` events. `SkillGate`/`SkillError` are
+* re-mapped to the `gate`/`error` variants below, so they are excluded here;
+* any name outside this set is a server event this SDK version predates and
+* flows through as `skill-unknown`.
+*/
+const SKILL_EVENT_NAMES = new Set(Object.values(GuideEvent).filter((name) => name !== GuideEvent.SkillGate && name !== GuideEvent.SkillError));
 function mapCustomFrame(frame) {
 	if (!frame.name) return null;
 	const value = frame.value ?? {};
@@ -1531,20 +1615,42 @@ function mapCustomFrame(frame) {
 	if (frame.name === GuideEvent.SkillError) return {
 		type: "error",
 		message: value.message ?? "Skill error",
-		code: value.errorType
+		code: value.errorType,
+		retryable: value.retryable,
+		retryHint: value.retryHint
 	};
-	return {
+	if (SKILL_EVENT_NAMES.has(frame.name)) return {
 		type: "skill",
 		name: frame.name,
 		value
 	};
+	return {
+		type: "skill-unknown",
+		name: frame.name,
+		value
+	};
 }
 //#endregion
 //#region src/GuideClient.ts
+/**
+* The account is resolved by the branded host the SDK talks to, and that host
+* must be same-site with `baseUrl` for the visitor cookies to attach — so the
+* `baseUrl` hostname IS the registered account domain. Derive it from there
+* rather than the host page's `window.location`, which is an unrelated origin
+* for cross-site embeds and produces a "Domain not found" 404 on resolve.
+*/
 function resolveDomain(config) {
 	if (config.domain) return config.domain;
-	if (typeof window !== "undefined") return window.location.hostname;
-	throw new Error("[brand_brain] `domain` is required when running without a browser `window`.");
+	return hostnameFromBaseUrl(config.baseUrl);
+}
+/**
+* Normalize `baseUrl` to the bare host the server stores: lowercased, no port,
+* no leading `www.` (the domain write-path strips it, so a `www.` host can
+* never match). Accepts a bare host too, in case `baseUrl` omits the protocol.
+*/
+function hostnameFromBaseUrl(baseUrl) {
+	const withProtocol = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseUrl) ? baseUrl : `https://${baseUrl}`;
+	return new URL(withProtocol).hostname.toLowerCase().replace(/^www\./, "");
 }
 /**
 * The client returned by {@link initGuide}. Holds the resolved guide, the
@@ -1598,7 +1704,9 @@ var GuideClient = class GuideClient {
 		this.#api = createApiClient(this.apiBaseUrl, this.fetchImpl);
 	}
 	static async init(config) {
-		const fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+		const globalFetch = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
+		const fetchImpl = config.fetch ?? globalFetch;
+		if (!fetchImpl) throw new Error("[brand_brain] No `fetch` is available — pass `config.fetch` when running without a global fetch.");
 		const apiBaseUrl = toApiBaseUrl(config.baseUrl);
 		const domain = resolveDomain(config);
 		const guide = await createApiClient(apiBaseUrl, fetchImpl).guides.resolve({
@@ -1737,12 +1845,167 @@ async function initGuide(config) {
 	return GuideClient.init(config);
 }
 //#endregion
+//#region src/skill-state.ts
+/** A fresh, empty turn state. */
+function createSkillTurn() {
+	return {
+		skill: null,
+		status: "streaming",
+		messageId: null,
+		diagnoseSubtype: null,
+		followUpSkill: null,
+		content: "",
+		documents: [],
+		contentRecommendations: [],
+		followUpRecommendations: [],
+		ctas: [],
+		diagnoseHeader: null,
+		diagnoseQuestions: [],
+		playlistHeader: null,
+		playlistItems: [],
+		howToOutline: null,
+		howToSteps: [],
+		businessCaseFormats: [],
+		businessCaseDrafts: {},
+		businessCaseContent: {},
+		solutionDesignHeader: null,
+		solutionDesignNodes: [],
+		solutionDesignEdges: [],
+		skillInstanceId: null
+	};
+}
+/** A recommendations payload is content cards iff its entries carry `targetSkill`. */
+function isContentRecommendations(recommendations) {
+	return recommendations.length > 0 && "targetSkill" in recommendations[0];
+}
+/**
+* Fold one `skill` stream event into the turn state. Pure and immutable — the
+* returned object is a new reference whenever anything changed, so the result
+* can back React state directly:
+*
+* ```ts
+* let turn = createSkillTurn();
+* for await (const event of client.ask(message)) {
+*   if (event.type === "skill") turn = reduceSkillEvent(turn, event);
+* }
+* ```
+*/
+function reduceSkillEvent(turn, event) {
+	switch (event.name) {
+		case GuideEvent.SkillStart: return {
+			...event.value.skill === SkillResponseType.BusinessCase && turn.skill === SkillResponseType.BusinessCase ? {
+				...createSkillTurn(),
+				businessCaseFormats: turn.businessCaseFormats,
+				businessCaseDrafts: turn.businessCaseDrafts,
+				businessCaseContent: turn.businessCaseContent
+			} : createSkillTurn(),
+			skill: event.value.skill,
+			messageId: event.value.messageId,
+			diagnoseSubtype: event.value.diagnoseSubtype ?? null,
+			followUpSkill: event.value.followUpSkill ?? null
+		};
+		case GuideEvent.SkillContent: return {
+			...turn,
+			content: turn.content + event.value.delta
+		};
+		case GuideEvent.SkillDocuments: return {
+			...turn,
+			documents: event.value.documents
+		};
+		case GuideEvent.SkillRecommendations: return isContentRecommendations(event.value.recommendations) ? {
+			...turn,
+			contentRecommendations: event.value.recommendations
+		} : {
+			...turn,
+			followUpRecommendations: event.value.recommendations
+		};
+		case GuideEvent.SkillCTAs: return {
+			...turn,
+			ctas: event.value.ctas
+		};
+		case GuideEvent.SkillDiagnoseHeader: return {
+			...turn,
+			diagnoseHeader: event.value.header
+		};
+		case GuideEvent.SkillDiagnoseQuestion: return {
+			...turn,
+			diagnoseQuestions: [...turn.diagnoseQuestions, event.value.question]
+		};
+		case GuideEvent.SkillPlaylistHeader: return {
+			...turn,
+			playlistHeader: event.value.header
+		};
+		case GuideEvent.SkillPlaylistItems: return {
+			...turn,
+			playlistItems: event.value.items
+		};
+		case GuideEvent.SkillPlaylistRationale: return {
+			...turn,
+			playlistItems: turn.playlistItems.map((item) => item.id === event.value.itemId ? {
+				...item,
+				rationale: event.value.rationale
+			} : item)
+		};
+		case GuideEvent.SkillHowToOutline: return {
+			...turn,
+			howToOutline: event.value.outline,
+			skillInstanceId: event.value.skillInstanceId ?? turn.skillInstanceId
+		};
+		case GuideEvent.SkillHowToSteps: return {
+			...turn,
+			howToSteps: event.value.steps
+		};
+		case GuideEvent.SkillBusinessCaseChooser: return {
+			...turn,
+			businessCaseFormats: event.value.formats,
+			businessCaseDrafts: event.value.drafts
+		};
+		case GuideEvent.SkillBusinessCaseDelta: {
+			const existing = turn.businessCaseContent[event.value.subType] ?? "";
+			return {
+				...turn,
+				businessCaseContent: {
+					...turn.businessCaseContent,
+					[event.value.subType]: existing + event.value.delta
+				}
+			};
+		}
+		case GuideEvent.SkillSolutionDesignHeader: return {
+			...turn,
+			solutionDesignHeader: event.value.header
+		};
+		case GuideEvent.SkillSolutionDesignDiagram: return {
+			...turn,
+			solutionDesignNodes: event.value.nodes,
+			solutionDesignEdges: event.value.edges
+		};
+		case GuideEvent.SkillEnd: return {
+			...turn,
+			status: "complete",
+			skillInstanceId: event.value.skillInstanceId ?? event.value.skillResponseId ?? turn.skillInstanceId
+		};
+		default: return event;
+	}
+}
+//#endregion
+exports.BusinessCaseSubType = BusinessCaseSubType;
+exports.Confidence = Confidence;
 exports.ConsentTier = ConsentTier;
+exports.ContentType = ContentType;
+exports.CtaPlacement = CtaPlacement;
+exports.DiagnoseOptionLabel = DiagnoseOptionLabel;
+exports.DiagnoseSubtype = DiagnoseSubtype;
 exports.EmbedTrackingEvent = EmbedTrackingEvent;
 exports.GuideClient = GuideClient;
 exports.GuideEvent = GuideEvent;
 exports.SSEMessageType = SSEMessageType;
+exports.SchedulerProvider = SchedulerProvider;
+exports.SkillCtaKind = SkillCtaKind;
+exports.SkillIconColorMode = SkillIconColorMode;
 exports.SkillResponseType = SkillResponseType;
+exports.SolutionDesignNodeType = SolutionDesignNodeType;
+exports.createSkillTurn = createSkillTurn;
 exports.initGuide = initGuide;
+exports.reduceSkillEvent = reduceSkillEvent;
 
 //# sourceMappingURL=index.cjs.map