bitboss-ui 3.0.0-beta.35 → 3.0.0-beta.37

package/bin/bitboss-ui-mcp.mjs

@@ -35,6 +35,14 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { dirname, join, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
+import {
+	frontmatter,
+	outline,
+	pickSections,
+	searchSections,
+	splitSections,
+	stripFrontmatter,
+} from '../scripts/lib/doc-sections.mjs';
 import {
 	loadManifest,
 	possessive,
@@ -126,13 +134,31 @@ const SEARCH_STOPWORDS = new Set([
 	'element',
 ]);
 
-/** `'data table view'` → `['data', 'table']`. Order is not significant. */
+/**
+ * `'data table view'` → `['data', 'table']`. Order is not significant.
+ *
+ * Names arrive as tags and identifiers too (review D6-6): `bb-select` used to
+ * return all 60 components on the token `bb`, and `BbCheckboxIcon` nothing.
+ * So a CamelCase word is also split into its words, the joined word loses a
+ * leading `bb`, and a bare `bb` is dropped.
+ */
 function tokenize(query) {
 	const raw = String(query ?? '')
-		.toLowerCase()
-		.split(/[^a-z0-9]+/)
-		.filter(Boolean);
-	const meaningful = raw.filter((t) => !SEARCH_STOPWORDS.has(t));
+		.split(/[^A-Za-z0-9]+/)
+		.filter(Boolean)
+		.flatMap((word) => {
+			const lower = word.toLowerCase();
+			const parts = word
+				.replace(/^Bb(?=[A-Z])/, '')
+				.split(/(?<=[a-z0-9])(?=[A-Z])/)
+				.map((part) => part.toLowerCase());
+			return [
+				lower.replace(/^bb(?=.)/, ''),
+				...(parts.length > 1 ? parts : []),
+			];
+		})
+		.filter((token) => token && token !== 'bb');
+	const meaningful = [...new Set(raw)].filter((t) => !SEARCH_STOPWORDS.has(t));
 	// An all-stopword query ('the view') still deserves its literal reading
 	// rather than an empty token list that matches everything.
 	return meaningful.length > 0 ? meaningful : raw;
@@ -228,22 +254,41 @@ function loadNotInLibrary() {
 			assumed,
 			reality,
 			tokens: aliasTokens(assumed),
+			// The names the row is ABOUT: `BbSkeleton` → 'skeleton'.
+			names: [...assumed.matchAll(/`(\w+)`/g)].map(([, name]) =>
+				name.toLowerCase().replace(/^(bb|use)(?=.)/, '')
+			),
 		});
 	}
 	return cachedNotInLibrary;
 }
 
