uipkge-ng 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to `uipkge-ng` (and its aliases `@uipkge/ng` and `uipkge`). This project follows [Semantic Versioning](https://semver.org); while it's 0.x, minor versions may change behaviour.
+
+## 0.1.1 — 2026-09-26
+
+### Added
+
+- `doctor`: checks the setup (Node, Angular app, `components.json`, registries and their tokens, aliases, Tailwind v4 and its build step, design tokens actually loaded, `cn()`, incomplete components, undeclared component packages) and prints the fix for each problem. Exits with 1 on failure; `--json`.
+
+### Fixed
+
+- `add` no longer stops half-way on a bundle item — an item with no files of its own, only dependencies, such as `charts`. Bundles now install their dependencies.
+- `add` checks every item before writing anything, so a broken item can't leave a project half-installed.
+- `init` works when the default registry (`registryUrl`) ships only its own components: `utils` and `tailwind` come from uipkge instead, and it says so.
+
+### Changed
+
+- Resolving dependencies fetches in parallel: adding all 200 uipkge components resolves in about 3 seconds instead of about 70.
+- `build` writes bare names in `registryDependencies` as uipkge URLs, so they resolve the same in every project whatever its default registry is. A bare name that matches one of the registry's own items is now an error — use `@your-registry/name` or a URL for those.
+
+## 0.1.0 — 2026-09-25
+
+First release.
+
+- `init`: Tailwind CSS v4, the `cn()` helper, design tokens and tsconfig paths; Sass/Less apps get the tokens registered in `angular.json`.
+- `add`: components with their dependencies, `@angular/*` pinned to the app's version; `--dry-run`, `--view`, `--diff`, `--path`, `--overwrite`; stops before writing when a file you have differs.
+- `list`, `view`, `diff`, `info`.
+- Custom folders through `aliases`, with import rewriting.
+- Named and private registries (`@name/item`, `{name}` URLs, `${ENV}` headers from the environment, `.env.local` and `.env`).
+- `build` for publishing your own registry; `mcp` server for AI assistants.
+- Multi-project Angular workspaces and npm/pnpm/yarn/bun monorepos.

package/README.md

@@ -92,6 +92,7 @@ Dark mode follows a `dark` class on `<html>`.
 | [`view <items...>`](#view) | show a component's details and source |
 | [`diff [item]`](#diff) | compare your copies with the registry |
 | [`info`](#info) | project, config and registry details |
+| [`doctor`](#doctor) | check the setup and explain how to fix problems |
 | [`build [registry.json]`](#publishing-your-own-registry) | build your own registry |
 | [`mcp`](#ai-assistants-mcp) | MCP server for AI assistants |
 
@@ -168,6 +169,30 @@ Checks what you installed from the default registry and from every named one. Ta
 
 Prints the CLI and Node versions, the project (app, Angular, package manager, Tailwind, PostCSS), `components.json`, the folders your aliases resolve to, whether the registry is reachable and what's installed. Paste it into bug reports; `--json` for machines.
 
+### doctor
+
+```bash
+npx uipkge-ng doctor
+```
+
+Checks the whole setup — like `react-native doctor` — and says how to fix anything wrong:
+
+```text
+Styling
+ ✔ Tailwind CSS           ^4.3.3
+ ✔ Tailwind build         .postcssrc.json uses @tailwindcss/postcss
+ ✖ Design tokens          src/uipkge.css isn't loaded
+                          → Add `@import './uipkge.css';` to src/styles.css, or list src/uipkge.css under "styles" in angular.json.
+
+Components
+ ! Incomplete components  files missing from 1: card
+                          → Reinstall with `uipkge-ng add card --overwrite`.
+ ✖ Component packages     not in package.json: class-variance-authority
+                          → Run `npm install class-variance-authority`.
+```
+
+It checks Node, the Angular app (and workspace), `components.json`, that the registry and every named registry answer (and their tokens are set), that your aliases resolve, Tailwind v4 and its build step, that the design tokens are actually loaded, the `cn()` helper, components with missing files, and npm packages your components need but `package.json` doesn't list. It changes nothing. It exits with 1 when something fails, so it can run in CI; `--json` for scripts.
+
 ## Existing projects
 
 uipkge-ng is built to be run on apps that already have code in them:
@@ -237,7 +262,7 @@ Every command then uses those folders, and the `@/ui/…` and `@/lib/…` import
 
 ## Registries
 
-Components come from `https://uipkge.dev/r/angular` unless you configure otherwise. Any shadcn-style registry works — a public one, your company's private one, or one you [build yourself](#publishing-your-own-registry).
+Out of the box everything comes from the uipkge registry, `https://uipkge.dev/r/angular` — no setup needed. Any shadcn-style registry works — a public one, your company's private one, or one you [build yourself](#publishing-your-own-registry).
 
 ### Changing the default registry
 
@@ -360,7 +385,7 @@ It never writes files — installing stays a command you run. It reads the `comp
 | `Registry "@acme" needs the environment variable ACME_TOKEN` | set it in your shell, `.env.local` or `.env` |
 | `Nx workspaces are not supported yet` | use a standalone Angular CLI app for now |
 
-Still stuck? Include the output of `npx uipkge-ng info` when you [open an issue](https://github.com/uday-a/uipkge-cli/issues).
+Start with `npx uipkge-ng doctor` — it finds most setup problems and tells you the fix. Still stuck? Include the output of `npx uipkge-ng info` when you [open an issue](https://github.com/uday-a/uipkge-cli/issues).
 
 ## Credits
 
@@ -368,4 +393,6 @@ Created by **Uday Adaka** as part of **[uipkge](https://uipkge.dev)**. It uses t
 
 ## License
 
-[MIT](./LICENSE) © 2026 Uday Adaka — uipkge. You can use, change and redistribute it freely; keep the copyright and license notice in copies of the CLI.
+[MIT](./LICENSE) © 2026 Uday Adaka — uipkge.
+
+In plain words: you can use it for anything — personal or commercial — fork it, change it, and sell or redistribute it, including your modified version. The one condition: keep the copyright line (Uday Adaka, uipkge) and the license text in every copy.

package/dist/commands/add.js

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { registryFor, requireConfig } from '../config.js';
 import { UipkgeError } from '../errors.js';
 import { applyCss, applyEnv, envKeys, hasCss } from '../extras.js';
-import { conflictingFiles, isItemInstalled, targetedFiles, writeItemFiles } from '../files.js';
+import { assertWritable, conflictingFiles, isItemInstalled, targetedFiles, writeItemFiles } from '../files.js';
 import { adaptItem, resolveLayout } from '../layout.js';
 import { color, log, plural } from '../output.js';
 import { installPackages, missingPackages, pinAngular } from '../packages.js';
@@ -70,6 +70,9 @@ export async function runAdd(options) {
         log.info(`Already installed: ${plan.skipped.join(', ')}. ${color.dim('Use --overwrite to reinstall.')}`);
         return;
     }
+    // Every item must be writable before anything is written or installed.
+    for (const item of plan.install)
+        assertWritable(root, item);
     // Existing files that differ: never write the rest of an item around them.
     let overwrite = options.overwrite;
     const conflicts = overwrite ? [] : plan.install.flatMap(item => conflictingFiles(root, item).map(file => `${file} (${item.name})`));
@@ -115,7 +118,8 @@ export async function runAdd(options) {
             log.warn(`${item.name} ships a Tailwind v3 config; Tailwind v4 reads config from CSS, so it was not applied.`);
         if (item.docs)
             docs.push([item.name, item.docs]);
-        log.success(`${item.name} ${color.dim(`(${[plural(result.written.length, 'file'), ...extras].join(', ')})`)}`);
+        const summary = targetedFiles(item).length ? plural(result.written.length, 'file') : 'bundle';
+        log.success(`${item.name} ${color.dim(`(${[summary, ...extras].join(', ')})`)}`);
     }
     log.blank();
     log.info(`${color.green('✔')} Added ${plural(plan.install.length, 'component')}.`);

package/dist/commands/doctor.js

@@ -0,0 +1,251 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { readConfig, registryFor } from '../config.js';
+import { targetedFiles } from '../files.js';
+import { adaptItem, resolveLayout } from '../layout.js';
+import { color } from '../output.js';
+import { installArgs, missingPackages } from '../packages.js';
+import { angularApps, declaredDependencies, detectPackageManager, findApp, readPackageJson, resolveTarget } from '../project.js';
+import { FOUNDATION_ITEMS, namedRegistryFrom } from '../registry.js';
+import { projectEnv } from '../env.js';
+import { TAILWIND_POSTCSS, readPostcssConfig, relativeImport } from '../setup.js';
+const MIN_NODE = [20, 12];
+/** `3: a, b, c` or `202: a, b, c, d, e, f … and 196 more`. */
+const summarize = (names, shown = 6) => `${names.length}: ${names.slice(0, shown).join(', ')}${names.length > shown ? ` … and ${names.length - shown} more` : ''}`;
+/**
+ * Checks a project's uipkge setup, like `react-native doctor`. Never throws:
+ * every problem becomes a failed check with a fix, and later checks that
+ * depend on it are skipped rather than failing with noise.
+ */
+export async function runChecks(cwd) {
+    const checks = [];
+    const push = (c) => (checks.push(c), c);
+    // ── Environment ──
+    const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+    const nodeOk = major > MIN_NODE[0] || (major === MIN_NODE[0] && minor >= MIN_NODE[1]);
+    push({
+        section: 'Environment',
+        title: 'Node.js',
+        status: nodeOk ? 'pass' : 'fail',
+        detail: process.version,
+        fix: nodeOk ? undefined : `uipkge-ng needs Node ${MIN_NODE.join('.')} or newer.`,
+    });
+    // ── Project ──
+    const location = findApp(path.resolve(cwd));
+    if (!location) {
+        push({ section: 'Project', title: 'package.json', status: 'fail', detail: 'none found', fix: 'Run this inside your Angular project.' });
+        return checks;
+    }
+    if (location.ambiguous) {
+        push({
+            section: 'Project',
+            title: 'Angular app',
+            status: 'fail',
+            detail: `this workspace has ${location.ambiguous.length} apps: ${location.ambiguous.map(a => a.name).join(', ')}`,
+            fix: `Run it inside one app's folder, or pass it with \`-c ${path.relative(cwd, location.ambiguous[0].root) || '.'}\`.`,
+        });
+        return checks;
+    }
+    const { root, packageRoot } = location;
+    let pkg;
+    try {
+        pkg = await readPackageJson(packageRoot);
+    }
+    catch (error) {
+        push({ section: 'Project', title: 'package.json', status: 'fail', detail: error.message });
+        return checks;
+    }
+    const deps = declaredDependencies(pkg);
+    const angular = deps['@angular/core'];
+    push({
+        section: 'Project',
+        title: 'Angular',
+        status: angular ? 'pass' : 'fail',
+        detail: angular ? `${angular}${location.app ? ` (app: ${location.app.name})` : ''}` : 'no @angular/core in package.json',
+        fix: angular ? undefined : 'uipkge-ng works with Angular CLI apps.',
+    });
+    if (!angular)
+        return checks;
+    const nx = Boolean(deps['nx'] || existsSync(path.join(packageRoot, 'nx.json')));
+    if (nx)
+        push({ section: 'Project', title: 'Nx', status: 'fail', detail: 'Nx workspaces are not supported yet' });
+    const pm = detectPackageManager(packageRoot, pkg);
+    push({ section: 'Project', title: 'Package manager', status: 'pass', detail: pm });
+    // ── Configuration ──
+    let config = null;
+    try {
+        config = await readConfig(root);
+    }
+    catch (error) {
+        push({ section: 'Configuration', title: 'components.json', status: 'fail', detail: error.message, fix: 'Fix the JSON, or run `uipkge-ng init --overwrite`.' });
+        return checks;
+    }
+    if (!config) {
+        push({ section: 'Configuration', title: 'components.json', status: 'fail', detail: `not found in ${root}`, fix: 'Run `uipkge-ng init`.' });
+        return checks;
+    }
+    push({ section: 'Configuration', title: 'components.json', status: 'pass', detail: path.relative(cwd, path.join(root, 'components.json')) || 'components.json' });
+    const registry = registryFor(root, config, cwd);
+    let index = null;
+    try {
+        index = (await registry.index()).items;
+        push({ section: 'Configuration', title: 'Registry', status: 'pass', detail: `${registry.baseUrl} (${index.length} items)` });
+    }
+    catch (error) {
+        push({
+            section: 'Configuration',
+            title: 'Registry',
+            status: 'fail',
+            detail: `${registry.baseUrl}: ${error.message}`,
+            fix: 'Check your connection, "registryUrl" in components.json, or UIPKGE_REGISTRY_URL.',
+        });
+    }
+    const env = projectEnv(root);
+    for (const [ns, raw] of Object.entries(config.registries ?? {})) {
+        try {
+            namedRegistryFrom(ns, raw, env);
+            await registry.index(ns);
+            push({ section: 'Configuration', title: `Registry ${ns}`, status: 'pass' });
+        }
+        catch (error) {
+            push({
+                section: 'Configuration',
+                title: `Registry ${ns}`,
+                status: 'fail',
+                detail: error.message,
+                fix: `Check "${ns}" under "registries" in components.json; tokens come from the environment, .env.local or .env.`,
+            });
+        }
+    }
+    let layout = null;
+    try {
+        layout = resolveLayout(root, config.aliases);
+        push({ section: 'Configuration', title: 'Folders (aliases)', status: 'pass', detail: `ui → ${layout.dirs.ui}, lib → ${layout.dirs.lib}` });
+    }
+    catch (error) {
+        push({ section: 'Configuration', title: 'Folders (aliases)', status: 'fail', detail: error.message, fix: 'Map the aliases in tsconfig "paths", or run `uipkge-ng init --overwrite`.' });
+    }
+    // ── Styling ──
+    const tailwind = deps['tailwindcss'];
+    const tailwindMajor = Number(tailwind?.match(/\d+/)?.[0] ?? 0);
+    push({
+        section: 'Styling',
+        title: 'Tailwind CSS',
+        status: tailwindMajor >= 4 ? 'pass' : 'fail',
+        detail: tailwind ?? 'not installed',
+        fix: tailwindMajor >= 4 ? undefined : tailwind ? 'uipkge components need Tailwind CSS v4.' : 'Run `uipkge-ng init`.',
+    });
+    const analog = Boolean(deps['@analogjs/platform'] || deps['@analogjs/vite-plugin-angular']);
+    if (analog) {
+        push({ section: 'Styling', title: 'Tailwind build', status: 'warn', detail: 'Analog builds with Vite', fix: "Check vite.config.ts has `tailwindcss()` from '@tailwindcss/vite' in plugins." });
+    }
+    else {
+        const postcss = await readPostcssConfig(packageRoot);
+        const wired = postcss?.content.includes(TAILWIND_POSTCSS);
+        push({
+            section: 'Styling',
+            title: 'Tailwind build',
+            status: wired ? 'pass' : 'fail',
+            detail: wired ? `${postcss.file} uses ${TAILWIND_POSTCSS}` : postcss ? `${postcss.file} doesn't use ${TAILWIND_POSTCSS}` : 'no PostCSS config',
+            fix: wired ? undefined : `Add "${TAILWIND_POSTCSS}" to your PostCSS plugins, or run \`uipkge-ng init --overwrite\`.`,
+        });
+    }
+    const tokensFile = path.join(root, config.tokens);
+    if (!existsSync(tokensFile)) {
+        push({ section: 'Styling', title: 'Design tokens', status: 'fail', detail: `${config.tokens} is missing`, fix: 'Run `uipkge-ng init --overwrite`.' });
+    }
+    else {
+        // Loaded either by an @import in the global stylesheet or as its own entry in angular.json "styles".
+        const importPath = relativeImport(config.styles, config.tokens);
+        const stylesFile = path.join(root, config.styles);
+        const imported = existsSync(stylesFile) && new RegExp(`@import\\s+(url\\()?['"]${importPath.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')}['"]`).test(readFileSync(stylesFile, 'utf8'));
+        const app = location.app ?? angularApps(packageRoot).find(a => a.root === root);
+        const registered = Boolean(app?.styles.some(s => path.resolve(root, s) === tokensFile));
+        push({
+            section: 'Styling',
+            title: 'Design tokens',
+            status: imported || registered ? 'pass' : 'fail',
+            detail: imported ? `${config.styles} imports ${importPath}` : registered ? `${config.tokens} is in angular.json "styles"` : `${config.tokens} isn't loaded`,
+            fix: imported || registered ? undefined : `Add \`@import '${importPath}';\` to ${config.styles}, or list ${config.tokens} under "styles" in angular.json.`,
+        });
+    }
+    if (layout) {
+        const utils = path.join(root, layout.dirs.lib, 'utils.ts');
+        const hasCn = existsSync(utils) && /export\s+(?:function|const|let)\s+cn\b|export\s*\{[^}]*\bcn\b[^}]*\}/.test(readFileSync(utils, 'utf8'));
+        push({
+            section: 'Styling',
+            title: 'cn() helper',
+            status: hasCn ? 'pass' : 'fail',
+            detail: hasCn ? path.relative(root, utils) : existsSync(utils) ? `${path.relative(root, utils)} doesn't export cn()` : `${path.relative(root, utils)} is missing`,
+            fix: hasCn ? undefined : 'Every component imports it. Run `uipkge-ng init --overwrite`, or add it (`uipkge-ng view utils`).',
+        });
+    }
+    // ── Components ──
+    if (!index || !layout) {
+        push({ section: 'Components', title: 'Installed components', status: 'skip', detail: 'needs the registry and folders above' });
+        return checks;
+    }
+    const installed = [];
+    const partial = [];
+    for (const item of index.filter(i => !FOUNDATION_ITEMS.has(i.name))) {
+        const files = targetedFiles(adaptItem(item, layout));
+        if (!files.length)
+            continue;
+        const present = files.filter(f => existsSync(resolveTarget(root, f.target))).length;
+        if (present === files.length)
+            installed.push(item);
+        else if (present > 0)
+            partial.push(item.name);
+    }
+    push({ section: 'Components', title: 'Installed components', status: 'pass', detail: installed.length ? summarize(installed.map(i => i.name)) : 'none yet' });
+    if (partial.length) {
+        push({
+            section: 'Components',
+            title: 'Incomplete components',
+            status: 'warn',
+            detail: `files missing from ${summarize(partial)}`,
+            fix: `Reinstall with \`uipkge-ng add ${partial.join(' ')} --overwrite\`.`,
+        });
+    }
+    const missing = missingPackages(installed.flatMap(i => i.dependencies ?? []), deps);
+    push({
+        section: 'Components',
+        title: 'Component packages',
+        status: missing.length ? 'fail' : 'pass',
+        detail: missing.length ? `not in package.json: ${missing.join(', ')}` : 'all declared',
+        fix: missing.length ? `Run \`${pm} ${installArgs(pm, missing, false).join(' ')}\`.` : undefined,
+    });
+    return checks;
+}
+const MARK = {
+    pass: color.green('✔'),
+    warn: color.yellow('!'),
+    fail: color.red('✖'),
+    skip: color.dim('-'),
+};
+export async function runDoctor(options) {
+    const checks = await runChecks(options.cwd);
+    const failed = checks.filter(c => c.status === 'fail').length;
+    const warned = checks.filter(c => c.status === 'warn').length;
+    if (failed)
+        process.exitCode = 1;
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ ok: failed === 0, checks }, null, 2)}\n`);
+        return;
+    }
+    const width = Math.max(...checks.map(c => c.title.length)) + 2;
+    const out = [color.bold('uipkge-ng doctor')];
+    let section = '';
+    for (const c of checks) {
+        if (c.section !== section)
+            out.push('', color.bold(c.section)), (section = c.section);
+        out.push(` ${MARK[c.status]} ${c.title.padEnd(width)}${c.detail ? color.dim(c.detail) : ''}`);
+        if (c.fix && (c.status === 'fail' || c.status === 'warn'))
+            out.push(`   ${' '.repeat(width)}${color.cyan('→')} ${c.fix}`);
+    }
+    const passed = checks.filter(c => c.status === 'pass').length;
+    out.push('', failed
+        ? color.red(`${failed} problem${failed === 1 ? '' : 's'} found`) + color.dim(` · ${passed} passed${warned ? ` · ${warned} warning${warned === 1 ? '' : 's'}` : ''}`)
+        : color.green('Everything looks good.') + color.dim(` ${passed} checks passed${warned ? ` · ${warned} warning${warned === 1 ? '' : 's'}` : ''}`), '');
+    process.stdout.write(out.join('\n'));
+}

package/dist/files.js

@@ -26,15 +26,24 @@ export function conflictingFiles(root, item) {
         return normalizeEol(readFileSync(abs, 'utf8')) === normalizeEol(f.content) ? [] : [path.relative(root, abs)];
     });
 }
-export async function writeItemFiles(root, item, overwrite) {
-    const result = { written: [], kept: [] };
-    const files = targetedFiles(item);
-    if (!files.length)
-        throw new UipkgeError(`Registry item \`${item.name}\` has no files to install.`);
-    for (const file of files) {
+/**
+ * Throws if the item can't be written as-is. `add` checks every item before
+ * writing any, so a bad item never leaves a project half-installed. An item
+ * without files (a bundle such as `charts`) is fine: it only brings its
+ * dependencies.
+ */
+export function assertWritable(root, item) {
+    for (const file of targetedFiles(item)) {
         if (typeof file.content !== 'string') {
-            throw new UipkgeError(`Registry item \`${item.name}\` is missing the content of ${file.target}.`);
+            throw new UipkgeError(`Registry item \`${item.name}\` is missing the content of ${file.target}.`, 'Nothing was installed.');
         }
+        resolveTarget(root, file.target);
+    }
+}
+export async function writeItemFiles(root, item, overwrite) {
+    const result = { written: [], kept: [] };
+    assertWritable(root, item);
+    for (const file of targetedFiles(item)) {
         const abs = resolveTarget(root, file.target);
         const rel = path.relative(root, abs);
         if (existsSync(abs) && !overwrite) {

package/dist/index.js

@@ -6,6 +6,7 @@ import { normalizeOptionalValues } from './args.js';
 import { runAdd } from './commands/add.js';
 import { runBuild } from './commands/build.js';
 import { runDiff } from './commands/diff.js';
+import { runDoctor } from './commands/doctor.js';
 import { runInfo } from './commands/info.js';
 import { runInit } from './commands/init.js';
 import { runList } from './commands/list.js';
@@ -21,6 +22,7 @@ const COMMAND_HELP = [
     ['view <items...>', "show a component's details and files"],
     ['diff [item]', 'compare installed components with the registry'],
     ['info', 'show project, config and registry details'],
+    ['doctor', 'check the setup and explain how to fix problems'],
     ['build [file]', 'build your own registry (registry.json → public/r)'],
     ['mcp', 'run an MCP server so AI assistants can browse components'],
 ];
@@ -47,7 +49,7 @@ Options
   -s, --silent          only print errors
       --category <c>    only one category (list)
   -i, --installed       only installed components (list)
-      --json            machine-readable output (list, view, info)
+      --json            machine-readable output (list, view, info, doctor)
       --output <dir>    where build writes the registry (default public/r)
       --debug           show stack traces on errors
   -h, --help            show this help
@@ -55,7 +57,7 @@ Options
 
 Registry: https://uipkge.dev/r/angular (override with components.json "registryUrl" or UIPKGE_REGISTRY_URL)
 `;
-const COMMANDS = new Set(['init', 'add', 'list', 'ls', 'view', 'diff', 'info', 'build', 'mcp']);
+const COMMANDS = new Set(['init', 'add', 'list', 'ls', 'view', 'diff', 'info', 'doctor', 'build', 'mcp']);
 const OPTION_COMMANDS = {
     overwrite: ['init', 'add'],
     all: ['add'],
@@ -65,7 +67,7 @@ const OPTION_COMMANDS = {
     diff: ['add'],
     category: ['list', 'ls'],
     installed: ['list', 'ls'],
-    json: ['list', 'ls', 'view', 'info'],
+    json: ['list', 'ls', 'view', 'info', 'doctor'],
     output: ['build'],
 };
 async function main(argv) {
@@ -135,6 +137,8 @@ async function main(argv) {
             return runDiff({ cwd, name: rest[0] });
         case 'info':
             return runInfo({ cwd, json: values.json, version: VERSION });
+        case 'doctor':
+            return runDoctor({ cwd, json: values.json });
         case 'build':
             return runBuild({ cwd, registry: rest[0] ?? 'registry.json', output: values.output ?? 'public/r' });
         case 'mcp':

package/dist/resolve.js

@@ -28,17 +28,28 @@ transform = item => item) {
     const skipped = [];
     const dependencies = new Set();
     const devDependencies = new Set();
-    async function visit(ref, direct) {
-        // The default registry's foundation is init's job; a component depending on
-        // `utils` must not reinstall it. `@acme/utils` is someone else's item.
+    // The default registry's foundation is init's job; a component depending on
+    // `utils` must not reinstall it. `@acme/utils` is someone else's item.
+    const isFoundation = (ref) => {
         const kind = refKind(ref);
         const ownRegistry = kind === 'name' || (kind === 'url' && ref.startsWith(`${registry.baseUrl}/`));
-        if (ownRegistry && FOUNDATION_ITEMS.has(itemNameFromRef(ref)))
+        return ownRegistry && FOUNDATION_ITEMS.has(itemNameFromRef(ref));
+    };
+    // Start fetches early and in parallel; the registry caches them, so the ordered
+    // walk below just awaits ones already in flight. Errors surface there, not here.
+    const prefetch = (refs) => {
+        for (const ref of refs)
+            if (!isFoundation(ref))
+                registry.item(ref).catch(() => undefined);
+    };
+    async function visit(ref, direct) {
+        if (isFoundation(ref))
             return undefined;
         const item = transform(await registry.item(ref), direct);
         if (visited.has(item.name))
             return item.name;
         visited.add(item.name);
+        prefetch(item.registryDependencies ?? []);
         for (const dep of item.registryDependencies ?? [])
             await visit(dep, false);
         if (isInstalled(item) && !overwrite) {
@@ -51,6 +62,7 @@ transform = item => item) {
         return item.name;
     }
     const requested = [];
+    prefetch(names);
     for (const name of names) {
         const resolved = await visit(name, true);
         if (resolved && !requested.includes(resolved))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uipkge-ng",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Add uipkge Angular components to your project: copy the source, own the code.",
   "license": "MIT",
   "author": "Uday Adaka (https://uipkge.dev)",
@@ -25,7 +25,8 @@
     "uipkge-ng": "dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "engines": {
     "node": ">=20.12"
@@ -34,7 +35,9 @@
     "build": "tsc -p tsconfig.build.json",
     "dev": "tsx src/index.ts",
     "test": "vitest run",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@clack/prompts": "^1.8.1",
@@ -43,6 +46,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "3.2.7",
     "tsx": "^4.20.0",
     "typescript": "^5.9.3",
     "vitest": "^3.2.7"