delacour 0.5.0-alpha.20261021114607 → 0.5.0

package/dist/index.js

@@ -4068,6 +4068,70 @@ ${r ? styleText("cyan", S_BAR_END) : ""}
 	}
 }).prompt();
 //#endregion
+//#region src/registry/test-runner.ts
+/**
+* The runner a project's copied tests are written for.
+*
+* The library's suites are Bun's, and the registry build holds every shipped one
+* to the API Bun, Jest and Vitest share — `describe` / `test` / `it` / `expect`
+* and the four hooks, a `node:*` read beside itself through
+* `import.meta.dirname`, and nothing else. So a suite moves between runners by
+* two substitutions and no parsing: the module the API is imported from, and,
+* for Jest, which cannot evaluate `import.meta` in CommonJS, `__dirname`.
+*/
+const TEST_RUNNERS = [
+	"bun",
+	"jest",
+	"vitest"
+];
+/** Where each runner's shared API is imported from. */
+const RUNNER_MODULE = {
+	bun: "bun:test",
+	jest: "@jest/globals",
+	vitest: "vitest"
+};
+/**
+* What a project needs to typecheck and run its copied tests. `node:*` imports
+* need Node's types everywhere but Bun, whose own types carry them.
+*/
+const RUNNER_PACKAGES = {
+	bun: ["@types/bun"],
+	jest: ["@jest/globals", "@types/node"],
+	vitest: ["@types/node", "vitest"]
+};
+const BUN_TEST_IMPORT = /(from\s*)(["'])bun:test\2/g;
+/** A copied test's text as `runner` runs it. */
+function adaptTest(content, runner) {
+	if (runner === "bun") return content;
+	const imported = content.replace(BUN_TEST_IMPORT, (_match, from, quote) => {
+		return `${from}${quote}${RUNNER_MODULE[runner]}${quote}`;
+	});
+	return runner === "jest" ? imported.replaceAll("import.meta.dirname", "__dirname") : imported;
+}
+function testRunnerPackages(runner) {
+	return [...RUNNER_PACKAGES[runner]];
+}
+/**
+* The runner a `package.json` tests with, or `null` when it names none.
+*
+* The `test` script is read first: it is the runner the project actually
+* invokes, where a dependency may be a leftover. `jest-expo` is Expo's own
+* preset, so it counts as Jest.
+*/
+function detectTestRunner(manifest) {
+	const script = manifest.scripts?.test ?? "";
+	if (/\bvitest\b/.test(script)) return "vitest";
+	if (/\bjest\b/.test(script)) return "jest";
+	if (/\bbun\s+test\b/.test(script)) return "bun";
+	const packages = {
+		...manifest.dependencies,
+		...manifest.devDependencies
+	};
+	if ("vitest" in packages) return "vitest";
+	if ("jest" in packages || "jest-expo" in packages || manifest.jest !== void 0) return "jest";
+	return null;
+}
+//#endregion
 //#region ../../node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -10016,6 +10080,12 @@ const registrySchema = object$1({
 const packageSchema = object$1({ 
 /** The package's npm name, and therefore the app's import prefix. */
 name: string().min(1) });
+/**
+* How copied tests are written. Without a `runner`, `add --tests` reads the one
+* the project's `package.json` tests with, and falls back to Bun's, which the
+* library's suites are written for.
+*/
+const testsSchema = object$1({ runner: _enum(TEST_RUNNERS).optional() });
 const configSchema = object$1({
 	$schema: string().optional(),
 	framework: _enum(["expo", "react-native"]).default("expo"),
@@ -10027,7 +10097,8 @@ const configSchema = object$1({
 	aliases: aliasesSchema.default({}),
 	/** Absent when the components live in the app itself. */
 	package: packageSchema.optional(),
-	app: appSchema.prefault({})
+	app: appSchema.prefault({}),
+	tests: testsSchema.optional()
 });
 const CONFIG_FILENAME = "native-components.json";
 const CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/delacournz/delacour-ui/main/registry/config.schema.json";
@@ -10069,14 +10140,35 @@ async function readConfig(configPath) {
 		const issues = result.error.issues.map((issue) => `  ${issue.path.join(".") || "(root)"}: ${issue.message}`);
 		throw new Error(`${configPath} is not a valid config:\n${issues.join("\n")}`);
 	}
-	return resolveConfig(result.data, dirname(configPath), configPath);
+	const root = dirname(configPath);
+	const detected = result.data.tests?.runner ? null : await readTestRunner([root, absolute(root, result.data.app.root)]);
+	return resolveConfig(result.data, root, configPath, detected);
+}
+/**
+* The runner the first of `directories` to name one tests with. The config's
+* own `package.json` comes first — in a monorepo that is the shared package the
+* tests land in — then the app's.
+*/
+async function readTestRunner(directories) {
+	for (const directory of new Set(directories)) {
+		let manifest;
+		try {
+			manifest = JSON.parse(await readFile(join(directory, "package.json"), "utf-8"));
+		} catch {
+			continue;
+		}
+		const runner = detectTestRunner(manifest);
+		if (runner) return runner;
+	}
+	return null;
 }
-function resolveConfig(config, root, configPath) {
+function resolveConfig(config, root, configPath, detectedRunner = null) {
 	const appRoot = absolute(root, config.app.root);
 	return {
 		...config,
 		root,
 		configPath,
+		testRunner: config.tests?.runner ?? detectedRunner ?? "bun",
 		directories: {
 			ui: absolute(root, config.paths.ui),
 			lib: absolute(root, config.paths.lib),
@@ -10405,10 +10497,10 @@ const LOCKFILES = [
 async function detectProject(cwd) {
 	const packageJsonPath = findUp(cwd, "package.json");
 	const packageRoot = packageJsonPath ? dirname(packageJsonPath) : null;
-	const packageJson = packageJsonPath ? await readJson$1(packageJsonPath) : null;
+	const packageJson = packageJsonPath ? await readJson$2(packageJsonPath) : null;
 	const workspaceRoot = await findWorkspaceRoot(packageRoot ?? cwd);
 	const appRoot = await findAppRoot(cwd, workspaceRoot);
-	const appPackage = appRoot ? await readJson$1(join(appRoot, "package.json")) : null;
+	const appPackage = appRoot ? await readJson$2(join(appRoot, "package.json")) : null;
 	const tsconfigPath = findUp(cwd, "tsconfig.json");
 	const tsconfig = tsconfigPath ? await readJsonc(tsconfigPath) : null;
 	return {
@@ -10444,7 +10536,7 @@ async function findWorkspaceRoot(from) {
 	let directory = resolve(from);
 	while (true) {
 		if (existsSync(join(directory, "pnpm-workspace.yaml"))) return directory;
-		if ((await readJson$1(join(directory, "package.json")))?.workspaces) return directory;
+		if ((await readJson$2(join(directory, "package.json")))?.workspaces) return directory;
 		const parent = dirname(directory);
 		if (parent === directory) return null;
 		directory = parent;
@@ -10460,7 +10552,7 @@ async function findWorkspaceRoot(from) {
 async function findAppRoot(cwd, workspaceRoot) {
 	let directory = resolve(cwd);
 	while (true) {
-		const packageJson = await readJson$1(join(directory, "package.json"));
+		const packageJson = await readJson$2(join(directory, "package.json"));
 		if (packageJson && versionOf(packageJson, "expo")) return directory;
 		const parent = dirname(directory);
 		if (parent === directory || workspaceRoot && directory === workspaceRoot) break;
@@ -10479,7 +10571,7 @@ async function findExpoPackageIn(directory) {
 	}
 	for (const entry of entries.sort()) {
 		const candidate = join(directory, entry);
-		const packageJson = await readJson$1(join(candidate, "package.json"));
+		const packageJson = await readJson$2(join(candidate, "package.json"));
 		if (packageJson && versionOf(packageJson, "expo")) return candidate;
 	}
 	return null;
@@ -10503,7 +10595,7 @@ function findUp(from, filename) {
 		directory = parent;
 	}
 }
-async function readJson$1(path) {
+async function readJson$2(path) {
 	try {
 		return JSON.parse(await readFile(path, "utf-8"));
 	} catch {
@@ -10863,7 +10955,7 @@ const exec = x;
 function channelFor(version) {
 	return /-alpha\b/.test(version) ? "alpha" : "latest";
 }
-const CLI_CHANNEL = channelFor("0.5.0-alpha.20261021114607");
+const CLI_CHANNEL = channelFor("0.5.0");
 //#endregion
 //#region src/project/package-manager.ts
 const ADD = {
@@ -10971,9 +11063,9 @@ function installCommands(request) {
 function planDependencies(request, packageJson) {
 	const groups = installCommands({
 		packageManager: request.packageManager,
-		expoDependencies: missingPackages(packageJson, request.expoDependencies),
-		dependencies: missingPackages(packageJson, request.dependencies),
-		devDependencies: missingPackages(packageJson, request.devDependencies),
+		expoDependencies: missingPackages$1(packageJson, request.expoDependencies),
+		dependencies: missingPackages$1(packageJson, request.dependencies),
+		devDependencies: missingPackages$1(packageJson, request.devDependencies),
 		channel: request.channel
 	});
 	const wanted = unique([
@@ -10998,7 +11090,7 @@ function unique(names) {
 	return [...new Set(names)].sort();
 }
 /** The packages in `wanted` that the project does not already have. */
-function missingPackages(packageJson, wanted) {
+function missingPackages$1(packageJson, wanted) {
 	const installed = /* @__PURE__ */ new Set([...Object.keys(packageJson?.dependencies ?? {}), ...Object.keys(packageJson?.devDependencies ?? {})]);
 	return wanted.filter((name) => !installed.has(name));
 }
@@ -11117,7 +11209,7 @@ function sharedTsconfig() {
 async function syncSharedPackage(config, peers) {
 	if (!config.package) return null;
 	const path = join(config.root, "package.json");
-	const existing = await readJson(path);
+	const existing = await readJson$1(path);
 	const merged = mergePackageJson(existing, {
 		name: config.package.name,
 		exports: buildExportsMap(config.paths, await collectWritten(config)),
@@ -11144,7 +11236,7 @@ async function linkPackageToApp(config) {
 	if (!config.package) return false;
 	if (config.app.resolved.root === config.root) return false;
 	const path = join(config.app.resolved.root, "package.json");
-	const app = await readJson(path);
+	const app = await readJson$1(path);
 	if (!app) return false;
 	const name = config.package.name;
 	if (app.dependencies?.[name] || app.peerDependencies?.[name]) return false;
@@ -11170,7 +11262,7 @@ async function listFiles(root, recursive) {
 		withFileTypes: true
 	})).filter((entry) => entry.isFile()).map((entry) => toPosix$6(relative(root, join(entry.parentPath, entry.name)))).sort();
 }
-async function readJson(path) {
+async function readJson$1(path) {
 	try {
 		return JSON.parse(await readFile(path, "utf-8"));
 	} catch {
@@ -11184,6 +11276,212 @@ function toPosix$6(path) {
 	return sep === "/" ? path : path.split(sep).join("/");
 }
 //#endregion
+//#region src/registry/classify.ts
+/**
+* Maps a path inside `packages/react-native-ui/src` onto the registry item it
+* belongs to and where it lands in a consumer's project.
+*
+* The rules here are `react-native-ui`'s own conventions, restated — one component
+* per folder with an `index.ts` entry point, flat files under `lib/`, `hooks/`
+* and `icons/`. `packages/react-native-ui/scripts/gen-exports.ts` reads the same
+* shape to build the package's `exports` map, so a component folder that is
+* malformed fails there first.
+*
+* Pure and filesystem-free, so the whole mapping is reachable from `bun test`.
+*/
+const REGISTRY_TYPES = [
+	"registry:ui",
+	"registry:lib",
+	"registry:hook",
+	"registry:style"
+];
+/** A test, or a file that exists only to serve tests — `*.test-helpers.ts`, `*.fixtures.ts`. */
+function isTest(path) {
+	return /\.(test|test-helpers|fixtures)\.tsx?$/.test(path);
+}
+//#endregion
+//#region src/project/test-setup.ts
+/** Expo's base config, which SDK 58's `exports` map hides from Vite's tsconfig loader. */
+const EXPO_TSCONFIG = "expo/tsconfig.base";
+function checkTestRunner(setup) {
+	const name = "Test runner";
+	if (setup.copiedTests === 0) return {
+		name,
+		status: "skip",
+		detail: "no copied tests"
+	};
+	const problems = [
+		...missingPackages(setup),
+		...mismatchedScript(setup),
+		...runnerProblems(setup)
+	];
+	const count = `${setup.copiedTests} copied test${setup.copiedTests === 1 ? "" : "s"}`;
+	if (problems.length === 0) return {
+		name,
+		status: "pass",
+		detail: `${count} set up for ${setup.runner}`
+	};
+	return {
+		name,
+		status: "warn",
+		detail: `${count} for ${setup.runner}, but ${problems.map((problem) => problem.detail).join("; ")}`,
+		fix: problems.map((problem) => problem.fix).join(" ")
+	};
+}
+function missingPackages(setup) {
+	const missing = [...setup.runner === "jest" ? ["jest"] : [], ...testRunnerPackages(setup.runner)].filter((name) => !(name in setup.dependencies));
+	if (missing.length === 0) return [];
+	return [{
+		detail: `${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not installed`,
+		fix: `Install ${missing.map((name) => `\`${name}\``).join(", ")} as dev dependencies.`
+	}];
+}
+function mismatchedScript(setup) {
+	if (setup.scripted === null || setup.scripted === setup.runner) return [];
+	return [{
+		detail: `the project runs ${setup.scripted}`,
+		fix: `Set \`tests.runner\` to "${setup.scripted}" in native-components.json and run \`update --tests\` to rewrite them, or point the \`test\` script at ${setup.runner}.`
+	}];
+}
+function runnerProblems(setup) {
+	switch (setup.runner) {
+		case "bun": return [];
+		case "jest": return jestProblems(setup);
+		case "vitest": return vitestProblems(setup);
+	}
+}
+/**
+* Bare Jest compiles neither TypeScript nor React Native, and `jest-expo` is
+* the preset that does both — and resolves the `tsconfig` aliases the copies
+* import through. Any other preset has to map them itself.
+*/
+function jestProblems(setup) {
+	if (setup.jestConfig === null) return [{
+		detail: "there is no Jest config",
+		fix: "Add `\"jest\": { \"preset\": \"jest-expo\" }` to package.json, beside `jest-expo` installed at the app's SDK."
+	}];
+	if (setup.jestConfig.includes("jest-expo")) return [];
+	const unmapped = setup.aliasPrefixes.filter((prefix) => !(setup.jestConfig?.includes("moduleNameMapper") && setup.jestConfig.includes(trimSlash(prefix))));
+	if (unmapped.length === 0) return [];
+	return [{
+		detail: `Jest does not resolve ${unmapped.join(", ")}`,
+		fix: `Use the \`jest-expo\` preset, or map ${unmapped.map((prefix) => `\`${prefix}\``).join(", ")} in \`moduleNameMapper\`.`
+	}];
+}
+/**
+* Vitest reads no `tsconfig` paths, so an alias needs its own entry or the
+* `vite-tsconfig-paths` plugin. And Vite's own tsconfig loader cannot follow
+* `extends: "expo/tsconfig.base"` on SDK 58, which fails every suite before one
+* runs; `esbuild.tsconfigRaw` stops it reading `tsconfig.json` at all.
+*/
+function vitestProblems(setup) {
+	const config = setup.vitestConfig ?? "";
+	const problems = [];
+	const unmapped = config.includes("vite-tsconfig-paths") || config.includes("tsconfigPaths") ? [] : setup.aliasPrefixes.filter((prefix) => !quotes(config, trimSlash(prefix)));
+	if (unmapped.length > 0) problems.push({
+		detail: `Vitest does not resolve ${unmapped.join(", ")}`,
+		fix: `Map ${unmapped.map((prefix) => `\`${prefix}\``).join(", ")} in \`resolve.alias\` in vitest.config.ts.`
+	});
+	if (setup.tsconfigExtends === EXPO_TSCONFIG && !config.includes("tsconfigRaw")) problems.push({
+		detail: `Vite cannot follow tsconfig.json's extends of ${EXPO_TSCONFIG}`,
+		fix: "Set `esbuild: { tsconfigRaw: \"{}\" }` in vitest.config.ts."
+	});
+	return problems;
+}
+function trimSlash(prefix) {
+	return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+}
+/** Whether `text` holds `name`, or `name/`, as a whole quoted string. */
+function quotes(text, name) {
+	return [
+		"\"",
+		"'",
+		"`"
+	].some((quote) => text.includes(`${quote}${name}${quote}`) || text.includes(`${quote}${name}/`));
+}
+const JEST_CONFIG_FILES = [
+	"jest.config.js",
+	"jest.config.ts",
+	"jest.config.cjs",
+	"jest.config.mjs",
+	"jest.config.json"
+];
+const VITEST_CONFIG_FILES = [
+	"vitest.config.ts",
+	"vitest.config.mts",
+	"vitest.config.js",
+	"vitest.config.mjs",
+	"vitest.config.cjs",
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs"
+];
+/** Reads what `checkTestRunner` and `checkJestTransform` need, from the config's package and then the app. */
+async function readTestSetup(config, project) {
+	const roots = [.../* @__PURE__ */ new Set([config.root, config.app.resolved.root])];
+	const manifests = await Promise.all(roots.map((root) => readJson(join(root, "package.json"))));
+	const dependencies = Object.assign({}, project.packageJson?.dependencies, project.packageJson?.devDependencies, ...manifests.flatMap((manifest) => [manifest?.dependencies, manifest?.devDependencies]));
+	return {
+		runner: config.testRunner,
+		scripted: manifests.map((manifest) => manifest ? detectTestRunner(manifest) : null).find(Boolean) ?? null,
+		copiedTests: await countCopiedTests(config.root),
+		dependencies,
+		jestConfig: await readJestConfig(roots, manifests),
+		vitestConfig: await readFirst(roots, VITEST_CONFIG_FILES),
+		tsconfigExtends: await readTsconfigExtends(roots),
+		aliasPrefixes: aliasPrefixes(config)
+	};
+}
+function aliasPrefixes(config) {
+	const prefixes = Object.values(config.aliases).flatMap((alias) => alias?.match(/^[^/]+\//)?.[0] ?? []);
+	return [...new Set(prefixes)];
+}
+async function countCopiedTests(root) {
+	try {
+		const lock = await readLock(root);
+		return Object.values(lock.items).flatMap((item) => Object.keys(item.files)).filter(isTest).length;
+	} catch {
+		return 0;
+	}
+}
+async function readJestConfig(roots, manifests) {
+	for (const [index, root] of roots.entries()) {
+		const file = await readFirst([root], JEST_CONFIG_FILES);
+		if (file !== null) return file;
+		const inline = manifests[index]?.jest;
+		if (inline !== void 0) return JSON.stringify(inline);
+	}
+	return null;
+}
+async function readFirst(roots, names) {
+	for (const root of roots) for (const name of names) {
+		const path = join(root, name);
+		if (existsSync(path)) return readFile(path, "utf-8");
+	}
+	return null;
+}
+async function readTsconfigExtends(roots) {
+	for (const root of roots) {
+		const text = await readFile(join(root, "tsconfig.json"), "utf-8").catch(() => null);
+		if (text === null) continue;
+		try {
+			const { extends: base } = parseJsonc(text);
+			return typeof base === "string" ? base : null;
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/registry/transform.ts
 /**
 * Anchored on the surrounding quote or backtick.
@@ -11238,13 +11536,17 @@ function destination$1(config, namespace, target) {
 		displayPath: toPosix$4(relative(config.root, path))
 	};
 }
-/** A fetched file's text as this project would hold it at `path`: placeholders resolved to its aliases. */
+/**
+* A fetched file's text as this project would hold it at `path`: placeholders
+* resolved to its aliases, and a test written for the runner it tests with.
+*/
 function transformFile(content, path, config) {
-	return transformContent(content, {
+	const transformed = transformContent(content, {
 		fileDirectory: dirname(path),
 		directories: config.directories,
 		aliases: config.aliases
 	});
+	return isTest(path) ? adaptTest(transformed, config.testRunner) : transformed;
 }
 async function writeFiles(files) {
 	for (const file of files) {
@@ -11296,30 +11598,6 @@ function escapePattern(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 //#endregion
-//#region src/registry/classify.ts
-/**
-* Maps a path inside `packages/react-native-ui/src` onto the registry item it
-* belongs to and where it lands in a consumer's project.
-*
-* The rules here are `react-native-ui`'s own conventions, restated — one component
-* per folder with an `index.ts` entry point, flat files under `lib/`, `hooks/`
-* and `icons/`. `packages/react-native-ui/scripts/gen-exports.ts` reads the same
-* shape to build the package's `exports` map, so a component folder that is
-* malformed fails there first.
-*
-* Pure and filesystem-free, so the whole mapping is reachable from `bun test`.
-*/
-const REGISTRY_TYPES = [
-	"registry:ui",
-	"registry:lib",
-	"registry:hook",
-	"registry:style"
-];
-/** A test, or a file that exists only to serve tests — `*.test-helpers.ts`, `*.fixtures.ts`. */
-function isTest(path) {
-	return /\.(test|test-helpers|fixtures)\.tsx?$/.test(path);
-}
-//#endregion
 //#region src/registry/schema.ts
 /**
 * The shape of the JSON the builder emits and the `add` command consumes.
@@ -11446,13 +11724,14 @@ const registryIndexSchema = object$1({
 * then treats a test like any other file, which is the point: a copied test is
 * the consumer's from then on, recorded and updated exactly as the source is.
 */
-function withTests(item) {
+function withTests(item, runner = "bun") {
 	const tests = "tests" in item ? item.tests : [];
+	const testDependencies = item.testDependencies.flatMap((name) => name === "@types/bun" ? testRunnerPackages(runner) : [name]);
 	return {
 		...item,
 		..."files" in item && "tests" in item ? { files: [...item.files, ...tests] } : {},
 		registryDependencies: union(item.registryDependencies, item.testRegistryDependencies),
-		devDependencies: union(item.devDependencies, item.testDependencies)
+		devDependencies: union(item.devDependencies, testDependencies)
 	};
 }
 function union(a, b) {
@@ -11564,13 +11843,13 @@ const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/delacournz/delac
 * Replaced at build time with the git tag being published (see `tsdown.config.ts`).
 * `main` in a working tree, where there is no tag yet.
 */
-const DEFAULT_REGISTRY_REF = "abcaf1b8a49718368bc5726b1801ec58e75a2477";
+const DEFAULT_REGISTRY_REF = "713984b74d21a6bb6b0e1f719a947cce7a2d847e";
 const RAW_GITHUB = "https://raw.githubusercontent.com";
 const GITHUB_SHORTHAND = /^github:([^/#]+)\/([^/#]+)(?:#(.+))?$/;
 /** `https://raw.githubusercontent.com/owner/repo` and nothing more. */
 const BARE_RAW_REPO = new RegExp(`^${RAW_GITHUB}/([^/]+)/([^/]+)$`);
 function resolveRegistrySource(options) {
-	const ref = options.ref || "abcaf1b8a49718368bc5726b1801ec58e75a2477";
+	const ref = options.ref || "713984b74d21a6bb6b0e1f719a947cce7a2d847e";
 	const url = options.url?.trim();
 	if (!url) return remote(`${DEFAULT_REGISTRY_URL}/${ref}`);
 	const shorthand = GITHUB_SHORTHAND.exec(url);
@@ -11984,477 +12263,90 @@ const style = {
 	path: (value) => import_picocolors.default.dim(value)
 };
 //#endregion
-//#region src/project/css.ts
+//#region ../design-system/src/styles.ts
 /**
-* Wires the copied styles into the app's Tailwind entry.
-*
-* Two things have to happen and only one of them is obvious. The `@import`
-* pulls in the tokens and the theme. The `@source` lines are what make the
-* classes inside the copied components survive a production build: Tailwind
-* scans source text, and a class it never saw is a class it never compiled.
+* The three control heights, the type paired with each, and the icon scale.
 *
-* The paths are computed from where the files actually landed, which resolves
-* the symlink trap on its own. In a monorepo the components live in a package
-* that Bun links into `node_modules`, and Tailwind's scanner does not follow
-* symlinks — a `@source` pointing at the linked copy silently contributes
-* nothing, and the components render unstyled in release and fine in dev. The
-* comment in `apps/playground/src/styles/global.css` is this bug, already paid
-* for once.
+* A style names one density and everything steps from it, rather than listing
+* two dozen numbers per style and inviting them to drift out of proportion.
+* `heights` are the button and input scales, which the library keeps separate
+* but which no style has yet had a reason to disagree on.
 */
-const START = "/* delacour:start — managed by `delacour init`, edit outside this block */";
-const END = "/* delacour:end */";
+function geometry({ radius, heights, text, icons, navbar, gutter, buttonRadius }) {
+	return {
+		radius,
+		"spacing-button-sm": heights[0],
+		"spacing-button-md": heights[1],
+		"spacing-button-lg": heights[2],
+		"text-button-sm": text[0],
+		"text-button-md": text[1],
+		"text-button-lg": text[2],
+		"radius-button-sm": Math.min(buttonRadius[0], heights[0] / 2),
+		"radius-button-md": Math.min(buttonRadius[1], heights[1] / 2),
+		"radius-button-lg": Math.min(buttonRadius[2], heights[2] / 2),
+		"spacing-input-sm": heights[0],
+		"spacing-input-md": heights[1],
+		"spacing-input-lg": heights[2],
+		"text-input-sm": text[0],
+		"text-input-md": text[1],
+		"text-input-lg": text[2],
+		"spacing-icon-xs": icons[0],
+		"spacing-icon-sm": icons[1],
+		"spacing-icon-md": icons[2],
+		"spacing-icon-lg": icons[3],
+		"spacing-icon-xl": icons[4],
+		"spacing-icon-2xl": icons[5],
+		"spacing-navbar-row": navbar,
+		"spacing-screen-gutter": gutter,
+		"spacing-chart-sm": chartHeight(LIBRARY_CHART[0], heights[1]),
+		"spacing-chart-md": chartHeight(LIBRARY_CHART[1], heights[1]),
+		"spacing-chart-lg": chartHeight(LIBRARY_CHART[2], heights[1]),
+		"spacing-fab-sm": LIBRARY_FAB[0],
+		"spacing-fab-md": LIBRARY_FAB[1],
+		"spacing-fab-lg": LIBRARY_FAB[2]
+	};
+}
+const LIBRARY_HEIGHTS = [
+	36,
+	44,
+	52
+];
+const LIBRARY_TEXT = [
+	14,
+	16,
+	18
+];
+const LIBRARY_ICONS = [
+	14,
+	16,
+	18,
+	20,
+	24,
+	32
+];
+const CAPSULE = [
+	18,
+	22,
+	26
+];
+const LIBRARY_CHART = [
+	160,
+	220,
+	280
+];
 /**
-* The managed block: one import for the theme, one source glob per directory
-* holding copied code.
+* A floating action button's footprint, the same under every style. It floats
+* over content rather than sitting in a row of controls, so a denser style's
+* shorter buttons are no reason to shrink the one target above the list — and
+* 44 is the floor a touch target cannot go under.
 */
-function buildStylesBlock(context) {
-	const from = dirname(context.cssPath);
-	const lines = [
-		START,
-		`@import "${toSpecifier$1(from, `${context.directories.styles}/index.css`)}";`,
-		""
-	];
-	const scanned = new Set(NAMESPACES.filter((namespace) => namespace !== "styles").map((namespace) => context.directories[namespace]));
-	for (const directory of [...scanned].sort()) {
-		if ([...scanned].some((other) => other !== directory && isInside(directory, other))) continue;
-		lines.push(`@source "${toSpecifier$1(from, directory)}";`);
-	}
-	lines.push(END);
-	return lines.join("\n");
-}
+const LIBRARY_FAB = [
+	44,
+	56,
+	64
+];
 /**
-* Writes the block into an existing entry, or creates one.
-*
-* Bounded by markers so a second `init` replaces the block rather than
-* appending a second copy, and so everything a developer adds around it is left
-* alone.
-*/
-function patchGlobalCss(existing, block) {
-	if (existing === null) return {
-		content: `${DEFAULT_ENTRY}\n${block}\n`,
-		changed: true
-	};
-	const start = existing.indexOf(START);
-	const end = existing.indexOf(END);
-	if (start !== -1 && end > start) {
-		const content = `${existing.slice(0, start)}${block}${existing.slice(end + 18)}`;
-		return {
-			content,
-			changed: content !== existing
-		};
-	}
-	return {
-		content: `${existing}${existing.endsWith("\n") ? "" : "\n"}\n${block}\n`,
-		changed: true
-	};
-}
-const DEFAULT_ENTRY = `@import "tailwindcss";
-@import "uniwind";
-
-@source "../**/*.{ts,tsx}";
-`;
-/**
-* The directories a Tailwind entry actually scans.
-*
-* Read back rather than assumed, because this is the check that matters: a
-* `@source` that does not cover where the components landed produces a build
-* with no error and no styles. Only directory sources are returned — a glob
-* like `../**\/*.{ts,tsx}` is reduced to the directory it starts from, which is
-* what decides coverage.
-*/
-function parseSources(css, cssPath) {
-	const from = dirname(cssPath);
-	const sources = [];
-	for (const match of css.matchAll(/@source\s+(?:not\s+)?["']([^"']+)["']/g)) {
-		const value = match[1];
-		if (value.startsWith("inline(")) continue;
-		const wildcard = value.search(/[*?[]/);
-		const directory = wildcard === -1 ? value : value.slice(0, wildcard);
-		sources.push(resolve(from, directory));
-	}
-	return sources;
-}
-/** Whether any source directory contains `directory`. */
-function isCovered(directory, sources) {
-	return sources.some((source) => {
-		const suffix = relative(source, directory);
-		return suffix === "" || !suffix.startsWith("..");
-	});
-}
-/** A path Tailwind can resolve from the entry file, always POSIX and always relative. */
-function toSpecifier$1(from, target) {
-	const path = toPosix$3(relative(from, target));
-	return path.startsWith(".") ? path : `./${path}`;
-}
-function isInside(directory, parent) {
-	const suffix = relative(parent, directory);
-	return suffix !== "" && !suffix.startsWith("..");
-}
-function toPosix$3(path) {
-	return sep === "/" ? path : path.split(sep).join("/");
-}
-//#endregion
-//#region src/project/css-entry.ts
-/**
-* Finds the Tailwind entry an app already has.
-*
-* Creating a second one is the failure this exists to prevent. Metro compiles
-* the file its `cssEntryFile` names and no other; the app imports whichever
-* file its root layout imports. Write a new entry beside an existing one and
-* those become two different files — Tailwind compiles the one with the
-* `@source` globs, the app loads the one without them, and every component
-* renders unstyled with nothing logged.
-*
-* The Metro config wins when it names one, because that is what actually
-* compiles — see `readUniwindPaths`. This is the fallback for a project that
-* has an entry but has not wired Metro to it yet, which is every app that
-* installed Uniwind and stopped there.
-*
-* Shallowest first: an app that ran an older version of this CLI has both
-* `src/global.css` and `src/styles/global.css`, and the one it imports is the
-* one it had first.
-*/
-const CANDIDATES$1 = [
-	"global.css",
-	"src/global.css",
-	"app/global.css",
-	"src/app/global.css",
-	"styles/global.css",
-	"src/styles/global.css",
-	"src/styles/index.css"
-];
-/** `@import "tailwindcss"`, however it is quoted and whatever follows it. */
-const TAILWIND_IMPORT = /@import\s+["']tailwindcss["']/;
-function findTailwindEntry(appRoot) {
-	for (const candidate of CANDIDATES$1) {
-		const path = join(appRoot, candidate);
-		if (!existsSync(path)) continue;
-		try {
-			if (TAILWIND_IMPORT.test(readFileSync(path, "utf-8"))) return path;
-		} catch {}
-	}
-	return null;
-}
-//#endregion
-//#region src/project/metro.ts
-/**
-* Wraps the app's Metro config with Uniwind's.
-*
-* `withUniwindConfig` has to stay the outermost wrapper — it installs the
-* transformer that compiles `className` into styles, and a wrapper applied
-* after it can replace the `transformer` key and leave every component
-* unstyled with nothing logged. So the patch rewrites the export itself rather
-* than inserting a line somewhere in the middle.
-*
-* When the export is not in a shape this can safely rewrite, it says so and
-* prints what to write. Guessing at an unfamiliar config file earns nothing —
-* the failure it causes is a Metro error at bundle time in someone else's app.
-*/
-/** Modules that must resolve to exactly one copy across a workspace. */
-const PINNED_MODULES = [
-	"@shopify/react-native-skia",
-	"react",
-	"react-native",
-	"react-native-gesture-handler",
-	"react-native-keyboard-controller",
-	"react-native-reanimated",
-	"react-native-safe-area-context",
-	"react-native-svg",
-	"react-native-teleport",
-	"react-native-worklets"
-];
-const REQUIRE = "const { withUniwindConfig } = require(\"uniwind/metro\");";
-const IMPORT = "import { withUniwindConfig } from \"uniwind/metro\";";
-/** `module.exports = config;` or `export default config;`, with nothing after it. */
-const COMMONJS_EXPORT = /module\.exports\s*=\s*([\s\S]+?);?\s*$/;
-const ESM_EXPORT = /export default\s+([\s\S]+?);?\s*$/;
-const CSS_ENTRY = /cssEntryFile\s*:\s*["'`]([^"'`]+)["'`]/;
-const DTS_FILE = /dtsFile\s*:\s*["'`]([^"'`]+)["'`]/;
-/**
-* Reads the paths a wrapped Metro config already names.
-*
-* A project that arrives with Uniwind set up — Expo's `with-router-uniwind`
-* example is the common one — has chosen its own CSS entry, and Metro compiles
-* **that file and no other**. Writing the `@source` block into the path this
-* CLI would have picked leaves Tailwind scanning a file with no globs in it, so
-* every class the components use is dropped and every one of them renders
-* unstyled. Nothing errors; the app just looks wrong.
-*
-* So the wired config wins. Returns nothing when the config is not wired, in
-* which case `init` is about to wrap it with paths of its own.
-*/
-function readUniwindPaths(existing) {
-	if (!existing?.includes("withUniwindConfig")) return {};
-	return {
-		css: CSS_ENTRY.exec(existing)?.[1],
-		types: DTS_FILE.exec(existing)?.[1]
-	};
-}
-function patchMetroConfig(existing, options) {
-	const wrapper = optionsLiteral(options);
-	const monorepo = options.workspaceRoot && options.workspaceRoot !== options.metroConfigPath ? monorepoResolverBlock(dirname(options.metroConfigPath), options.workspaceRoot) : "";
-	if (existing === null) return {
-		status: "created",
-		content: template(wrapper, monorepo)
-	};
-	if (existing.includes("withUniwindConfig")) return { status: "already-wired" };
-	const isEsm = /^\s*(import|export default)/m.test(existing);
-	const match = (isEsm ? ESM_EXPORT : COMMONJS_EXPORT).exec(existing);
-	if (!match?.[1]) return {
-		status: "manual",
-		snippet: manualSnippet(wrapper, isEsm)
-	};
-	const keyword = isEsm ? "export default" : "module.exports =";
-	const head = existing.slice(0, match.index);
-	const wrapped = `${keyword} withUniwindConfig(${match[1].trim()}, ${wrapper});\n`;
-	const body = monorepo ? `${head}${monorepo}\n` : head;
-	return {
-		status: "patched",
-		content: `${isEsm ? IMPORT : REQUIRE}\n${body}${wrapped}`
-	};
-}
-function optionsLiteral(options) {
-	const from = dirname(options.metroConfigPath);
-	return `{\n\tcssEntryFile: "${toSpecifier(from, options.cssPath)}",\n\tdtsFile: "${toSpecifier(from, options.typesPath)}",\n}`;
-}
-/**
-* The resolver settings an app needs to reach a package outside its own tree.
-*
-* Metro resolves by walking `node_modules` from the app downwards, so without
-* `watchFolders` and `nodeModulesPaths` it simply cannot see a sibling package —
-* the import fails at bundle time with a missing module, pointing at the app
-* rather than at the workspace.
-*
-* `extraNodeModules` is the other half, and it is about runtime rather than
-* resolution: a package manager can materialise a second copy of a native module
-* under the app, and two registrations of one native module break. This is the
-* block `apps/playground/metro.config.js` in this repository carries for exactly
-* this reason.
-*/
-function monorepoResolverBlock(appRoot, workspaceRoot) {
-	const pins = PINNED_MODULES.map((name) => `\t${JSON.stringify(name)}: path.resolve(workspaceRoot, "node_modules/${name}"),`).join("\n");
-	return `const path = require("node:path");
-
-const workspaceRoot = path.resolve(__dirname, "${toSpecifier(appRoot, workspaceRoot)}");
-
-// The components live in a package outside this app, so Metro has to watch and
-// resolve beyond the app's own directory.
-config.watchFolders = [workspaceRoot];
-config.resolver.nodeModulesPaths = [
-\tpath.resolve(__dirname, "node_modules"),
-\tpath.resolve(workspaceRoot, "node_modules"),
-];
-config.resolver.disableHierarchicalLookup = true;
-
-// One copy of each native module for the whole bundle: two registrations of a
-// native module break at runtime.
-config.resolver.extraNodeModules = {
-${pins}
-};
-`;
-}
-function template(wrapper, monorepo) {
-	return `const { getDefaultConfig } = require("expo/metro-config");
-${REQUIRE}
-
-const config = getDefaultConfig(__dirname);
-${monorepo ? `\n${monorepo}` : ""}
-// withUniwindConfig must stay the outermost wrapper.
-module.exports = withUniwindConfig(config, ${wrapper});
-`;
-}
-function manualSnippet(wrapper, isEsm) {
-	return `${isEsm ? IMPORT : REQUIRE}\n\n// Keep this the outermost wrapper.\n${isEsm ? "export default" : "module.exports ="} withUniwindConfig(config, ${wrapper});`;
-}
-function toSpecifier(from, target) {
-	const path = toPosix$2(relative(from, target));
-	return path.startsWith(".") ? path : `./${path}`;
-}
-function toPosix$2(path) {
-	return sep === "/" ? path : path.split(sep).join("/");
-}
-//#endregion
-//#region src/project/root-layout.ts
-/**
-* Router layouts first: an app holding both is an Expo Router app whose
-* `App.tsx` is left over, and the layout is the file that actually renders.
-*/
-const CANDIDATES = [
-	{
-		path: "src/app/_layout.tsx",
-		router: true
-	},
-	{
-		path: "app/_layout.tsx",
-		router: true
-	},
-	{
-		path: "src/app/_layout.jsx",
-		router: true
-	},
-	{
-		path: "app/_layout.jsx",
-		router: true
-	},
-	{
-		path: "App.tsx",
-		router: false
-	},
-	{
-		path: "src/App.tsx",
-		router: false
-	},
-	{
-		path: "App.jsx",
-		router: false
-	},
-	{
-		path: "index.tsx",
-		router: false
-	}
-];
-function findRootLayout(appRoot) {
-	return CANDIDATES.find((candidate) => existsSync(join(appRoot, candidate.path))) ?? null;
-}
-/**
-* The root layout, whole, ready to paste.
-*
-* The CSS import is the first line because that is the rule it exists to
-* teach — anywhere else and every component renders unstyled with nothing
-* logged.
-*
-* `<Slot />` is Expo Router's minimal root. A layout already rendering a
-* `<Stack>` keeps it; the provider goes around whatever is there, which is
-* what the line printed beside this says.
-*/
-function renderRootLayout(layout, specifiers) {
-	const { css, provider } = specifiers;
-	if (!layout.router) return [
-		`import "${css}";`,
-		`import { DelacourProvider } from "${provider}";`,
-		"",
-		"export default function App() {",
-		"	return (",
-		"		<DelacourProvider>",
-		"			<YourApp />",
-		"		</DelacourProvider>",
-		"	);",
-		"}"
-	].join("\n");
-	return [
-		`import "${css}";`,
-		`import { DelacourProvider } from "${provider}";`,
-		"import { Slot } from \"expo-router\";",
-		"",
-		"export default function RootLayout() {",
-		"	return (",
-		"		<DelacourProvider>",
-		"			<Slot />",
-		"		</DelacourProvider>",
-		"	);",
-		"}"
-	].join("\n");
-}
-//#endregion
-//#region src/project/uniwind-env.ts
-/**
-* The one line that makes `className` a real prop in TypeScript.
-*
-* Uniwind augments React Native's types through a global `/// <reference>`, and
-* a declaration file is only loaded if it is part of the program — either
-* matched by `tsconfig`'s `include` or reachable by import. This file is neither
-* importable nor, in a shared package, inside the app's `include`, which is why
-* the app needs a copy of its own.
-*
-* Kept here rather than inlined so `init` and `doctor` agree on the contents.
-*/
-const UNIWIND_ENV_FILENAME = "uniwind-env.d.ts";
-const UNIWIND_ENV_REFERENCE = "/// <reference types=\"uniwind/types\" />";
-//#endregion
-//#region ../design-system/src/styles.ts
-/**
-* The three control heights, the type paired with each, and the icon scale.
-*
-* A style names one density and everything steps from it, rather than listing
-* two dozen numbers per style and inviting them to drift out of proportion.
-* `heights` are the button and input scales, which the library keeps separate
-* but which no style has yet had a reason to disagree on.
-*/
-function geometry({ radius, heights, text, icons, navbar, gutter, buttonRadius }) {
-	return {
-		radius,
-		"spacing-button-sm": heights[0],
-		"spacing-button-md": heights[1],
-		"spacing-button-lg": heights[2],
-		"text-button-sm": text[0],
-		"text-button-md": text[1],
-		"text-button-lg": text[2],
-		"radius-button-sm": Math.min(buttonRadius[0], heights[0] / 2),
-		"radius-button-md": Math.min(buttonRadius[1], heights[1] / 2),
-		"radius-button-lg": Math.min(buttonRadius[2], heights[2] / 2),
-		"spacing-input-sm": heights[0],
-		"spacing-input-md": heights[1],
-		"spacing-input-lg": heights[2],
-		"text-input-sm": text[0],
-		"text-input-md": text[1],
-		"text-input-lg": text[2],
-		"spacing-icon-xs": icons[0],
-		"spacing-icon-sm": icons[1],
-		"spacing-icon-md": icons[2],
-		"spacing-icon-lg": icons[3],
-		"spacing-icon-xl": icons[4],
-		"spacing-icon-2xl": icons[5],
-		"spacing-navbar-row": navbar,
-		"spacing-screen-gutter": gutter,
-		"spacing-chart-sm": chartHeight(LIBRARY_CHART[0], heights[1]),
-		"spacing-chart-md": chartHeight(LIBRARY_CHART[1], heights[1]),
-		"spacing-chart-lg": chartHeight(LIBRARY_CHART[2], heights[1]),
-		"spacing-fab-sm": LIBRARY_FAB[0],
-		"spacing-fab-md": LIBRARY_FAB[1],
-		"spacing-fab-lg": LIBRARY_FAB[2]
-	};
-}
-const LIBRARY_HEIGHTS = [
-	36,
-	44,
-	52
-];
-const LIBRARY_TEXT = [
-	14,
-	16,
-	18
-];
-const LIBRARY_ICONS = [
-	14,
-	16,
-	18,
-	20,
-	24,
-	32
-];
-const CAPSULE = [
-	18,
-	22,
-	26
-];
-const LIBRARY_CHART = [
-	160,
-	220,
-	280
-];
-/**
-* A floating action button's footprint, the same under every style. It floats
-* over content rather than sitting in a row of controls, so a denser style's
-* shorter buttons are no reason to shrink the one target above the list — and
-* 44 is the floor a touch target cannot go under.
-*/
-const LIBRARY_FAB = [
-	44,
-	56,
-	64
-];
-/**
-* A chart's height, scaled to a style's control density.
+* A chart's height, scaled to a style's control density.
 *
 * A plot is a region rather than a control, so none of the axes a style
 * actually sets — a corner, an icon, a button's height — describes it directly.
@@ -13205,6 +13097,213 @@ function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 //#endregion
+//#region src/project/css.ts
+/**
+* Wires the copied styles into the app's Tailwind entry.
+*
+* Two things have to happen and only one of them is obvious. The `@import`
+* pulls in the tokens and the theme. The `@source` lines are what make the
+* classes inside the copied components survive a production build: Tailwind
+* scans source text, and a class it never saw is a class it never compiled.
+*
+* The paths are computed from where the files actually landed, which resolves
+* the symlink trap on its own. In a monorepo the components live in a package
+* that Bun links into `node_modules`, and Tailwind's scanner does not follow
+* symlinks — a `@source` pointing at the linked copy silently contributes
+* nothing, and the components render unstyled in release and fine in dev. The
+* comment in `apps/playground/src/styles/global.css` is this bug, already paid
+* for once.
+*/
+const START = "/* delacour:start — managed by `delacour init`, edit outside this block */";
+const END = "/* delacour:end */";
+/**
+* The managed block: one import for the theme, one source glob per directory
+* holding copied code.
+*/
+function buildStylesBlock(context) {
+	const from = dirname(context.cssPath);
+	const lines = [
+		START,
+		`@import "${toSpecifier$1(from, `${context.directories.styles}/index.css`)}";`,
+		""
+	];
+	const scanned = new Set(NAMESPACES.filter((namespace) => namespace !== "styles").map((namespace) => context.directories[namespace]));
+	for (const directory of [...scanned].sort()) {
+		if ([...scanned].some((other) => other !== directory && isInside(directory, other))) continue;
+		lines.push(`@source "${toSpecifier$1(from, directory)}";`);
+	}
+	lines.push(END);
+	return lines.join("\n");
+}
+/**
+* Writes the block into an existing entry, or creates one.
+*
+* Bounded by markers so a second `init` replaces the block rather than
+* appending a second copy, and so everything a developer adds around it is left
+* alone.
+*/
+function patchGlobalCss(existing, block) {
+	if (existing === null) return {
+		content: `${DEFAULT_ENTRY}\n${block}\n`,
+		changed: true
+	};
+	const start = existing.indexOf(START);
+	const end = existing.indexOf(END);
+	if (start !== -1 && end > start) {
+		const content = `${existing.slice(0, start)}${block}${existing.slice(end + 18)}`;
+		return {
+			content,
+			changed: content !== existing
+		};
+	}
+	return {
+		content: `${existing}${existing.endsWith("\n") ? "" : "\n"}\n${block}\n`,
+		changed: true
+	};
+}
+const DEFAULT_ENTRY = `@import "tailwindcss";
+@import "uniwind";
+
+@source "../**/*.{ts,tsx}";
+`;
+/**
+* The directories a Tailwind entry actually scans.
+*
+* Read back rather than assumed, because this is the check that matters: a
+* `@source` that does not cover where the components landed produces a build
+* with no error and no styles. Only directory sources are returned — a glob
+* like `../**\/*.{ts,tsx}` is reduced to the directory it starts from, which is
+* what decides coverage.
+*/
+function parseSources(css, cssPath) {
+	const from = dirname(cssPath);
+	const sources = [];
+	for (const match of css.matchAll(/@source\s+(?:not\s+)?["']([^"']+)["']/g)) {
+		const value = match[1];
+		if (value.startsWith("inline(")) continue;
+		const wildcard = value.search(/[*?[]/);
+		const directory = wildcard === -1 ? value : value.slice(0, wildcard);
+		sources.push(resolve(from, directory));
+	}
+	return sources;
+}
+/** Whether any source directory contains `directory`. */
+function isCovered(directory, sources) {
+	return sources.some((source) => {
+		const suffix = relative(source, directory);
+		return suffix === "" || !suffix.startsWith("..");
+	});
+}
+/** A path Tailwind can resolve from the entry file, always POSIX and always relative. */
+function toSpecifier$1(from, target) {
+	const path = toPosix$3(relative(from, target));
+	return path.startsWith(".") ? path : `./${path}`;
+}
+function isInside(directory, parent) {
+	const suffix = relative(parent, directory);
+	return suffix !== "" && !suffix.startsWith("..");
+}
+function toPosix$3(path) {
+	return sep === "/" ? path : path.split(sep).join("/");
+}
+//#endregion
+//#region src/project/root-layout.ts
+/**
+* Router layouts first: an app holding both is an Expo Router app whose
+* `App.tsx` is left over, and the layout is the file that actually renders.
+*/
+const CANDIDATES$1 = [
+	{
+		path: "src/app/_layout.tsx",
+		router: true
+	},
+	{
+		path: "app/_layout.tsx",
+		router: true
+	},
+	{
+		path: "src/app/_layout.jsx",
+		router: true
+	},
+	{
+		path: "app/_layout.jsx",
+		router: true
+	},
+	{
+		path: "App.tsx",
+		router: false
+	},
+	{
+		path: "src/App.tsx",
+		router: false
+	},
+	{
+		path: "App.jsx",
+		router: false
+	},
+	{
+		path: "index.tsx",
+		router: false
+	}
+];
+function findRootLayout(appRoot) {
+	return CANDIDATES$1.find((candidate) => existsSync(join(appRoot, candidate.path))) ?? null;
+}
+/**
+* The root layout, whole, ready to paste.
+*
+* The CSS import is the first line because that is the rule it exists to
+* teach — anywhere else and every component renders unstyled with nothing
+* logged.
+*
+* `<Slot />` is Expo Router's minimal root. A layout already rendering a
+* `<Stack>` keeps it; the provider goes around whatever is there, which is
+* what the line printed beside this says.
+*/
+function renderRootLayout(layout, specifiers) {
+	const { css, provider } = specifiers;
+	if (!layout.router) return [
+		`import "${css}";`,
+		`import { DelacourProvider } from "${provider}";`,
+		"",
+		"export default function App() {",
+		"	return (",
+		"		<DelacourProvider>",
+		"			<YourApp />",
+		"		</DelacourProvider>",
+		"	);",
+		"}"
+	].join("\n");
+	return [
+		`import "${css}";`,
+		`import { DelacourProvider } from "${provider}";`,
+		"import { Slot } from \"expo-router\";",
+		"",
+		"export default function RootLayout() {",
+		"	return (",
+		"		<DelacourProvider>",
+		"			<Slot />",
+		"		</DelacourProvider>",
+		"	);",
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/project/uniwind-env.ts
+/**
+* The one line that makes `className` a real prop in TypeScript.
+*
+* Uniwind augments React Native's types through a global `/// <reference>`, and
+* a declaration file is only loaded if it is part of the program — either
+* matched by `tsconfig`'s `include` or reachable by import. This file is neither
+* importable nor, in a shared package, inside the app's `include`, which is why
+* the app needs a copy of its own.
+*
+* Kept here rather than inlined so `init` and `doctor` agree on the contents.
+*/
+const UNIWIND_ENV_FILENAME = "uniwind-env.d.ts";
+const UNIWIND_ENV_REFERENCE = "/// <reference types=\"uniwind/types\" />";
+//#endregion
 //#region src/commands/doctor.ts
 async function doctor(options) {
 	const output = createOutput(options);
@@ -13233,10 +13332,65 @@ async function runChecks(options) {
 		await checkCssEntryImported(config),
 		await checkGestureHandlerRoot(config),
 		await checkDuplicateNativeModules(project),
+		...testChecks(await readTestSetup(config, project)),
 		checkLock(existsSync(lockPath(config.root)), await hasEntries(config.directories.ui))
 	];
 }
 /**
+* What `transformIgnorePatterns` has to let through for each engine. Both
+* publish TypeScript source; the charts engine also imports d3, whose packages
+* ship ES modules only.
+*/
+const ENGINE_TRANSFORMS = {
+	"@delacour/react-native-bottom-sheet": ["@delacour/.*"],
+	"@delacour/react-native-charts": [
+		"@delacour/.*",
+		"d3-.*",
+		"internmap"
+	]
+};
+/** Whether copied tests can run: the runner's setup, then what Jest has to transform. */
+function testChecks(setup) {
+	return [checkTestRunner(setup), checkJestTransform(setup)];
+}
+/**
+* A Jest project that imports an engine has to transform it.
+*
+* Jest skips `node_modules` by default and `jest-expo`'s list does not name
+* these, so every suite reaching `chart` or `bottom-sheet` dies with "Must use
+* import to load ES Module" and a path inside `node_modules`. Nothing in the app
+* is wrong, so it is a warning: only the tests are broken. The config is read as
+* text, so a pattern built in code may be missed — the fix names exactly what
+* the pattern has to contain.
+*/
+function checkJestTransform(setup) {
+	const name = "Jest transforms";
+	if (setup.runner !== "jest") return {
+		name,
+		status: "pass",
+		detail: `tests run on ${setup.runner}, not Jest`
+	};
+	const engines = Object.keys(ENGINE_TRANSFORMS).filter((engine) => engine in setup.dependencies);
+	if (engines.length === 0) return {
+		name,
+		status: "pass",
+		detail: "no engine package to transform"
+	};
+	const patterns = setup.jestConfig?.includes("transformIgnorePatterns") ? setup.jestConfig : "";
+	const missing = [...new Set(engines.flatMap((engine) => ENGINE_TRANSFORMS[engine] ?? []))].filter((pattern) => !patterns.includes(pattern.replace(".*", "")));
+	if (missing.length === 0) return {
+		name,
+		status: "pass",
+		detail: `${engines.join(", ")} transformed`
+	};
+	return {
+		name,
+		status: "warn",
+		detail: `${engines.join(", ")} ship${engines.length === 1 ? "s" : ""} untranspiled, and transformIgnorePatterns does not let ${missing.join(", ")} through`,
+		fix: `Add ${missing.map((pattern) => `\`${pattern}\``).join(", ")} to the packages transformIgnorePatterns lets through, beside jest-expo's own.`
+	};
+}
+/**
 * Components copied in before the lock existed have nothing to merge from.
 *
 * A warning, never a failure: the components work exactly as they did. What is
@@ -13696,10 +13850,10 @@ function cssImportSpecifier(config) {
 }
 /** A relative path as an import specifier: `../styles/global.css`, `./global.css`. */
 function relativeSpecifier(from, target) {
-	const path = toPosix$1(relative(from, target));
+	const path = toPosix$2(relative(from, target));
 	return path.startsWith(".") ? path : `./${path}`;
 }
-function toPosix$1(path) {
+function toPosix$2(path) {
 	return sep === "/" ? path : path.split(sep).join("/");
 }
 /**
@@ -13865,6 +14019,186 @@ async function read$1(path) {
 	}
 }
 //#endregion
+//#region src/project/css-entry.ts
+/**
+* Finds the Tailwind entry an app already has.
+*
+* Creating a second one is the failure this exists to prevent. Metro compiles
+* the file its `cssEntryFile` names and no other; the app imports whichever
+* file its root layout imports. Write a new entry beside an existing one and
+* those become two different files — Tailwind compiles the one with the
+* `@source` globs, the app loads the one without them, and every component
+* renders unstyled with nothing logged.
+*
+* The Metro config wins when it names one, because that is what actually
+* compiles — see `readUniwindPaths`. This is the fallback for a project that
+* has an entry but has not wired Metro to it yet, which is every app that
+* installed Uniwind and stopped there.
+*
+* Shallowest first: an app that ran an older version of this CLI has both
+* `src/global.css` and `src/styles/global.css`, and the one it imports is the
+* one it had first.
+*/
+const CANDIDATES = [
+	"global.css",
+	"src/global.css",
+	"app/global.css",
+	"src/app/global.css",
+	"styles/global.css",
+	"src/styles/global.css",
+	"src/styles/index.css"
+];
+/** `@import "tailwindcss"`, however it is quoted and whatever follows it. */
+const TAILWIND_IMPORT = /@import\s+["']tailwindcss["']/;
+function findTailwindEntry(appRoot) {
+	for (const candidate of CANDIDATES) {
+		const path = join(appRoot, candidate);
+		if (!existsSync(path)) continue;
+		try {
+			if (TAILWIND_IMPORT.test(readFileSync(path, "utf-8"))) return path;
+		} catch {}
+	}
+	return null;
+}
+//#endregion
+//#region src/project/metro.ts
+/**
+* Wraps the app's Metro config with Uniwind's.
+*
+* `withUniwindConfig` has to stay the outermost wrapper — it installs the
+* transformer that compiles `className` into styles, and a wrapper applied
+* after it can replace the `transformer` key and leave every component
+* unstyled with nothing logged. So the patch rewrites the export itself rather
+* than inserting a line somewhere in the middle.
+*
+* When the export is not in a shape this can safely rewrite, it says so and
+* prints what to write. Guessing at an unfamiliar config file earns nothing —
+* the failure it causes is a Metro error at bundle time in someone else's app.
+*/
+/** Modules that must resolve to exactly one copy across a workspace. */
+const PINNED_MODULES = [
+	"@shopify/react-native-skia",
+	"react",
+	"react-native",
+	"react-native-gesture-handler",
+	"react-native-keyboard-controller",
+	"react-native-reanimated",
+	"react-native-safe-area-context",
+	"react-native-svg",
+	"react-native-teleport",
+	"react-native-worklets"
+];
+const REQUIRE = "const { withUniwindConfig } = require(\"uniwind/metro\");";
+const IMPORT = "import { withUniwindConfig } from \"uniwind/metro\";";
+/** `module.exports = config;` or `export default config;`, with nothing after it. */
+const COMMONJS_EXPORT = /module\.exports\s*=\s*([\s\S]+?);?\s*$/;
+const ESM_EXPORT = /export default\s+([\s\S]+?);?\s*$/;
+const CSS_ENTRY = /cssEntryFile\s*:\s*["'`]([^"'`]+)["'`]/;
+const DTS_FILE = /dtsFile\s*:\s*["'`]([^"'`]+)["'`]/;
+/**
+* Reads the paths a wrapped Metro config already names.
+*
+* A project that arrives with Uniwind set up — Expo's `with-router-uniwind`
+* example is the common one — has chosen its own CSS entry, and Metro compiles
+* **that file and no other**. Writing the `@source` block into the path this
+* CLI would have picked leaves Tailwind scanning a file with no globs in it, so
+* every class the components use is dropped and every one of them renders
+* unstyled. Nothing errors; the app just looks wrong.
+*
+* So the wired config wins. Returns nothing when the config is not wired, in
+* which case `init` is about to wrap it with paths of its own.
+*/
+function readUniwindPaths(existing) {
+	if (!existing?.includes("withUniwindConfig")) return {};
+	return {
+		css: CSS_ENTRY.exec(existing)?.[1],
+		types: DTS_FILE.exec(existing)?.[1]
+	};
+}
+function patchMetroConfig(existing, options) {
+	const wrapper = optionsLiteral(options);
+	const monorepo = options.workspaceRoot && options.workspaceRoot !== options.metroConfigPath ? monorepoResolverBlock(dirname(options.metroConfigPath), options.workspaceRoot) : "";
+	if (existing === null) return {
+		status: "created",
+		content: template(wrapper, monorepo)
+	};
+	if (existing.includes("withUniwindConfig")) return { status: "already-wired" };
+	const isEsm = /^\s*(import|export default)/m.test(existing);
+	const match = (isEsm ? ESM_EXPORT : COMMONJS_EXPORT).exec(existing);
+	if (!match?.[1]) return {
+		status: "manual",
+		snippet: manualSnippet(wrapper, isEsm)
+	};
+	const keyword = isEsm ? "export default" : "module.exports =";
+	const head = existing.slice(0, match.index);
+	const wrapped = `${keyword} withUniwindConfig(${match[1].trim()}, ${wrapper});\n`;
+	const body = monorepo ? `${head}${monorepo}\n` : head;
+	return {
+		status: "patched",
+		content: `${isEsm ? IMPORT : REQUIRE}\n${body}${wrapped}`
+	};
+}
+function optionsLiteral(options) {
+	const from = dirname(options.metroConfigPath);
+	return `{\n\tcssEntryFile: "${toSpecifier(from, options.cssPath)}",\n\tdtsFile: "${toSpecifier(from, options.typesPath)}",\n}`;
+}
+/**
+* The resolver settings an app needs to reach a package outside its own tree.
+*
+* Metro resolves by walking `node_modules` from the app downwards, so without
+* `watchFolders` and `nodeModulesPaths` it simply cannot see a sibling package —
+* the import fails at bundle time with a missing module, pointing at the app
+* rather than at the workspace.
+*
+* `extraNodeModules` is the other half, and it is about runtime rather than
+* resolution: a package manager can materialise a second copy of a native module
+* under the app, and two registrations of one native module break. This is the
+* block `apps/playground/metro.config.js` in this repository carries for exactly
+* this reason.
+*/
+function monorepoResolverBlock(appRoot, workspaceRoot) {
+	const pins = PINNED_MODULES.map((name) => `\t${JSON.stringify(name)}: path.resolve(workspaceRoot, "node_modules/${name}"),`).join("\n");
+	return `const path = require("node:path");
+
+const workspaceRoot = path.resolve(__dirname, "${toSpecifier(appRoot, workspaceRoot)}");
+
+// The components live in a package outside this app, so Metro has to watch and
+// resolve beyond the app's own directory.
+config.watchFolders = [workspaceRoot];
+config.resolver.nodeModulesPaths = [
+\tpath.resolve(__dirname, "node_modules"),
+\tpath.resolve(workspaceRoot, "node_modules"),
+];
+config.resolver.disableHierarchicalLookup = true;
+
+// One copy of each native module for the whole bundle: two registrations of a
+// native module break at runtime.
+config.resolver.extraNodeModules = {
+${pins}
+};
+`;
+}
+function template(wrapper, monorepo) {
+	return `const { getDefaultConfig } = require("expo/metro-config");
+${REQUIRE}
+
+const config = getDefaultConfig(__dirname);
+${monorepo ? `\n${monorepo}` : ""}
+// withUniwindConfig must stay the outermost wrapper.
+module.exports = withUniwindConfig(config, ${wrapper});
+`;
+}
+function manualSnippet(wrapper, isEsm) {
+	return `${isEsm ? IMPORT : REQUIRE}\n\n// Keep this the outermost wrapper.\n${isEsm ? "export default" : "module.exports ="} withUniwindConfig(config, ${wrapper});`;
+}
+function toSpecifier(from, target) {
+	const path = toPosix$1(relative(from, target));
+	return path.startsWith(".") ? path : `./${path}`;
+}
+function toPosix$1(path) {
+	return sep === "/" ? path : path.split(sep).join("/");
+}
+//#endregion
 //#region src/commands/init.ts
 async function init(components, options) {
 	const output = createOutput(options);
@@ -14213,7 +14547,7 @@ async function add(names, options) {
 		output.warn("Nothing to add. Name a component, or pass --all.");
 		return null;
 	}
-	const scope = (item) => options.tests ? withTests(item) : item;
+	const scope = (item) => options.tests ? withTests(item, config.testRunner) : item;
 	const byName = new Map(index.items.map((item) => [item.name, item]));
 	const order = resolveItemGraph(requested, (name) => {
 		const entry = byName.get(name);
@@ -14227,16 +14561,31 @@ async function add(names, options) {
 	const toWrite = await resolveConflicts(planned, options, output);
 	if (toWrite === null) return null;
 	await writeFiles(toWrite);
-	await recordLock(config, planned, toWrite, options.ref || config.registry.ref || "abcaf1b8a49718368bc5726b1801ec58e75a2477");
+	await recordLock(config, planned, toWrite, options.ref || config.registry.ref || "713984b74d21a6bb6b0e1f719a947cce7a2d847e");
 	report$1(toWrite, planned, requested, output);
 	const settled = await settleDependencies(items, config, project, options, output);
+	const testSetup = options.tests ? await checkTestSetup(config, project, output) : [];
 	return {
 		items: items.map((item) => item.name),
 		written: toWrite.length,
-		...settled
+		...settled,
+		testSetup
 	};
 }
 /**
+* Says what the runner still needs before the copied tests will run.
+*
+* After the install, so a package it just added is not reported missing. The
+* CLI writes no runner config — that file is the project's — so a suite that
+* cannot load is said here, where it was copied, rather than found at the first
+* test run with an error naming neither the cause nor the fix.
+*/
+async function checkTestSetup(config, project, output) {
+	const checks = testChecks(await readTestSetup(config, project));
+	for (const check of checks.filter((entry) => entry.status === "warn" || entry.status === "fail")) output.warn([`${check.name}: ${check.detail}`, ...check.fix ? [`  ${check.fix}`] : []].join("\n"));
+	return checks;
+}
+/**
 * Everything that follows a write: the shared package's manifest, the report of
 * what the components need from npm, and the install if it is wanted.
 *
@@ -14389,7 +14738,7 @@ function printSkippedInstall(plan, appPath, output) {
 * true.
 */
 function warnAboutNativeRebuild(items, project, output) {
-	const added = missingPackages(project.packageJson, collect(items, "expoDependencies"));
+	const added = missingPackages$1(project.packageJson, collect(items, "expoDependencies"));
 	if (added.length === 0) return;
 	output.warn([
 		`Added native modules: ${added.join(", ")}`,
@@ -15260,7 +15609,7 @@ async function planUpdate(input) {
 	const byName = new Map(index.items.map((item) => [item.name, item]));
 	const candidates = input.names.length > 0 ? [...input.names] : [.../* @__PURE__ */ new Set([...Object.keys(lock.items), ...await installedItems(index.items, config)])];
 	const dropped = candidates.filter((name) => !byName.has(name) && lock.items[name] !== void 0);
-	const scope = (item) => input.tests || hasTests(lock, item.name) ? withTests(item) : item;
+	const scope = (item) => input.tests || hasTests(lock, item.name) ? withTests(item, config.testRunner) : item;
 	const order = resolveItemGraph(candidates.filter((name) => !dropped.includes(name)), (name) => {
 		const entry = byName.get(name);
 		return entry && scope(entry);
@@ -15518,7 +15867,7 @@ async function promptUntracked(files) {
 async function readPlan(names, options, output, clients) {
 	const config = await loadConfig(options.cwd);
 	const lock = await readLock(config.root);
-	const ref = options.ref || config.registry.ref || "abcaf1b8a49718368bc5726b1801ec58e75a2477";
+	const ref = options.ref || config.registry.ref || "713984b74d21a6bb6b0e1f719a947cce7a2d847e";
 	const url = options.registry ?? config.registry.url;
 	const open = (at) => createRegistryClient({
 		cwd: options.cwd,
@@ -31669,6 +32018,7 @@ function describeAdd(result) {
 	} else if (result.installed) lines.push(`Installed: ${dependencies.missing.join(", ")}.`);
 	else lines.push("Not installed. These have to be run from the app before it will build:", ...dependencies.groups.map((group) => `  ${commandLine(group)}`), "Re-run with install: true to have them run for you.");
 	if (dependencies.groups.some((group) => group.label === "expo install")) lines.push("A native module changed — rebuild the dev client; a JS reload will not pick it up.");
+	for (const check of result.testSetup.filter((entry) => entry.status === "warn" || entry.status === "fail")) lines.push(`The copied tests will not run yet — ${check.name}: ${check.detail}.${check.fix ? ` ${check.fix}` : ""}`);
 	return lines;
 }
 //#endregion
@@ -32784,7 +33134,7 @@ function report(result, output) {
 	if (result.derived.length > 0) output.info(`${result.derived.length} filled in, derived from tokens the theme does define: ${result.derived.map((name) => name.slice(2)).join(", ")}.`);
 	for (const warning of result.warnings) output.warn(warning);
 }
-const program = new Command().name("delacour").description("Add React Native components to your Expo app. You own the code.").version("0.5.0-alpha.20261021114607");
+const program = new Command().name("delacour").description("Add React Native components to your Expo app. You own the code.").version("0.5.0");
 /** Shared by every command that reads the registry. */
 function withRegistryOptions(command) {
 	return command.addOption(new Option("--registry <url>", "registry to read from: a URL, github:owner/repo, or a local path")).addOption(new Option("--ref <ref>", "git ref to read the registry at").default(DEFAULT_REGISTRY_REF)).addOption(new Option("--offline", "use only what is already cached")).addOption(new Option("-c, --cwd <path>", "directory to work in").default(process.cwd()));