-/** Picker rows whose assumed-name cell shares a token with the query. */
+/**
+ * Picker rows the query is about. A row matches when the query names the
+ * row's own component (`skeleton loading` → BbSkeleton, `drawer` → BbDrawer),
+ * or when every word of a multi-word query is in the row (`data table`),
+ * counting a shared 6-letter stem (`scheduler` / `scheduling`). One shared
+ * generic word is not enough any more: 'text input' answered with the
+ * rich-text-editor verdict as "the authoritative answer", 'tab' with the
+ * cross-tab live-feed row (review D6-7).
+ */
 function matchNotInLibrary(tokens) {
-	const wanted = new Set(tokens);
+	if (!tokens.length) return [];
+	const covers = (row, token) =>
+		row.tokens.some(
+			(t) =>
+				t === token ||
+				(t.length >= 6 &&
+					token.length >= 6 &&
+					t.slice(0, 6) === token.slice(0, 6))
+		);
 	return loadNotInLibrary()
-		.map((row) => ({
-			row,
-			hits: row.tokens.filter((t) => wanted.has(t)).length,
-		}))
-		.filter(({ hits }) => hits > 0)
-		.sort((a, b) => b.hits - a.hits)
-		.map(({ row }) => ({ assumed: row.assumed, reality: row.reality }));
+		.filter(
+			(row) =>
+				tokens.some((t) => row.names.includes(t)) ||
+				(tokens.length > 1 && tokens.every((t) => covers(row, t)))
+		)
+		.map((row) => ({ assumed: row.assumed, reality: row.reality }));
 }
 
 function searchComponents({ query, limit, includeReferenceOnly } = {}) {
@@ -260,6 +305,17 @@ function searchComponents({ query, limit, includeReferenceOnly } = {}) {
 		? manifest.components
 		: manifest.components.filter((c) => !c.referenceOnly);
 
+	// No query: the catalog, one line per component (review D6-19) — the
+	// answer to "which components exist?", which no tool gave before.
+	if (!needle || needle === '*') {
+		return {
+			query: query ?? '',
+			count: pool.length,
+			catalog: pool.map((c) => `${c.name} (${c.group}): ${c.description}`),
+			hint: 'The whole consumer catalog. get_component({ name }) for one; search_components({ query }) to rank by a need.',
+		};
+	}
+
 	const tokens = tokenize(needle);
 	const notInLibrary = matchNotInLibrary(tokens);
 
@@ -291,6 +347,16 @@ function searchComponents({ query, limit, includeReferenceOnly } = {}) {
 
 	const shown = scored.slice(0, max);
 
+	// Internal components an exact search would have found (review D6-15):
+	// 'CommonPopover' answered "No manifest match" although it is in the
+	// manifest, only filtered out as reference-only.
+	const hiddenReferenceOnly = includeReferenceOnly
+		? []
+		: manifest.components
+				.filter((c) => c.referenceOnly)
+				.filter((c) => scoreComponent(c, tokens).score >= 80)
+				.map((c) => c.name);
+
 	/**
 	 * Public type exports whose name matches the query. Scored the same way as
 	 * a component name (exact, prefix, substring) but never mixed into the
@@ -316,6 +382,8 @@ function searchComponents({ query, limit, includeReferenceOnly } = {}) {
 			...(type.deprecated ? { deprecated: true } : {}),
 			...(type.replacedBy ? { replacedBy: type.replacedBy } : {}),
 			usedBy: type.usedBy ?? [],
+			// The short answer only; get_component(name) has the definition.
+			...(type.values ? { values: type.values } : {}),
 			import: `import type { ${type.replacedBy ?? type.name} } from 'bitboss-ui';`,
 		}));
 
@@ -345,6 +413,13 @@ function searchComponents({ query, limit, includeReferenceOnly } = {}) {
 		// consumer who hit this concluded the export was undocumented and
 		// allowlisted the tag.
 		...(matchedTypes.length > 0 ? { types: matchedTypes } : {}),
+		...(hiddenReferenceOnly.length
+			? {
+					hiddenReferenceOnly,
+					referenceOnlyHint:
+						'Internal building blocks, not consumer API: never write them in a template. Use the ranked components; pass includeReferenceOnly: true only to read how one works.',
+				}
+			: {}),
 		guidance:
 			notInLibrary.length > 0
 				? 'The `notInLibrary` entries are the authoritative answer for this query — prefer them over the ranked components, and do not hand-roll what they redirect you to.'
@@ -401,9 +476,154 @@ function truncateMarkdown(text, maxChars, readHint) {
 	};
 }
 
-function getComponent({ name, maxChars } = {}) {
+/**
+ * Names an agent brings from v2, from an older beta or from habit, mapped to
+ * what replaced them. Parsed from the shipped docs so there is one source of
+ * truth: the v2 → v3 guide's § 5.1 component table, and changelog rows that
+ * say "BbX is renamed BbY". Without it `get_component('BbChip')` answered
+ * "unknown component" although the guide had the exact answer (review D6-5).
+ */
+let cachedRetired = null;
+function loadRetired() {
+	if (cachedRetired) return cachedRetired;
+	cachedRetired = new Map();
+	const guidePath = join(AI_ROOT, 'guides', 'migration', 'v2-to-v3.md');
+	if (existsSync(guidePath)) {
+		const md = readFileSync(guidePath, 'utf-8');
+		const table = md.split(/^### 5\.1 .*$/m)[1]?.split(/^### /m)[0] ?? '';
+		for (const line of table.split('\n')) {
+			if (!line.startsWith('|')) continue;
+			const [was, now, todo] = line
+				.replace(/^\|/, '')
+				.replace(/\|\s*$/, '')
+				.split('|')
+				.map((cell) => cell.trim());
+			if (!was || !now || /^-+$/.test(was) || was === 'v2') continue;
+			for (const [, retired] of was.matchAll(/`(\w+)`/g)) {
+				cachedRetired.set(retired, {
+					now: now.replace(/\*\*/g, ''),
+					todo: (todo ?? '').replace(/\*\*/g, '').split(/(?<=\.)\s/)[0],
+					guide: 'migration/v2-to-v3.md',
+					section: '5.1 Components renamed, split, or removed',
+				});
+			}
+		}
+	}
+	if (existsSync(CHANGELOG_PATH)) {
+		const doc = JSON.parse(readFileSync(CHANGELOG_PATH, 'utf-8'));
+		for (const row of doc.breaking ?? []) {
+			const match = String(row.description ?? '').match(
+				/\b(Bb[A-Z]\w+) is renamed (Bb[A-Z]\w+)/
+			);
+			if (match && !cachedRetired.has(match[1])) {
+				cachedRetired.set(match[1], {
+					now: `\`${match[2]}\``,
+					todo: row.description.split(/(?<=\.)\s|—/)[0].trim(),
+					guide: row.guide ?? null,
+					firstReleasedIn: row.firstReleasedIn ?? null,
+				});
+			}
+		}
+	}
+	return cachedRetired;
+}
+
+/** `bb-date-picker-input` → `BbDatePickerInput`; `button` → `Button`. */
+const pascal = (value) =>
+	String(value ?? '')
+		.split(/[^A-Za-z0-9]+/)
+		.filter(Boolean)
+		.map((part) => part[0].toUpperCase() + part.slice(1))
+		.join('');
+
+/** Levenshtein distance, small inputs only. */
+function editDistance(a, b) {
+	const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i += 1) {
+		let previous = row[0];
+		row[0] = i;
+		for (let j = 1; j <= b.length; j += 1) {
+			const current = row[j];
+			row[j] = Math.min(
+				row[j] + 1,
+				row[j - 1] + 1,
+				previous + (a[i - 1] === b[j - 1] ? 0 : 1)
+			);
+			previous = current;
+		}
+	}
+	return row[b.length];
+}
+
+/**
+ * Find the component an agent meant. Exact first; then the spellings agents
+ * really send — `bb-button`, `bbbutton`, `Button` (review D6-2) — before
+ * giving up with the nearest names.
+ */
+function resolveComponent(manifest, name) {
+	const raw = String(name ?? '').trim();
+	const exact = manifest.components.find((c) => c.name === raw);
+	if (exact) return { entry: exact };
+	const byLower = new Map(
+		manifest.components.map((c) => [c.name.toLowerCase(), c])
+	);
+	const candidates = [raw, pascal(raw)].flatMap((value) => [
+		value.toLowerCase(),
+		`bb${value.toLowerCase().replace(/^bb/, '')}`,
+	]);
+	for (const candidate of candidates) {
+		const hit = byLower.get(candidate);
+		if (hit) return { entry: hit, resolvedFrom: raw };
+	}
+	return null;
+}
+
+function nearestComponents(manifest, name, count = 3) {
+	const needle = pascal(name).toLowerCase().replace(/^bb/, '');
+	return manifest.components
+		.filter((c) => !c.referenceOnly)
+		.map((c) => ({
+			name: c.name,
+			distance: editDistance(needle, c.name.toLowerCase().replace(/^bb/, '')),
+		}))
+		.sort((a, b) => a.distance - b.distance)
+		.slice(0, count)
+		.filter(({ distance }) => distance <= Math.max(3, needle.length / 2))
+		.map(({ name: found }) => found);
+}
+
+/** Guide sections of a contract: everything under `## Usage & Guidelines`. */
+function contractGuideSections(markdown) {
+	const all = splitSections(markdown);
+	const start = all.findIndex(
+		(s) => s.level === 2 && /^Usage & Guidelines/i.test(s.title)
+	);
+	if (start === -1) return [];
+	const end = all.findIndex((s, i) => i > start && s.level === 2);
+	return all.slice(start + 1, end === -1 ? undefined : end);
+}
+
+/** Sections every agent needs, served whole in the default answer. */
+const ALWAYS_SECTIONS = [/^gotchas/i, /^accessibility/i];
+
+/**
+ * `get_component({ name, sections?, include?, maxChars? })`.
+ *
+ * COMPACT BY DEFAULT (release review 2026-09-23, D6-4). The old answer was
+ * the manifest entry plus the whole contract cut at 40 000 chars: 76–101 KB,
+ * and the cut dropped `Gotchas` on six components while the tail it kept
+ * repeated the structured entry. Blind Haiku answerers could not read it and
+ * guessed. Now the default is the structured entry (props never cut — a
+ * partial prop list is what makes agents invent API) minus the parts that
+ * repeat it (`pt:*` prop rows: the `pt` section lists every part and state),
+ * the guide's outline, and its Gotchas + Accessibility sections. Guide
+ * sections, the component tree, the CSS variables with their descriptions
+ * and the whole contract come on request.
+ */
+function getComponent({ name, sections, include, maxChars } = {}) {
 	const manifest = loadComponentsManifest();
-	const entry = manifest.components.find((c) => c.name === name);
+	const resolved = resolveComponent(manifest, name);
+	const entry = resolved?.entry;
 	if (!entry) {
 		/*
 		 * A public TYPE asked for as a component. `BbTableColumn`,
@@ -425,18 +645,67 @@ function getComponent({ name, maxChars } = {}) {
 				...(type.replacedBy ? { replacedBy: type.replacedBy } : {}),
 				component: type.component,
 				usedBy: type.usedBy ?? [],
+				// What it is (Q50.2): the declaration, the accepted values when
+				// finite (open when `extensibleVia` names a registry), and the
+				// resolved fields when the declaration leans on a private type.
+				...(type.definition ? { definition: type.definition } : {}),
+				...(type.values ? { values: type.values } : {}),
+				...(type.extensibleVia ? { extensibleVia: type.extensibleVia } : {}),
+				...(type.fields ? { fields: type.fields } : {}),
 				import: `import type { ${type.replacedBy ?? name} } from 'bitboss-ui';`,
 				hint: use
-					? `A type, not a component: it types ${possessive(use.component)} \`${use.name}\` ${use.surface}. Call get_component('${use.component}') for the contract that documents its fields.`
+					? `A type, not a component: it types ${possessive(use.component)} \`${use.name}\` ${use.surface}. \`definition\` above is the type itself; call get_component('${use.component}') to see it in use.`
 					: 'A type, not a component — import it for the value you pass, never write it as a tag.',
 			};
 		}
+		// A directive (`v-bb-tooltip`, `vBbTooltip`) — review D3-13.
+		const directiveName = String(name ?? '')
+			.trim()
+			.replace(/^vBb([A-Z]\w*)$/, (_, word) => `v-bb-${word.toLowerCase()}`)
+			.toLowerCase();
+		const directive = (manifest.directives ?? []).find(
+			(d) => d.name === directiveName
+		);
+		if (directive) {
+			const value = (manifest.types ?? []).find(
+				(t) => t.name === directive.value
+			);
+			return {
+				found: true,
+				kind: 'directive',
+				...directive,
+				...(value?.definition ? { valueDefinition: value.definition } : {}),
+				...(value?.fields ? { valueFields: value.fields } : {}),
+				hint: `A directive, the floating twin of ${directive.mirrors}: read get_component({ name: '${directive.mirrors}', sections: ['directive'] }) for its guide section.`,
+			};
+		}
+		const retired = loadRetired().get(String(name ?? '').trim());
+		if (retired) {
+			return {
+				found: false,
+				name,
+				retired: true,
+				now: retired.now,
+				todo: retired.todo,
+				guide: retired.guide,
+				...(retired.section ? { section: retired.section } : {}),
+				hint: `\`${name}\` is not in this version. \`now\` says what replaced it; read get_guide({ name: '${retired.guide}'${retired.section ? `, sections: ['${retired.section}']` : ''} }) for the full row.`,
+			};
+		}
+		const picker = matchNotInLibrary(tokenize(name));
+		const didYouMean = nearestComponents(manifest, name);
 		return {
 			found: false,
 			name,
-			hint: 'Unknown component name — try search_components first.',
+			...(didYouMean.length ? { didYouMean } : {}),
+			...(picker.length ? { notInLibrary: picker.slice(0, 3) } : {}),
+			hint: picker.length
+				? "Not a component here — `notInLibrary` is the picker's verdict for this name."
+				: 'Unknown component name. Try one of `didYouMean`, or search_components with a plain noun.',
 		};
 	}
+
+	const wanted = new Set(include ?? []);
 	const contractPath = entry.contract ?? null;
 	const contractAbsPath = contractPath
 		? join(PACKAGE_ROOT, 'dist', contractPath)
@@ -444,12 +713,9 @@ function getComponent({ name, maxChars } = {}) {
 	const raw =
 		contractAbsPath && existsSync(contractAbsPath)
 			? readFileSync(contractAbsPath, 'utf-8')
-			: null;
-	const { content, ...meta } = truncateMarkdown(
-		raw,
-		maxChars,
-		`The structured \`component\` field above is COMPLETE (all props/events/slots) — the cut text is guidance prose only.`
-	);
+			: '';
+	const guide = contractGuideSections(raw);
+
 	/*
 	 * The types this component's own API names, so "what do I import to build
 	 * the value for `columns`?" is answered where the question is asked. Without
@@ -465,19 +731,98 @@ function getComponent({ name, maxChars } = {}) {
 		.filter((type) => !type.deprecated)
 		.map((type) => ({
 			name: type.name,
-			usage: type.usage,
 			usedBy: (type.usedBy ?? []).filter((use) => use.component === entry.name),
 			import: `import type { ${type.name} } from 'bitboss-ui';`,
+			...(type.values ? { values: type.values } : {}),
+			...(type.extensibleVia ? { extensibleVia: type.extensibleVia } : {}),
+			...(type.fields ? { fields: type.fields } : {}),
+			...(!type.values && !type.fields && type.definition
+				? { definition: type.definition }
+				: {}),
 		}));
 
+	const ptRows = entry.props.filter(
+		(p) => p.name === 'pt' || p.name.startsWith('pt:')
+	);
+	const component = {
+		...entry,
+		props: (wanted.has('ptProps')
+			? entry.props
+			: entry.props.filter((p) => !ptRows.includes(p))
+		).map(({ required, ...prop }) => (required ? { ...prop, required } : prop)),
+		...(entry.cssProps && !wanted.has('cssProps')
+			? { cssProps: entry.cssProps.map((c) => c.name ?? c) }
+			: {}),
+	};
+	if (!wanted.has('tree')) delete component.tree;
+	// `removed` and `renamed` repeat each other with migration metadata; one
+	// line per old name answers "what happened to X" (include 'history' for
+	// the records the fixers use).
+	if (
+		!wanted.has('history') &&
+		(entry.removed?.length || entry.renamed?.length)
+	) {
+		const renamedFrom = new Set((entry.renamed ?? []).map((r) => r.from));
+		component.history = [
+			...(entry.renamed ?? []).map(
+				(r) =>
+					`${r.from} → ${r.to}${r.fix?.kind && r.fix.kind !== 'rename' ? ` (${r.fix.kind})` : ''}`
+			),
+			...(entry.removed ?? [])
+				.filter((r) => !renamedFrom.has(r.name))
+				.map((r) => `${r.name} removed${r.new ? ` → ${r.new}` : ''}`),
+		];
+		delete component.removed;
+		delete component.renamed;
+	}
+
+	const { picked, missing } = pickSections(guide, sections);
+	const always = guide.filter(
+		(s) => ALWAYS_SECTIONS.some((re) => re.test(s.title)) && !picked.includes(s)
+	);
+	const contract = wanted.has('contract')
+		? truncateMarkdown(
+				raw,
+				maxChars,
+				'The structured `component` field above is complete; the cut text is guide prose.'
+			)
+		: null;
+
 	return {
 		found: true,
-		// Never truncated: the precision-critical surface.
-		component: entry,
+		...(resolved.resolvedFrom ? { resolvedFrom: resolved.resolvedFrom } : {}),
+		component,
 		...(types.length > 0 ? { types } : {}),
+		...(ptRows.length && !wanted.has('ptProps')
+			? {
+					ptProps: `${ptRows.length} pt:* props not listed: every \`pt:<part>\` and \`pt:<part>:<state>\` in \`component.pt\` is a prop taking a class string (or object / array), and \`pt\` takes the same keys as one object.`,
+				}
+			: {}),
+		guide: {
+			sections: guide
+				.filter((s) => s.level === 3)
+				.map((s) => ({ title: s.title, chars: s.text.length })),
+			...(picked.length
+				? { requested: picked.map((s) => ({ title: s.title, text: s.text })) }
+				: {}),
+			...(missing.length ? { notFound: missing } : {}),
+			...(always.length
+				? { always: always.map((s) => ({ title: s.title, text: s.text })) }
+				: {}),
+		},
 		contractPath,
-		contractContent: content,
-		...meta,
+		...(contract
+			? {
+					contract: contract.content,
+					...(contract.truncated
+						? {
+								contractTruncated: true,
+								contractHint: contract.hint,
+							}
+						: {}),
+				}
+			: {}),
+		hint: `Structured API above is complete. Read guide sections with get_component({ name: '${entry.name}', sections: ['<title from guide.sections>'] }); add include: ['tree' | 'cssProps' | 'ptProps' | 'history' | 'contract'] for the component tree, CSS variables with descriptions, every pt:* row, the full v2/beta rename records, or the whole contract. search_docs finds a topic across all docs.`,
 	};
 }
 
@@ -546,6 +891,11 @@ const tokenKind = (inKnobBlock, inDerivedBlock) =>
  * tolerant of the missing final semicolon that minified CSS emits) is the
  * cheapest way to keep the scope — and this file ships in the package, so it
  * may not reach for postcss the way the dev-only `check:tokens` script does.
+ *
+ * `when` carries the enclosing `@supports` condition(s), if any: a value there
+ * is not the theme value but one browser path — `--bb-primary-fg` ships an
+ * auto-contrast formula with literal fallbacks, and folding the fallbacks into
+ * the theme values tells an agent to pin a literal that defeats the formula.
  */
 function* eachTokenDeclaration(css) {
 	const stack = [];
@@ -566,11 +916,23 @@ function* eachTokenDeclaration(css) {
 			quote = char;
 			buffer += char;
 		} else if (char === '{') {
-			stack.push(buffer.trim());
+			// A comment before a rule would otherwise prefix its selector or
+			// hide the `@supports` it opens.
+			stack.push(buffer.replace(/\/\*[\s\S]*?\*\//g, '').trim());
 			buffer = '';
 		} else if (char === '}' || char === ';') {
 			const decl = declaration();
-			if (decl) yield { ...decl, selector: stack[stack.length - 1] ?? '' };
+			if (decl) {
+				const supports = stack
+					.slice(0, -1)
+					.filter((scope) => scope.startsWith('@supports'))
+					.map((scope) => scope.replace(/^@supports\s*/, ''));
+				yield {
+					...decl,
+					selector: stack[stack.length - 1] ?? '',
+					...(supports.length ? { when: supports.join(' and ') } : {}),
+				};
+			}
 			if (char === '}') stack.pop();
 		} else {
 			buffer += char;
@@ -611,16 +973,27 @@ function listTokens({ filter } = {}) {
 	}
 	const css = readFileSync(STYLES_CSS, 'utf-8');
 	const byName = new Map();
-	for (const { name, value, selector } of eachTokenDeclaration(css)) {
+	for (const { name, value, selector, when } of eachTokenDeclaration(css)) {
 		const entry = byName.get(name) ?? {
 			theme: [],
 			local: [],
+			conditional: [],
 			knobBlock: false,
 			derivedBlock: false,
 		};
 		if (isThemeSelector(selector)) {
 			if (isDerivedBlock(selector)) entry.derivedBlock = true;
 			else entry.knobBlock = true;
+		}
+		if (when) {
+			// One browser path, not the theme value nor a dark override.
+			if (
+				!entry.conditional.some(
+					(c) => c.when === when && c.selector === selector
+				)
+			)
+				entry.conditional.push({ when, selector, value });
+		} else if (isThemeSelector(selector)) {
 			// Light first, dark after: report both rather than let one win.
 			if (!entry.theme.includes(value)) entry.theme.push(value);
 		} else if (!entry.local.some((r) => r.selector === selector)) {
@@ -637,12 +1010,13 @@ function listTokens({ filter } = {}) {
 	const tokens = [...byName.entries()]
 		.filter(([name]) => !needle || name.toLowerCase().includes(needle))
 		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([name, { theme, local, knobBlock, derivedBlock }]) => ({
+		.map(([name, { theme, local, conditional, knobBlock, derivedBlock }]) => ({
 			name,
 			kind: tokenKind(knobBlock, derivedBlock),
 			value: theme[0],
 			...(theme.length > 1 ? { themeOverrides: theme.slice(1) } : {}),
 			...(local.length > 0 ? { localRebinds: local } : {}),
+			...(conditional.length > 0 ? { conditional } : {}),
 		}));
 	return {
 		count: tokens.length,
@@ -651,7 +1025,7 @@ function listTokens({ filter } = {}) {
 		hint:
 			needle && tokens.length === 0
 				? `No token name contains '${needle}'. Call list_tokens with no filter for all ${byName.size} — the names are semantic (primary/danger/panel/text/border/radius/…), not literal colours.`
-				: 'Theme tokens are set by the consumer app (e.g. on :root / .dark); `themeOverrides` is the dark-theme value. `localRebinds` is a component rebinding the token inside its own subtree — not something to copy. `kind` says what you may set: "knob" is yours; "derived" is a formula recomputed at every theme boundary, so setting it stops it tracking the knob it came from — set that knob instead; "knob-tracking" is a knob that follows another until you pin it, and the pin must be repeated at every boundary you use, .dark included. Component-level unprefixed tokens are documented per component; see the design-tokens guide via get_guide.',
+				: 'Theme tokens are set by the consumer app (e.g. on :root / .dark); `themeOverrides` is the dark-theme value. `localRebinds` is a component rebinding the token inside its own subtree — not something to copy. `conditional` is a value that applies only under an @supports condition (`when`) — e.g. an auto-contrast formula with literal fallbacks for older browsers; pinning a fallback literal defeats the formula. `kind` says what you may set: "knob" is yours; "derived" is a formula recomputed at every theme boundary, so setting it stops it tracking the knob it came from — set that knob instead; "knob-tracking" is a knob that follows another until you pin it, and the pin must be repeated at every boundary you use, .dark included. Component-level unprefixed tokens are documented per component; see the design-tokens guide via get_guide.',
 	};
 }
 
@@ -670,41 +1044,276 @@ function collectGuidePaths(dir, prefix = '') {
 
 /** `list_guides()` — the shipped prose guides an agent can read. */
 function listGuides() {
-	const guides = collectGuidePaths(join(AI_ROOT, 'guides')).sort();
+	const guidesDir = join(AI_ROOT, 'guides');
+	const all = collectGuidePaths(guidesDir).sort();
+	/*
+	 * Title + summary per guide (review D6-13): 57 bare paths could not tell an
+	 * agent which one answers its question. The 40 per-component migration
+	 * pages collapse to one row — get_guide('migration/components/<kebab>').
+	 */
+	const perComponent = all.filter((p) => p.startsWith('migration/components/'));
+	const guides = all
+		.filter((p) => !perComponent.includes(p))
+		.map((path) => {
+			const markdown = readFileSync(join(guidesDir, path), 'utf-8');
+			const meta = frontmatter(markdown);
+			const title =
+				meta.title ??
+				stripFrontmatter(markdown)
+					.match(/^# (.+)$/m)?.[1]
+					?.trim();
+			return {
+				name: path,
+				...(title ? { title } : {}),
+				...(meta.summary ? { summary: meta.summary } : {}),
+			};
+		});
 	return {
-		count: guides.length,
+		count: all.length,
 		guides,
-		hint: 'Read one with get_guide({ name }). Start at `ai-router.md`, then `agent-contract.md` — do not read them all.',
+		...(perComponent.length
+			? {
+					perComponentMigration: `${perComponent.length} pages: get_guide({ name: 'migration/components/<kebab-name>' }), e.g. 'migration/components/bb-select'.`,
+				}
+			: {}),
+		hint: 'Read one with get_guide({ name }); a long guide answers with its outline — then pass sections. search_docs finds the section for a question across every guide. Start at `ai-router.md` — do not read them all.',
 	};
 }
 
-/** `get_guide({ name, maxChars })` — read one guide by relative path. */
-function getGuide({ name, maxChars } = {}) {
-	const rel = String(name ?? '').replace(/^\/+/, '');
-	// Contain reads to the guides dir — no traversal out of the knowledge base.
-	if (!rel || rel.includes('..')) {
+/** Guides this size or larger answer with an outline unless asked for more. */
+// The router (13 KB, the documented entry point) still comes whole.
+const GUIDE_OUTLINE_OVER = 16000;
+
+/**
+ * The shipped guide a pointer means. Pointers come from everywhere — the
+ * changelog (`components/bb-table.md (CSS table)`), contracts
+ * (`guides/passthrough.md`), the repo layout (`ai/guides/…`) — and every form
+ * used to answer "Guide not found" (review D6-11).
+ */
+function resolveGuidePath(name) {
+	const guidesDir = join(AI_ROOT, 'guides');
+	const all = collectGuidePaths(guidesDir);
+	let rel = String(name ?? '')
+		.trim()
+		.replace(/\s*\(.*\)\s*$/, '')
+		.replace(/^\/+/, '')
+		.replace(/^(dist\/)?(ai\/)?(guides\/)?/, '');
+	if (!rel || rel.includes('..')) return null;
+	if (!rel.endsWith('.md')) rel = `${rel}.md`;
+	const tries = [rel, `migration/${rel}`, `migration/components/${rel}`];
+	for (const attempt of tries) if (all.includes(attempt)) return attempt;
+	const base = rel.split('/').pop();
+	const byBase = all.filter((p) => p.split('/').pop() === base);
+	return byBase.length === 1 ? byBase[0] : null;
+}
+
+/** `get_guide({ name, sections?, maxChars? })`. */
+function getGuide({ name, sections, maxChars } = {}) {
+	const resolved = resolveGuidePath(name);
+	if (!resolved) {
+		const all = collectGuidePaths(join(AI_ROOT, 'guides'));
+		const needle = String(name ?? '').toLowerCase();
+		const near = all
+			.filter((p) =>
+				needle
+					.split(/[^a-z0-9]+/)
+					.some((w) => w.length > 3 && p.toLowerCase().includes(w))
+			)
+			.slice(0, 5);
 		return {
 			found: false,
-			error: `Invalid guide name '${name}'.`,
-			hint: 'Call list_guides for the available names.',
+			error: `Guide not found: ${name}`,
+			...(near.length ? { didYouMean: near } : {}),
+			hint: 'Call list_guides for the names, or search_docs to find the section by topic.',
 		};
 	}
-	const fileName = rel.endsWith('.md') ? rel : `${rel}.md`;
-	const guidesDir = join(AI_ROOT, 'guides');
-	const filePath = join(guidesDir, fileName);
-	if (!filePath.startsWith(guidesDir) || !existsSync(filePath)) {
+	const markdown = readFileSync(join(AI_ROOT, 'guides', resolved), 'utf-8');
+	const meta = frontmatter(markdown);
+	const all = splitSections(markdown);
+	const base = {
+		found: true,
+		name: resolved,
+		...(resolved !== name ? { resolvedFrom: name } : {}),
+		...(meta.title ? { title: meta.title } : {}),
+	};
+	if (sections?.length) {
+		const { picked, missing } = pickSections(all, sections);
 		return {
-			found: false,
-			error: `Guide not found: ${fileName}`,
-			hint: 'Call list_guides for the available names.',
+			...base,
+			sections: picked.map((s) => ({ title: s.title, text: s.text })),
+			...(missing.length ? { notFound: missing, outline: outline(all) } : {}),
 		};
 	}
-	const { content, ...meta } = truncateMarkdown(
-		readFileSync(filePath, 'utf-8'),
+	const body = stripFrontmatter(markdown);
+	if (maxChars === undefined && body.length >= GUIDE_OUTLINE_OVER) {
+		const intro = body.split(/^## /m)[0].trim();
+		return {
+			...base,
+			...(meta.summary ? { summary: meta.summary } : {}),
+			chars: body.length,
+			intro: intro.slice(0, 2000),
+			outline: outline(all),
+			hint: `This guide is ${body.length} chars. Read what you need: get_guide({ name: '${resolved}', sections: ['<title from outline>'] }) — a ## section includes its ### children. maxChars: 0 returns the whole guide.`,
+		};
+	}
+	const { content, ...cut } = truncateMarkdown(
+		markdown,
 		maxChars,
-		`Guides are ordered narrative — the cut tail is later sections.`
+		'Guides are ordered narrative — the cut tail is later sections.'
+	);
+	return { ...base, content, ...cut };
+}
+
+/**
+ * `search_docs({ query, limit? })` — the section that answers a question,
+ * across guides, composables, component guides, component props and recipes.
+ *
+ * WHY (review 2026-09-23). The facts Haiku missed were all shipped — the
+ * `.dark` class, `cssLayers`, `passthroughDeduper`, `ssrViewportWidth`, the
+ * `ai-init` and `changelog` commands, `prefill: false` — but each sat in one
+ * section of a long document, and no tool could say which. Each result is a
+ * snippet plus the exact call that reads the whole section.
+ */
+let cachedDocIndex = null;
+function docIndex() {
+	if (cachedDocIndex) return cachedDocIndex;
+	const entries = [];
+	const addSections = (source, markdown, read) => {
+		for (const section of splitSections(markdown)) {
+			if (section.own.length < 40) continue;
+			entries.push({
+				source,
+				section: section.title,
+				text: section.own,
+				read: read(section.title),
+			});
+		}
+	};
+	const guidesDir = join(AI_ROOT, 'guides');
+	for (const path of collectGuidePaths(guidesDir)) {
+		addSections(
+			`guide ${path}`,
+			readFileSync(join(guidesDir, path), 'utf-8'),
+			(title) => ({
+				tool: 'get_guide',
+				args: { name: path, sections: [title] },
+			})
+		);
+	}
+	const composablesDir = join(AI_ROOT, 'composables');
+	if (existsSync(composablesDir)) {
+		for (const file of readdirSync(composablesDir).filter((f) =>
+			f.endsWith('.md')
+		)) {
+			const markdown = readFileSync(join(composablesDir, file), 'utf-8');
+			const name = file.slice(0, -3);
+			entries.push({
+				source: `composable ${name}`,
+				section: frontmatter(markdown).summary ?? name,
+				text: stripFrontmatter(markdown).slice(0, 4000),
+				read: { tool: 'get_composable', args: { name } },
+			});
+		}
+	}
+	const manifest = loadComponentsManifest();
+	for (const component of manifest.components.filter((c) => !c.referenceOnly)) {
+		const path = join(PACKAGE_ROOT, 'dist', component.contract ?? '');
+		if (component.contract && existsSync(path)) {
+			for (const section of contractGuideSections(
+				readFileSync(path, 'utf-8')
+			)) {
+				if (section.own.length < 40) continue;
+				entries.push({
+					source: `component ${component.name}`,
+					section: section.title,
+					text: section.own,
+					read: {
+						tool: 'get_component',
+						args: { name: component.name, sections: [section.title] },
+					},
+				});
+			}
+		}
+		for (const prop of component.props) {
+			if (prop.name.startsWith('pt')) continue;
+			entries.push({
+				source: `component ${component.name}`,
+				section: `prop ${prop.name}`,
+				text: `${prop.name}: ${prop.type}${prop.default ? ` = ${prop.default}` : ''}. ${prop.description ?? ''}`,
+				read: { tool: 'get_component', args: { name: component.name } },
+			});
+		}
+		for (const event of component.events ?? []) {
+			entries.push({
+				source: `component ${component.name}`,
+				section: `event ${event.name}`,
+				text: `@${event.name} ${event.signature}. ${event.description ?? ''}`,
+				read: { tool: 'get_component', args: { name: component.name } },
+			});
+		}
+	}
+	for (const platform of RECIPE_PLATFORMS) {
+		const dir = join(AI_ROOT, 'recipes', platform);
+		if (!existsSync(dir)) continue;
+		for (const file of readdirSync(dir).filter((f) => f.endsWith('.md'))) {
+			const name = file.slice(0, -3);
+			const markdown = readFileSync(join(dir, file), 'utf-8');
+			entries.push({
+				source: `recipe ${platform}/${name}`,
+				section: frontmatter(markdown).title ?? name,
+				text: frontmatter(markdown).summary ?? name,
+				read: { tool: 'get_recipe', args: { platform, name } },
+			});
+		}
+	}
+	const readme = join(PACKAGE_ROOT, 'README.md');
+	if (existsSync(readme)) {
+		addSections('README', readFileSync(readme, 'utf-8'), () => ({
+			tool: 'read file',
+			args: { path: 'node_modules/bitboss-ui/README.md' },
+		}));
+	}
+	cachedDocIndex = entries;
+	return entries;
+}
+
+function searchDocs({ query, limit } = {}) {
+	const max = Number.isFinite(limit) && limit > 0 ? Math.min(limit, 20) : 8;
+	const { tokens, total, results } = searchSections(docIndex(), query, max);
+	return {
+		query: query ?? '',
+		tokens,
+		count: results.length,
+		...(total > results.length ? { totalMatches: total } : {}),
+		results,
+		hint: results.length
+			? 'Each result is one section; `read` is the call that returns it whole. Prefer the top results: they match the most query words.'
+			: 'Nothing matched. Use fewer, more specific words (a prop, option or component name), or search_components for components.',
+	};
+}
+
+/** `get_composable({ name })` — one composable's doc (useToast, useConfirm…). */
+function getComposable({ name } = {}) {
+	const dir = join(AI_ROOT, 'composables');
+	const files = existsSync(dir)
+		? readdirSync(dir).filter((f) => f.endsWith('.md'))
+		: [];
+	const wanted = String(name ?? '').replace(/\.md$/, '');
+	const file = files.find(
+		(f) => f.slice(0, -3).toLowerCase() === wanted.toLowerCase()
 	);
-	return { found: true, name: fileName, content, ...meta };
+	if (!file) {
+		return {
+			found: false,
+			error: `Composable not found: ${name}`,
+			available: files.map((f) => f.slice(0, -3)),
+		};
+	}
+	return {
+		found: true,
+		name: file.slice(0, -3),
+		content: stripFrontmatter(readFileSync(join(dir, file), 'utf-8')),
+	};
 }
 
 function listRecipes({ platform } = {}) {
@@ -716,21 +1325,40 @@ function listRecipes({ platform } = {}) {
 			error: `Unknown platform(s): ${invalid.join(', ')} — expected one of ${RECIPE_PLATFORMS.join(', ')}`,
 		};
 	}
-	const recipes = [];
+	/*
+	 * One row per recipe with its platforms, title, summary and size (review
+	 * D6-13): records-workspace / inline-edit-workspace / approvals-inbox could
+	 * not be told apart by name, and each costs 11–61 KB to open.
+	 */
+	const byName = new Map();
 	for (const p of platforms) {
 		const dir = join(AI_ROOT, 'recipes', p);
 		if (!existsSync(dir)) continue;
 		for (const file of readdirSync(dir)) {
-			if (file.endsWith('.md')) {
-				recipes.push({ platform: p, name: file.slice(0, -3) });
-			}
+			if (!file.endsWith('.md')) continue;
+			const name = file.slice(0, -3);
+			const markdown = readFileSync(join(dir, file), 'utf-8');
+			const meta = frontmatter(markdown);
+			const row = byName.get(name) ?? {
+				name,
+				...(meta.title ? { title: meta.title } : {}),
+				...(meta.summary ? { summary: meta.summary } : {}),
+				platforms: [],
+				chars: {},
+			};
+			row.platforms.push(p);
+			row.chars[p] = markdown.length;
+			byName.set(name, row);
 		}
 	}
-	return { recipes };
+	return {
+		recipes: [...byName.values()],
+		hint: 'get_recipe({ platform, name }) returns the whole recipe (they are copied whole); pass sections to read only part of a long one.',
+	};
 }
 
 /** `get_recipe({ platform, name })` — read one recipe's markdown content. */
-function getRecipe({ platform, name, maxChars } = {}) {
+function getRecipe({ platform, name, sections, maxChars } = {}) {
 	if (!RECIPE_PLATFORMS.includes(platform)) {
 		return {
 			found: false,
@@ -760,9 +1388,26 @@ function getRecipe({ platform, name, maxChars } = {}) {
 			hint: 'Call list_recipes for the available names.',
 		};
 	}
+	const markdown = readFileSync(filePath, 'utf-8');
+	if (sections?.length) {
+		const all = splitSections(markdown);
+		const { picked, missing } = pickSections(all, sections);
+		return {
+			found: true,
+			platform,
+			name: fileName.slice(0, -3),
+			sections: picked.map((section) => ({
+				title: section.title,
+				text: section.text,
+			})),
+			...(missing.length ? { notFound: missing, outline: outline(all) } : {}),
+		};
+	}
+	// Whole by default (review D6-14): a recipe is copied whole, and the old
+	// 40 000-char default cut 7 of 9 vue recipes inside their page code.
 	const { content, ...meta } = truncateMarkdown(
-		readFileSync(filePath, 'utf-8'),
-		maxChars,
+		markdown,
+		maxChars ?? 0,
 		`Recipes are ordered narrative — the cut tail is later sections.`
 	);
 	return {
@@ -825,7 +1470,12 @@ function compareVersions(a, b) {
  * halves are fixed: rows are stamped with `firstReleasedIn` at build time, and
  * this serves the slice.
  */
-function listChanges({ since, until } = {}) {
+function listChanges({ since: rawSince, until: rawUntil } = {}) {
+	// The repo's own tags are spelled `v3.0.0-beta.33` (review D6-12).
+	const since =
+		rawSince == null ? rawSince : String(rawSince).replace(/^v/, '');
+	const until =
+		rawUntil == null ? rawUntil : String(rawUntil).replace(/^v/, '');
 	if (!existsSync(CHANGELOG_PATH)) {
 		return {
 			error: `changelog.json not found at ${CHANGELOG_PATH} — reinstall bitboss-ui (or run \`npm run build\` when working in the library repo).`,
@@ -895,7 +1545,8 @@ function toolCallback(fn) {
 		try {
 			const result = fn(args ?? {});
 			return {
-				content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+				// Compact JSON: indentation was a quarter of every answer (review D6).
+				content: [{ type: 'text', text: JSON.stringify(result) }],
 				isError: false,
 			};
 		} catch (error) {
@@ -910,11 +1561,25 @@ function toolCallback(fn) {
 
 const platformSchema = z.enum(RECIPE_PLATFORMS);
 
+/**
+ * Sent once at initialize (review D6-1): an MCP-only agent otherwise had no
+ * way to know which tool answers which question, and read whole guides.
+ */
+const SERVER_INSTRUCTIONS = [
+	'bitboss-ui: a Vue 3 component library. Answer from these tools, never from memory — agents that guess invent props.',
+	'- A topic or "how do I…" question (dark mode, cascade layers, SSR, a plugin option, a CLI command): search_docs, then open the section it points to.',
+	'- Which component: search_components (empty query = the whole catalog). One component: get_component({ name }) — compact; pass sections for guide prose, include for more.',
+	'- A type in a props table (BbTableColumn, ButtonVariantType): get_component({ name }) returns its definition and values.',
+	'- After writing markup: validate. Before custom CSS: list_tokens. Before bumping the version: list_changes({ since }).',
+	'- Composables (useToast, useConfirm…): get_composable. Whole pages: list_recipes, get_recipe.',
+	'- Long guides answer with an outline: pass sections.',
+].join('\n');
+
 /** Register the knowledge-base tools on a fresh McpServer instance. */
 function buildServer() {
 	const server = new McpServer(
 		{ name: 'bitboss-ui', version: packageVersion() },
-		{ capabilities: { tools: {} } }
+		{ capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }
 	);
 
 	server.registerTool(
@@ -949,16 +1614,30 @@ function buildServer() {
 		'get_component',
 		{
 			description:
-				'Get the full manifest entry (props/events/slots/models, removed/renamed history) for one bitboss-ui component by exact name, plus the rendered contract markdown content.',
+				"One bitboss-ui component: every prop, event, slot, v-model and pt part (never cut), the types its API uses with their values, the guide's outline and its Gotchas + Accessibility sections. Compact by default; pass `sections` for guide prose and `include` for more. Also answers for a public TYPE name (its definition and values), a v2/beta name that was removed or renamed (what replaced it), and near-miss spellings ('bb-button', 'Button').",
 			inputSchema: {
-				name: z.string().describe("Exact component name, e.g. 'BbButton'."),
+				name: z
+					.string()
+					.describe("Component name, e.g. 'BbButton' ('bb-button' works too)."),
+				sections: z
+					.array(z.string())
+					.optional()
+					.describe(
+						"Guide sections to return whole, by title from `guide.sections`, e.g. ['Toggle buttons']. Case-insensitive; a partial title matches."
+					),
+				include: z
+					.array(z.enum(['tree', 'cssProps', 'ptProps', 'history', 'contract']))
+					.optional()
+					.describe(
+						'Extra parts: tree = the component tree, cssProps = CSS variables with descriptions, ptProps = every pt:* prop row, history = full v2/beta rename records, contract = the whole contract markdown.'
+					),
 				maxChars: z
 					.number()
 					.int()
 					.min(0)
 					.optional()
 					.describe(
-						`Cap on the returned contract markdown (default ${MARKDOWN_DEFAULT_MAX_CHARS}; 0 = no cap). The structured props/events/slots are never truncated.`
+						`With include: ['contract'] only — cap on the contract markdown (default ${MARKDOWN_DEFAULT_MAX_CHARS}; 0 = no cap).`
 					),
 			},
 		},
@@ -1019,13 +1698,19 @@ function buildServer() {
 		'get_guide',
 		{
 			description:
-				"Read one bitboss-ui guide by name (as listed by list_guides, e.g. 'ai-router.md' or 'migration/v2-to-v3.md').",
+				"Read one bitboss-ui guide (names from list_guides, e.g. 'design-tokens' or 'migration/v2-to-v3'). A long guide answers with its outline: then pass `sections`. Pointers such as 'ai/guides/passthrough.md' or 'components/bb-table.md' resolve too.",
 			inputSchema: {
 				name: z
 					.string()
 					.describe(
 						"Guide path relative to the guides dir, e.g. 'design-tokens.md'. The '.md' suffix is optional."
 					),
+				sections: z
+					.array(z.string())
+					.optional()
+					.describe(
+						"Section titles from the outline, e.g. ['Dark mode']. A ## section includes its ### children."
+					),
 				maxChars: z
 					.number()
 					.int()
@@ -1043,7 +1728,7 @@ function buildServer() {
 		'list_recipes',
 		{
 			description:
-				'List available page-level recipes (whole-page compositions), optionally filtered by platform.',
+				'List the page-level recipes (whole-page compositions) with title, summary, platforms and size, optionally filtered by platform.',
 			inputSchema: {
 				platform: platformSchema
 					.optional()
@@ -1057,8 +1742,12 @@ function buildServer() {
 		'get_recipe',
 		{
 			description:
-				'Read the full markdown content of one recipe by platform and name.',
+				'Read one recipe by platform and name — whole by default (recipes are copied whole); pass `sections` to read part of a long one.',
 			inputSchema: {
+				sections: z
+					.array(z.string())
+					.optional()
+					.describe('Section titles to return instead of the whole recipe.'),
 				platform: platformSchema.describe(
 					'Which platform variant of the recipe to read.'
 				),
@@ -1070,12 +1759,44 @@ function buildServer() {
 					.int()
 					.min(0)
 					.optional()
+					.describe('Optional cap on the returned markdown (default: no cap).'),
+			},
+		},
+		toolCallback(getRecipe)
+	);
+
+	server.registerTool(
+		'search_docs',
+		{
+			description:
+				'Find the section that answers a question, across every guide, component guide, component prop and event, composable, recipe and the README. Use it for "how do I…" and "is there…" questions (dark mode, cascade layers, SSR, a plugin option, a CLI command, a migration). Each result is a snippet plus the exact call that reads the whole section.',
+			inputSchema: {
+				query: z
+					.string()
 					.describe(
-						`Cap on the returned markdown (default ${MARKDOWN_DEFAULT_MAX_CHARS}; 0 = no cap).`
+						"A few specific words, e.g. 'dark mode class' or 'tailwind cascade layers'."
 					),
+				limit: z
+					.number()
+					.int()
+					.positive()
+					.optional()
+					.describe('Max results (default 8, max 20).'),
 			},
 		},
-		toolCallback(getRecipe)
+		toolCallback(searchDocs)
+	);
+
+	server.registerTool(
+		'get_composable',
+		{
+			description:
+				"Read one composable's doc (useToast, useConfirm, useBbTableContext, useMobile…): what it returns, what host it needs, examples.",
+			inputSchema: {
+				name: z.string().describe("Composable name, e.g. 'useToast'."),
+			},
+		},
+		toolCallback(getComposable)
 	);
 
 	server.registerTool(
@@ -1132,7 +1853,11 @@ export const start = main;
  * concurrently. Importing this module does not start a server.
  */
 export {
+	buildServer,
+	SERVER_INSTRUCTIONS,
 	searchComponents,
+	searchDocs,
+	getComposable,
 	getComponent,
 	listTokens,
 	listGuides,