@dowel-ui/registry 0.4.0 → 0.7.0

package/dist/index.js

@@ -1,2 +1,648 @@
-import { a as registryIndexSchema, c as hashContent, i as registryIndexEntrySchema, n as registryFileSchema, o as registryItemSchema, r as registryFileTypeSchema, s as registryItemTypeSchema, t as REGISTRY_VERSION } from "./schema-ByqIpT47.js";
-export { REGISTRY_VERSION, hashContent, registryFileSchema, registryFileTypeSchema, registryIndexEntrySchema, registryIndexSchema, registryItemSchema, registryItemTypeSchema };
+import { blocksPathFor, planUi, renderBrief, renderPlan } from "./generate.js";
+import { a as registryIndexEntrySchema, c as registryItemTypeSchema, i as registryFileTypeSchema, l as hashContent, n as registryAccessSchema, o as registryIndexSchema, r as registryFileSchema, s as registryItemSchema, t as REGISTRY_VERSION } from "./schema-BbyNjH6Q.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+//#region src/custom.ts
+/**
+* Building a registry of your own components.
+*
+* The CLI has always been able to install from any registry — `--registry`
+* takes a URL or a directory — but producing one meant reimplementing this
+* package. So an organisation that wanted its own components installed the same
+* way had the consumer half and none of the producer half.
+*
+* The authoring shape is declared here rather than imported from the component
+* package, because the registry *is* the contract. A team publishing their own
+* components should not have to depend on somebody else's component library to
+* describe their own.
+*/
+/** Where an item's files are written in the consuming project. */
+const itemGroupSchema = z.enum([
+	"ui",
+	"blocks",
+	"lib",
+	"hooks"
+]);
+const GROUP_FILE_TYPE = {
+	ui: "registry:ui",
+	blocks: "registry:block",
+	lib: "registry:lib",
+	hooks: "registry:hook"
+};
+const itemSourceSchema = z.object({
+	name: z.string().regex(/^[a-z][a-z0-9-]*$/),
+	title: z.string().min(1),
+	description: z.string().min(10),
+	category: z.string().min(1),
+	status: z.enum([
+		"stable",
+		"beta",
+		"experimental"
+	]).default("stable"),
+	/** Where the files land. Defaults to `ui`. */
+	group: itemGroupSchema.default("ui"),
+	/** npm packages the source imports. */
+	dependencies: z.array(z.string()).default([]),
+	/** Other registry items this one imports, upstream ones included. */
+	registryDependencies: z.array(z.string()).default([]),
+	/** Files to publish, relative to the item's own directory. */
+	files: z.array(z.string().min(1)).min(1),
+	a11y: z.string().optional(),
+	access: registryAccessSchema,
+	/**
+	* Overrides where the item's directory is, relative to the registry root.
+	* Defaults to `<group>/<name>`, which is the layout this repository uses.
+	*/
+	directory: z.string().optional()
+});
+const registryConfigSchema = z.object({
+	/** Absolute path the item directories are resolved against. */
+	root: z.string().min(1),
+	items: z.array(itemSourceSchema).min(1),
+	/**
+	* A registry to layer on top of — a URL, or a directory on disk.
+	*
+	* The reason a private registry is worth having at all: one URL that serves
+	* both the upstream components and yours, so a consumer configures one place
+	* and `add` resolves across both.
+	*/
+	extends: z.string().min(1).optional(),
+	/** Written into the index, so a consumer can see what produced it. */
+	generatedFrom: z.string().min(1).default("custom-registry")
+});
+/** Identity helper, for editor autocomplete inside a config file. */
+function defineRegistryConfig(config) {
+	return config;
+}
+/**
+* Every `@/...` import a source file makes, as `[group, rest]`.
+*
+* Published source is authored against the library's own aliases and rewritten
+* at install time to wherever the consuming project keeps things. Both checks
+* below depend on reading those imports.
+*/
+function authoredImports(content) {
+	const found = [];
+	for (const match of content.matchAll(/["']@\/(components|lib|hooks|blocks)\/([^"']+)["']/g)) if (match[1] && match[2]) found.push({
+		group: match[1],
+		rest: match[2]
+	});
+	return found;
+}
+/**
+* Catches source written against the *installed* paths instead of the authored
+* ones.
+*
+* `@/components/ui/badge` looks right — it is where the file ends up — and
+* rewrites to `@/components/ui/ui/badge`, because the rewriter maps
+* `@/components/` to wherever the project keeps its components. The result
+* compiles nowhere and the doubled segment is easy to stare past. The authored
+* form is `@/components/badge`.
+*/
+function assertAuthoredPaths(name, content) {
+	const groups = /* @__PURE__ */ new Set([
+		"ui",
+		"blocks",
+		"lib",
+		"hooks"
+	]);
+	const mistaken = authoredImports(content).filter((entry) => groups.has(entry.rest.split("/")[0] ?? "")).map((entry) => `@/${entry.group}/${entry.rest}`);
+	if (mistaken.length > 0) throw new Error(`Item "${name}" imports from an installed path rather than an authored one:\n  ${[...new Set(mistaken)].join("\n  ")}\nWrite \`@/components/badge\`, not \`@/components/ui/badge\` — the leading group is rewritten to wherever the consuming project keeps its components, so naming it twice produces a path that resolves nowhere.`);
+}
+/**
+* Catches a component importing something it never declared.
+*
+* The undeclared dependency is not installed alongside it, so the install
+* succeeds and the project fails to build — in someone else's repository, where
+* it is hardest to trace back to here.
+*/
+function assertDeclaredDependencies(source, content) {
+	const declared = /* @__PURE__ */ new Set([...source.registryDependencies, source.name]);
+	const undeclared = authoredImports(content).filter((entry) => entry.group === "components" || entry.group === "blocks").map((entry) => entry.rest.split("/")[0] ?? "").filter((imported) => imported.length > 0 && !declared.has(imported));
+	if (undeclared.length > 0) throw new Error(`Item "${source.name}" imports ${[...new Set(undeclared)].join(", ")} but does not list them in registryDependencies. They would not be installed alongside it, and the failure would surface as a build error in the consuming project.`);
+}
+function toItem(root, source) {
+	const directory = source.directory ?? join(source.group, source.name);
+	const itemDir = join(root, directory);
+	const files = source.files.map((file) => {
+		const path = join(itemDir, file);
+		if (!existsSync(path)) throw new Error(`Item "${source.name}" lists ${file}, but ${path} does not exist. A registry that names a file it cannot read produces a broken install in someone else's project, where it is hardest to diagnose.`);
+		const content = readFileSync(path, "utf8");
+		assertAuthoredPaths(source.name, content);
+		assertDeclaredDependencies(source, content);
+		return {
+			path: `${source.group}/${file}`,
+			type: GROUP_FILE_TYPE[source.group],
+			content,
+			hash: hashContent(content)
+		};
+	});
+	return registryItemSchema.parse({
+		registryVersion: 1,
+		name: source.name,
+		type: registryItemTypeSchema.parse(GROUP_FILE_TYPE[source.group]),
+		title: source.title,
+		description: source.description,
+		category: source.category,
+		status: source.status,
+		dependencies: source.dependencies,
+		registryDependencies: source.registryDependencies,
+		files,
+		a11y: source.a11y,
+		access: source.access
+	});
+}
+async function readUpstream(base) {
+	const isHttp = base.startsWith("http://") || base.startsWith("https://");
+	const load = async (file) => {
+		if (!isHttp) {
+			const root = base.startsWith("file:") ? fileURLToPath(base) : base;
+			const path = join(root, file);
+			if (!existsSync(path)) throw new Error(`Upstream registry has no ${file} at ${path}.`);
+			return JSON.parse(readFileSync(path, "utf8"));
+		}
+		const url = `${base.replace(/\/$/, "")}/${file}`;
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Upstream registry returned ${String(response.status)} for ${url}.`);
+		return await response.json();
+	};
+	const index = registryIndexSchema.parse(await load("index.json"));
+	const items = [];
+	for (const entry of index.items) {
+		if (entry.access === "pro") continue;
+		items.push(registryItemSchema.parse(await load(`${entry.name}.json`)));
+	}
+	return items;
+}
+/**
+* Every `registryDependencies` name must exist in the finished registry.
+*
+* Checked here, once, rather than discovered by a consumer whose `add` walks
+* into a name nothing serves. This is the single most common way a
+* hand-assembled registry is broken, and it is invisible until someone installs.
+*/
+function assertResolvable(items) {
+	const known = new Set(items.map((item) => item.name));
+	const missing = [];
+	for (const item of items) for (const dependency of item.registryDependencies) if (!known.has(dependency)) missing.push(`${item.name} → ${dependency}`);
+	if (missing.length > 0) throw new Error(`These registry dependencies are not in the registry:\n  ${missing.join("\n  ")}\nAdd them, or extend a registry that has them.`);
+}
+async function buildCustomRegistry(config) {
+	const parsed = registryConfigSchema.parse(config);
+	const local = parsed.items.map((item) => toItem(parsed.root, item));
+	const duplicates = local.map((item) => item.name).filter((name, index, all) => all.indexOf(name) !== index);
+	if (duplicates.length > 0) throw new Error(`Declared more than once: ${[...new Set(duplicates)].join(", ")}.`);
+	if (!parsed.extends) {
+		assertResolvable(local);
+		return {
+			items: local,
+			overridden: [],
+			inherited: 0
+		};
+	}
+	const upstream = await readUpstream(parsed.extends);
+	const localNames = new Set(local.map((item) => item.name));
+	const overridden = upstream.filter((item) => localNames.has(item.name)).map((item) => item.name);
+	const inherited = upstream.filter((item) => !localNames.has(item.name));
+	const items = [...inherited, ...local].sort((a, b) => a.name.localeCompare(b.name));
+	assertResolvable(items);
+	return {
+		items,
+		overridden,
+		inherited: inherited.length
+	};
+}
+//#endregion
+//#region src/agent-docs.ts
+const CATEGORY_LABELS = {
+	foundation: "Foundation",
+	form: "Forms",
+	overlay: "Overlays",
+	navigation: "Navigation",
+	display: "Display",
+	data: "Data",
+	feedback: "Feedback",
+	layout: "Layout",
+	ai: "AI"
+};
+const CATEGORY_ORDER = [
+	"foundation",
+	"form",
+	"overlay",
+	"navigation",
+	"display",
+	"data",
+	"feedback",
+	"layout",
+	"ai"
+];
+function label(category) {
+	return CATEGORY_LABELS[category] ?? category;
+}
+/** Ordered by curation where curated, alphabetical for anything new. */
+function categoriesOf(entries) {
+	const present = new Set(entries.map((entry) => entry.category));
+	const known = CATEGORY_ORDER.filter((category) => present.has(category));
+	const rest = [...present].filter((category) => !CATEGORY_ORDER.includes(category)).sort();
+	return [...known, ...rest];
+}
+function byType(index, type) {
+	return index.items.filter((entry) => entry.type === type).sort((a, b) => a.name.localeCompare(b.name));
+}
+function components(index) {
+	return byType(index, "registry:ui");
+}
+function blocks(index) {
+	return byType(index, "registry:block");
+}
+/**
+* Accessibility rules that differ from what a model has seen elsewhere.
+*
+* An agent trained on every other React library will reach for `disabled` on a
+* loading button and a live region on every alert. Stating only the deltas is
+* deliberate: a general accessibility lecture is ignored, a short list of
+* "here this is different" is followed.
+*/
+const ACCESSIBILITY_DELTAS = [
+	"A loading `Button` uses `aria-disabled` + `aria-busy` and guards its own click handler. Never add `disabled` to it — disabling a control mid-action strands keyboard focus.",
+	"`Alert` is not a live region by default. One that exists on first paint announces for no reason. Opt in with `live=\"polite\"` or `live=\"assertive\"` only when the alert appears in response to something.",
+	"`Separator`, `Skeleton` and `Spinner` are decorative and stay out of the accessibility tree unless given a label. Do not add `role` or `aria-label` to them by reflex.",
+	"`PopoverContent` carries `role=\"dialog\"` and warns in development without an accessible name. Always give it `aria-label` or `aria-labelledby`.",
+	"Never use colour as the only signal. The `monochrome` preset exists as a standing check on exactly this — if a state is unreadable under it, the component is wrong."
+];
+const TOKEN_RULES = [
+	"Use semantic tokens (`bg-background`, `text-foreground`, `border-border`, `ring-ring`, `bg-primary`, `text-muted-foreground`). Never raw hex, and never Tailwind's own palette (`bg-slate-900`, `text-gray-500`) — those do not follow the theme and break every preset and dark mode.",
+	"Spacing, radius and type come from the scale. `rounded-md` and `rounded-lg` re-proportion with `--radius-scale`; an arbitrary `rounded-[7px]` does not.",
+	"Durations derive from `--motion-scale`. Do not hardcode transition timings.",
+	"Compose class names with `cn()` from the project's utils, so consumer overrides win over defaults."
+];
+function conventionsDoc(context) {
+	const { libraryName, cliPackage, importFrom, docsUrl } = context;
+	return `# ${libraryName} — conventions
+
+Rules for writing code in this project. ${libraryName} is **source-first**: its
+components are files in this repository, not a dependency you can reason about
+from its README. They are yours to edit, and edits are preserved across updates.
+
+## The rule that matters most
+
+**Do not hand-write a component that ${libraryName} already has.** Check the
+catalogue in \`components.md\` first. Writing a second Button — with different
+focus rings, different disabled semantics, different tokens — is the single
+most common and most damaging thing to do here.
+
+## Adding a component
+
+\`\`\`bash
+npx ${cliPackage} add <name>
+\`\`\`
+
+This writes the source into the project and installs whatever it depends on.
+\`add\` is safe to re-run: an untouched file is left alone, an edited one is
+never overwritten without \`--overwrite\`.
+
+Do not \`npm install\` a component. Do not copy source out of the documentation
+by hand — the CLI resolves the dependency graph and rewrites imports to this
+project's path alias, and doing it manually gets both wrong.
+
+## Importing
+
+\`\`\`tsx
+import { Button, Card, CardContent } from "${importFrom}";
+\`\`\`
+
+## Styling
+
+${TOKEN_RULES.map((rule) => `- ${rule}`).join("\n")}
+
+## Accessibility
+
+Targeted at WCAG 2.2 AA, verified with axe per component. Where ${libraryName}
+differs from what you have seen in other libraries:
+
+${ACCESSIBILITY_DELTAS.map((rule) => `- ${rule}`).join("\n")}
+
+## Before you build a page
+
+Check \`components.md\` for a **block** that already covers it. A block is a
+whole section — a login form, a settings page, a chat surface — and installing
+one brings every component it is assembled from. Building a dashboard out of
+individual primitives when \`add dashboard\` exists is wasted work.
+
+## Reference
+
+- Documentation: ${docsUrl}
+- Full text for models: ${docsUrl}/llms-full.txt
+`;
+}
+function componentsDoc(context) {
+	const { index, libraryName, cliPackage, installed } = context;
+	const have = new Set(installed ?? []);
+	const known = installed !== void 0;
+	const ui = components(index);
+	const blk = blocks(index);
+	const lines = [
+		`# ${libraryName} — catalogue`,
+		"",
+		`${String(ui.length)} components and ${String(blk.length)} blocks, generated from \`${index.generatedFrom}\`. This is the complete list — anything not here does not exist.`,
+		""
+	];
+	if (known) lines.push("`✓` marks what is already installed in this project. Everything else needs", `\`npx ${cliPackage} add <name>\` before it can be imported.`, "");
+	const mark = (entry) => known ? have.has(entry.name) ? "✓ " : "  " : "";
+	for (const category of categoriesOf(ui)) {
+		lines.push(`## ${label(category)}`, "");
+		for (const entry of ui.filter((item) => item.category === category)) {
+			const status = entry.status === "stable" ? "" : ` _(${entry.status})_`;
+			lines.push(`- ${mark(entry)}**${entry.name}** — ${entry.description}${status}`);
+		}
+		lines.push("");
+	}
+	lines.push("## Blocks", "", "Whole sections. Installing one installs every component it is built from.", "");
+	for (const entry of blk) {
+		const deps = entry.registryDependencies.length;
+		const resolves = deps > 0 ? ` _(resolves ${String(deps)} components)_` : "";
+		lines.push(`- ${mark(entry)}**${entry.name}** — ${entry.description}${resolves}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function aiDoc(context) {
+	const { index, libraryName, cliPackage } = context;
+	const ai = components(index).filter((entry) => entry.category === "ai");
+	return `# ${libraryName} — AI components
+
+${String(ai.length)} surfaces for AI features. Reach for these before building
+anything custom for a model-facing interface.
+
+Most component sets ship a chat transcript and stop. Real AI features are
+extraction, enrichment, autofill and agents that *change things* — so the parts
+that matter are the ones around the transcript, not the transcript itself.
+
+${ai.map((entry) => `- **${entry.name}** — ${entry.description}`).join("\n")}
+
+## Choosing between them
+
+- Rendering a conversation → \`ai-conversation\` with \`ai-message\` and \`ai-response\`.
+- The composer → \`ai-prompt-input\`, with \`ai-model-selector\` if the model is switchable.
+- A tool the model called → \`ai-tool\`. Its arguments and result belong there, not in prose.
+- Asking permission *before* a tool runs → \`ai-approval-request\`.
+- Reporting what it did *after* → \`ai-action-ledger\`, which is also where reversibility belongs. A deletion can be undone, a refund can only be offset, a sent email cannot be taken back — the ledger is where that distinction is shown.
+- An object streaming in field by field → \`ai-structured-output\`, which reserves layout up front so nothing jumps.
+- Ghost text in a real textarea → \`ai-inline-completion\`. Escape always returns Tab to focus management, so a keyboard user is never trapped.
+- A value the model proposes for a form field → \`ai-suggested-value\`.
+- Reviewing what was pulled out of a document → \`ai-extraction-review\`.
+- Long-running work → \`ai-agent-status\` and \`ai-agent-plan\`.
+- Where an answer came from → \`ai-sources\`. Cost → \`ai-token-usage\`. Chain of thought → \`ai-reasoning\`.
+
+## Whole surface at once
+
+\`\`\`bash
+npx ${cliPackage} add ai-chat
+\`\`\`
+`;
+}
+function themesDoc(context) {
+	const { libraryName } = context;
+	return `# ${libraryName} — theming
+
+Tokens are two-tier. **Tier 1** is raw scales: an OKLCH neutral ramp, a radius
+ladder, a 15px-base type scale, elevation, motion. **Tier 2** is semantic
+aliases — \`--primary\`, \`--background\`, \`--border\`, \`--ring\` — and components
+consume Tier 2 *exclusively*.
+
+Re-skinning the system means reassigning Tier 2. It never means editing a
+component file. If you find yourself changing a colour inside a component, the
+change belongs in the token layer instead.
+
+## Presets
+
+\`default\`, \`ocean\`, \`emerald\`, \`violet\`, \`rose\`, \`amber\`, \`monochrome\`.
+
+\`\`\`html
+<html data-theme="ocean" class="dark">
+\`\`\`
+
+\`data-theme\` selects the preset; the \`dark\` class selects the mode. They are
+independent — every preset works in both.
+
+\`monochrome\` is not only a style. It is a standing check that no component uses
+colour as its only signal, so verify new work under it.
+
+## Two properties that re-proportion everything
+
+- \`--radius-scale\` — one multiplier behind every corner in the system. \`1\` is the designed default, \`0\` is fully square.
+- \`--motion-scale\` — one multiplier every duration derives from. Under \`prefers-reduced-motion\` it collapses, but indicators that report ongoing state are *slowed* rather than stopped via \`--motion-scale-indicator\`, because a frozen spinner reads as a hung application.
+
+## Contrast
+
+All semantic pairs are verified against WCAG 2.2 AA across both modes and every
+preset, in CI. A new token pair has to pass the same check — do not introduce
+one without running \`audit:contrast\`.
+`;
+}
+/** Frontmatter-carrying skill file for Claude Code. */
+function skillDoc(context) {
+	const { index, libraryName, cliPackage, importFrom } = context;
+	const ui = components(index);
+	const blk = blocks(index);
+	const names = ui.map((entry) => entry.name).join(", ");
+	return `---
+name: ${libraryName.toLowerCase()}-ui
+description: >-
+  Build React interfaces with ${libraryName}, the source-first component system
+  installed in this project. Use whenever writing or editing React UI here —
+  any button, form, dialog, table, dashboard or AI surface. Covers the
+  ${String(ui.length)}-component catalogue, the ${String(blk.length)} blocks, design tokens, theming
+  and the accessibility rules that differ from other libraries.
+---
+
+# ${libraryName}
+
+Source-first React components. They are **files in this repository**, not a
+dependency — installed with a CLI, then owned and edited like any other code.
+
+## Do this first
+
+Never hand-write a component ${libraryName} already has. The catalogue:
+
+${names}
+
+Blocks (whole sections, each resolving its own components):
+${blk.map((entry) => entry.name).join(", ")}
+
+## Adding one
+
+\`\`\`bash
+npx ${cliPackage} add button card dialog
+\`\`\`
+
+Resolves dependencies, installs npm packages, rewrites imports to this
+project's alias. Safe to re-run — it will not overwrite a file you have edited
+without \`--overwrite\`.
+
+## Importing
+
+\`\`\`tsx
+import { Button, Card, CardContent } from "${importFrom}";
+\`\`\`
+
+## Styling rules
+
+${TOKEN_RULES.map((rule) => `- ${rule}`).join("\n")}
+
+## Accessibility rules that differ here
+
+${ACCESSIBILITY_DELTAS.map((rule) => `- ${rule}`).join("\n")}
+
+## Reference files
+
+- \`.dowel/components.md\` — the full catalogue with descriptions
+- \`.dowel/ai.md\` — the AI components and when to use each
+- \`.dowel/themes.md\` — tokens, presets, radius and motion scales
+- \`.dowel/conventions.md\` — the rules above, in full
+`;
+}
+/** Cursor project rule (`.cursor/rules/*.mdc`). */
+function cursorRule(context) {
+	const { index, libraryName, cliPackage, importFrom } = context;
+	const ui = components(index);
+	return `---
+description: ${libraryName} component system — use for all React UI in this project
+globs: ["**/*.tsx", "**/*.jsx"]
+alwaysApply: false
+---
+
+${libraryName} is source-first: its ${String(ui.length)} components are files in this
+repository. Never hand-write one that already exists.
+
+Add: \`npx ${cliPackage} add <name>\`
+Import: \`import { Button } from "${importFrom}"\`
+
+Available: ${ui.map((entry) => entry.name).join(", ")}
+
+${TOKEN_RULES.map((rule) => `- ${rule}`).join("\n")}
+${ACCESSIBILITY_DELTAS.map((rule) => `- ${rule}`).join("\n")}
+
+Full catalogue and reasoning: \`.dowel/\`
+`;
+}
+const AGENTS_MARKER_START = "<!-- dowel:start -->";
+const AGENTS_MARKER_END = "<!-- dowel:end -->";
+/**
+* The block written into a project's AGENTS.md.
+*
+* Marker-wrapped rather than written as a whole file: AGENTS.md belongs to the
+* project and usually already says things about the project. Replacing it would
+* destroy that; appending without markers would duplicate the section on every
+* regeneration.
+*/
+function agentsSection(context) {
+	const { index, libraryName, cliPackage, importFrom } = context;
+	const ui = components(index);
+	return `${AGENTS_MARKER_START}
+
+## UI components — ${libraryName}
+
+This project uses ${libraryName}, a **source-first** component system: its
+${String(ui.length)} components live in this repository as editable files.
+
+- **Never hand-write a component that already exists.** The full catalogue is in \`.dowel/components.md\`.
+- Add one with \`npx ${cliPackage} add <name>\` — never \`npm install\`, never copy source by hand.
+- Import from \`${importFrom}\`.
+- Style with semantic tokens only (\`bg-background\`, \`text-muted-foreground\`), never raw hex and never Tailwind's own palette.
+- Building a page? Check \`.dowel/components.md\` for a **block** first.
+- Building an AI feature? \`.dowel/ai.md\` lists surfaces you will not find elsewhere.
+- Accessibility deltas from other libraries are in \`.dowel/conventions.md\`. Read them before adding ARIA by reflex.
+
+${AGENTS_MARKER_END}`;
+}
+/** Replaces the marked block, or appends it if there is none. */
+function upsertAgentsSection(existing, section) {
+	const start = existing.indexOf(AGENTS_MARKER_START);
+	const end = existing.indexOf(AGENTS_MARKER_END);
+	if (start !== -1 && end !== -1 && end > start) return existing.slice(0, start) + section + existing.slice(end + 18);
+	const base = existing.trimEnd();
+	return base.length > 0 ? `${base}\n\n${section}\n` : `${section}\n`;
+}
+/**
+* The llms.txt index.
+*
+* Deliberately a map rather than a dump: it names every component and points at
+* the one URL that carries everything, so a model with a small budget can find
+* the right page and one with a large budget can take the lot.
+*/
+function llmsTxt(context) {
+	const { index, libraryName, docsUrl, cliPackage } = context;
+	const ui = components(index);
+	const blk = blocks(index);
+	const lines = [
+		`# ${libraryName}`,
+		"",
+		`> Source-first React components for SaaS and AI products. ${String(ui.length)} components and ${String(blk.length)} blocks, installed as code you own rather than imported from a dependency. Built on Tailwind v4 and OKLCH design tokens, targeted at WCAG 2.2 AA.`,
+		"",
+		`Install: \`npx ${cliPackage} add <name>\` writes the component's source into your project.`,
+		"Re-running is safe — files you have edited are never overwritten without `--overwrite`.",
+		"",
+		`Generated from ${index.generatedFrom}.`,
+		"",
+		"## Start here",
+		"",
+		`- [Everything, in one file](${docsUrl}/llms-full.txt): the complete catalogue with descriptions, accessibility notes and conventions`,
+		`- [Installation](${docsUrl}/docs/installation)`,
+		`- [CLI](${docsUrl}/docs/cli)`,
+		`- [Theming](${docsUrl}/docs/themes)`,
+		`- [Accessibility](${docsUrl}/docs/accessibility)`,
+		""
+	];
+	for (const category of categoriesOf(ui)) {
+		lines.push(`## ${label(category)}`, "");
+		for (const entry of ui.filter((item) => item.category === category)) lines.push(`- [${entry.name}](${docsUrl}/docs/components/${entry.name}): ${entry.description}`);
+		lines.push("");
+	}
+	lines.push("## Blocks", "");
+	for (const entry of blk) lines.push(`- [${entry.name}](${docsUrl}/docs/blocks/${entry.name}): ${entry.description}`);
+	lines.push("");
+	return lines.join("\n");
+}
+/** Everything an agent needs, in one request. */
+function llmsFullTxt(context) {
+	const { index, items, libraryName, docsUrl } = context;
+	const detail = new Map((items ?? []).map((item) => [item.name, item]));
+	const parts = [
+		conventionsDoc(context),
+		componentsDoc({
+			...context,
+			installed: void 0
+		}),
+		aiDoc(context),
+		themesDoc(context)
+	];
+	const lines = [
+		`# ${libraryName} — full reference`,
+		"",
+		`Generated from ${index.generatedFrom}. Canonical source: ${docsUrl}`,
+		"",
+		"---",
+		"",
+		parts.join("\n---\n\n")
+	];
+	if (detail.size > 0) {
+		lines.push("---", "", "# Per-component detail", "");
+		for (const entry of components(index)) {
+			const item = detail.get(entry.name);
+			lines.push(`## ${entry.title} \`${entry.name}\``, "", entry.description, "");
+			lines.push(`- Category: ${label(entry.category)} · Status: ${entry.status}`, `- Install: \`add ${entry.name}\``);
+			if (entry.registryDependencies.length > 0) lines.push(`- Also installs: ${entry.registryDependencies.join(", ")}`);
+			if (entry.dependencies.length > 0) lines.push(`- npm: ${entry.dependencies.join(", ")}`);
+			if (item?.a11y) lines.push(`- Accessibility: ${item.a11y}`);
+			lines.push("");
+		}
+	}
+	return lines.join("\n");
+}
+//#endregion
+export { AGENTS_MARKER_END, AGENTS_MARKER_START, REGISTRY_VERSION, agentsSection, aiDoc, assertResolvable, blocksPathFor, buildCustomRegistry, componentsDoc, conventionsDoc, cursorRule, defineRegistryConfig, hashContent, itemGroupSchema, itemSourceSchema, llmsFullTxt, llmsTxt, planUi, registryAccessSchema, registryConfigSchema, registryFileSchema, registryFileTypeSchema, registryIndexEntrySchema, registryIndexSchema, registryItemSchema, registryItemTypeSchema, renderBrief, renderPlan, skillDoc, themesDoc, upsertAgentsSection };
+
+//# sourceMappingURL=index.js.map