@parity-app/cli 0.6.2 → 0.7.0

package/dist/src-D2kRGtaF.mjs

@@ -0,0 +1,129 @@
+import { a as applyLibraryEdits, f as parseLibraryEdits, p as parseLibraryManifest, u as libraryManifestExtension } from "./src-CSah1pZ-.mjs";
+import { createRequire } from "node:module";
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import semver from "semver";
+// ../core/src/jsonc.ts
+/** Parses JSON with comments and trailing commas, as tsconfig files allow. Comment markers inside strings are kept. */
+function parseJsonc(text) {
+	let output = "";
+	let index = 0;
+	while (index < text.length) {
+		const char = text[index];
+		if (char === "\"") {
+			const start = index++;
+			while (index < text.length && text[index] !== "\"") index += text[index] === "\\" ? 2 : 1;
+			output += text.slice(start, ++index);
+		} else if (char === "/" && text[index + 1] === "/") while (index < text.length && text[index] !== "\n") index++;
+		else if (char === "/" && text[index + 1] === "*") {
+			const end = text.indexOf("*/", index + 2);
+			index = end === -1 ? text.length : end + 2;
+		} else {
+			output += char;
+			index++;
+		}
+	}
+	return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
+}
+// ../registry/src/index.ts
+const require = createRequire(import.meta.url);
+/**
+* The folder the registry's files are in. The published CLI bundles this module and ships the files beside it, where
+* the package can't be resolved. Otherwise they're found through the package's own `package.json`, so it's the same
+* whether this module runs from source or bundled into the app.
+*/
+function registryDir() {
+	const bundled = join(import.meta.dirname, "libraries");
+	if (existsSync(bundled)) return bundled;
+	return join(dirname(require.resolve("@parity-app/registry/package.json")), "libraries");
+}
+let cache;
+/** Every file in the registry, read once. One that doesn't parse is skipped with a warning. */
+function registryEntries(dir = registryDir()) {
+	if (dir !== registryDir()) return readEntries(dir);
+	cache ??= readEntries(dir);
+	return cache;
+}
+async function readEntries(dir) {
+	const files = (await readdir(dir).catch(() => [])).filter((file) => file.endsWith(libraryManifestExtension)).sort();
+	const entries = [];
+	for (const file of files) {
+		const path = join(dir, file);
+		try {
+			const manifest = parseLibraryManifest(JSON.parse(await readFile(path, "utf8")));
+			if (!manifest.package) throw new TypeError("/package: a registry file names the package it describes");
+			entries.push({
+				file,
+				path,
+				manifest
+			});
+		} catch (error) {
+			console.warn(`Skipping registry file ${file}: ${errorText(error)}`);
+		}
+	}
+	return entries;
+}
+/**
+* The newest file for each package the registry describes, by the version it was made from, with its hand edits
+* applied. A file whose edits can't be read is used as it is, with a warning.
+*/
+async function newestEntries(dir) {
+	const newest = /* @__PURE__ */ new Map();
+	for (const entry of await registryEntries(dir)) {
+		const name = entry.manifest.package.name;
+		const current = newest.get(name);
+		if (!current || compareGenerated(entry.manifest, current.manifest) > 0) newest.set(name, entry);
+	}
+	return Promise.all([...newest.values()].map(async (entry) => {
+		try {
+			return {
+				...entry,
+				manifest: (await withEdits(entry.path, entry.manifest)).manifest
+			};
+		} catch (error) {
+			console.warn(`Using registry file ${entry.file} without its edits: ${errorText(error)}`);
+			return entry;
+		}
+	}));
+}
+/**
+* A library file at `path` with its hand edits applied: its own `edits`, or the shared file it names beside it. Edits
+* for exports it doesn't have are its `orphans`, reported rather than dropped silently. Throws when the edits can't be
+* read.
+*/
+async function withEdits(path, manifest) {
+	if (manifest.edits === void 0) return {
+		manifest,
+		orphans: []
+	};
+	return applyLibraryEdits(manifest, await readLibraryEdits(manifest.edits, dirname(path)));
+}
+/**
+* Hand edits as a library file writes them: inline, or the path of a shared file, which is read from `from` and may
+* have comments.
+*/
+async function readLibraryEdits(edits, from) {
+	return parseLibraryEdits(typeof edits === "string" ? parseJsonc(await readFile(resolve(from, edits), "utf8")) : edits);
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Whether a manifest describes this version of its package. A manifest without a range covers every version. */
+function covers(manifest, version) {
+	const range = manifest.package?.range;
+	if (!range) return true;
+	if (!version) return false;
+	const parsed = semver.coerce(version, { includePrerelease: true });
+	return parsed !== null && semver.satisfies(parsed, range, { includePrerelease: true });
+}
+function compareGenerated(a, b) {
+	const left = semver.coerce(a.package?.version);
+	const right = semver.coerce(b.package?.version);
+	if (!left || !right) {
+		if (left) return 1;
+		return right ? -1 : 0;
+	}
+	return semver.compare(left, right);
+}
+export { registryEntries as a, registryDir as i, newestEntries as n, withEdits as o, readLibraryEdits as r, parseJsonc as s, covers as t };

package/dist/src-vUHtM2X4.mjs

@@ -0,0 +1 @@
+export { t as covers, n as newestEntries, i as registryDir, a as registryEntries } from "./src-D2kRGtaF.mjs";

package/dist/{src-BvKhu6dX.mjs → src-x0VQ8I6l.mjs}

@@ -1,13 +1,13 @@
-import { i as plainObject, t as finiteNumber } from "./schema-zRNxotYl.mjs";
-import { D as collectCustomProperties, a as applyLibraryEdits, c as isSampleElement, f as parseLibraryEdits, j as lengthToPixels, l as isSampleRender, m as renderSlotOf, p as parseLibraryManifest, s as isMadeValue, u as libraryManifestExtension } from "./src-V9wTMkxO.mjs";
-import "./src-BIVDlIGc.mjs";
+import { a as parseData, n as finiteNumber, o as plainObject, r as jsonText } from "./schema-DcQLoUPP.mjs";
+import { E as collectCustomProperties, M as packageManifest, a as applyLibraryEdits, c as isSampleElement, f as parseLibraryEdits, j as lengthToPixels, l as isSampleRender, m as renderSlotOf, p as parseLibraryManifest, s as isMadeValue, u as libraryManifestExtension } from "./src-CSah1pZ-.mjs";
+import { r as readLibraryEdits, s as parseJsonc } from "./src-D2kRGtaF.mjs";
 import { a as publishedVersions, n as packageFile, o as repositoryFiles, r as publishedSource } from "./published-CdXoUgfD.mjs";
 import { createRequire } from "node:module";
 import { mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join, posix, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { createHash } from "node:crypto";
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { z } from "zod";
 import { pathToFileURL } from "node:url";
@@ -528,28 +528,6 @@ function slashes(path) {
 	return path.replaceAll("\\", "/");
 }
 ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.NonPrimitive | ts.TypeFlags.TypeParameter;
-// ../project/src/jsonc.ts
-/** Parses JSON with comments and trailing commas, as tsconfig files allow. Comment markers inside strings are kept. */
-function parseJsonc(text) {
-	let output = "";
-	let index = 0;
-	while (index < text.length) {
-		const char = text[index];
-		if (char === "\"") {
-			const start = index++;
-			while (index < text.length && text[index] !== "\"") index += text[index] === "\\" ? 2 : 1;
-			output += text.slice(start, ++index);
-		} else if (char === "/" && text[index + 1] === "/") while (index < text.length && text[index] !== "\n") index++;
-		else if (char === "/" && text[index + 1] === "*") {
-			const end = text.indexOf("*/", index + 2);
-			index = end === -1 ? text.length : end + 2;
-		} else {
-			output += char;
-			index++;
-		}
-	}
-	return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
-}
 // ../tokens/src/dtcg-values.ts
 /** A value written as CSS. */
 const css = z.string();
@@ -935,6 +913,247 @@ new Intl.Collator("en", {
 	numeric: true,
 	sensitivity: "base"
 });
+// ../project/src/packages.ts
+/**
+* The package a folder's code gets for `name`, found the way Node finds packages: in `node_modules` here or in a folder
+* above, with links followed. It reads the package's own package.json, which its `exports` may leave out of reach of
+* `require.resolve`, and never falls back to NODE_PATH, which pnpm's bin shims point at Parity's own dependencies.
+* Throws when the manifest isn't a package's.
+*/
+async function findPackage(from, name) {
+	for (let folder = resolve(from);; folder = dirname(folder)) {
+		const installedAt = join(folder, "node_modules", name);
+		const text = await readFile(join(installedAt, "package.json"), "utf8").catch(() => void 0);
+		if (text !== void 0) {
+			const manifest = readManifest(text, join(installedAt, "package.json"));
+			return {
+				dir: await realpath(installedAt),
+				installedAt,
+				manifest
+			};
+		}
+		if (dirname(folder) === folder) return void 0;
+	}
+}
+/** The package in a folder, or nothing when it has no package.json. Throws when the manifest isn't a package's. */
+async function readPackage(dir) {
+	const file = join(dir, "package.json");
+	const text = await readFile(file, "utf8").catch(() => void 0);
+	return text === void 0 ? void 0 : {
+		dir,
+		manifest: readManifest(text, file)
+	};
+}
+function readManifest(text, file) {
+	try {
+		return parseData(jsonText(packageManifest), text);
+	} catch (error) {
+		throw new TypeError(`${file}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/** A bare specifier's package and the entry point in it: `@acme/ui/button` is `@acme/ui` and `./button`. */
+function splitSpecifier(specifier) {
+	const parts = specifier.split("/");
+	const length = specifier.startsWith("@") ? 2 : 1;
+	const rest = parts.slice(length).join("/");
+	return {
+		name: parts.slice(0, length).join("/"),
+		subpath: rest ? `./${rest}` : "."
+	};
+}
+const conditions = {
+	types: [
+		"types",
+		"import",
+		"default",
+		"require"
+	],
+	runtime: [
+		"node",
+		"import",
+		"default"
+	],
+	source: [
+		"source",
+		"types",
+		"import",
+		"default"
+	],
+	style: [
+		"style",
+		"import",
+		"default"
+	]
+};
+/** Which files a target may lead to for each use: declarations for types, anything but them otherwise. */
+const accepts = {
+	types: (file) => isDeclaration(file),
+	runtime: (file) => !isDeclaration(file),
+	source: () => true,
+	style: (file) => !isDeclaration(file)
+};
+/**
+* The file one of a package's entry points leads to for a use, or nothing when no file is there. `subpath` is the
+* entry point as `exports` names it: `.` for the package itself, or one such as `./tailwind.css`, which can be written
+* `tailwind.css`. A package that doesn't list an entry point in `exports` is read as older packages are: `types` or
+* `typings` for declarations, `module` or `main` for its module, and `style` for its stylesheet.
+*/
+function packageEntry(pkg, use, subpath = ".") {
+	const entry = subpath === "." || subpath.startsWith("./") ? subpath : `./${subpath}`;
+	for (const candidate of entryCandidates(pkg.manifest, use, entry)) {
+		const file = candidate && join(pkg.dir, candidate);
+		if (file && isFile(file)) return file;
+	}
+}
+function entryCandidates(manifest, use, entry) {
+	const root = entry === ".";
+	const path = entry.slice(2);
+	const exported = exportTarget(manifest.exports, entry, conditions[use], accepts[use]);
+	switch (use) {
+		case "types": return [
+			exported,
+			...root ? [manifest.types, manifest.typings] : [],
+			...entryCandidates(manifest, "runtime", entry).map((file) => file && declarationOf(file)),
+			root ? "index.d.ts" : `${path}/index.d.ts`,
+			root ? void 0 : `${path}.d.ts`
+		];
+		case "runtime": return [
+			exported,
+			...root ? [manifest.module, ...moduleFiles(manifest.main)] : [],
+			...root || manifest.exports !== void 0 ? [] : moduleFiles(path)
+		];
+		case "source": {
+			const named = [exported, ...root ? [
+				manifest.types,
+				manifest.typings,
+				manifest.module,
+				manifest.main
+			] : []].find((file) => file !== void 0);
+			return [...named && isBuilt(named) ? sourcesOf(named) : [named], ...root ? [
+				"src/index.tsx",
+				"src/index.ts",
+				"src/index.jsx",
+				"src/index.js",
+				"index.tsx",
+				"index.ts"
+			] : []];
+		}
+		case "style": return root ? [manifest.style, exported] : [exported, path];
+	}
+}
+/** A `main` as Node reads it: the file, the file with `.js`, or a folder's `index.js`; `index.js` without one. */
+function moduleFiles(main) {
+	return main ? [
+		main,
+		`${main}.js`,
+		`${main}/index.js`
+	] : ["index.js"];
+}
+const stylesheetNames = [
+	"tailwind.css",
+	"styles.css",
+	"style.css",
+	"index.css",
+	"theme.css"
+];
+/**
+* The stylesheet a project imports to use a package, as a path from the package: its `style` field, else the CSS its
+* `exports` lists, the usual names first. Only one that leads to a file counts.
+*/
+function packageStylesheet(pkg) {
+	const { style, exports } = pkg.manifest;
+	if (style && isFile(join(pkg.dir, style))) return style;
+	const css = Object.keys(exports === void 0 ? {} : subpaths(exports)).filter((key) => key.endsWith(".css") && !key.includes("*")).map((key) => key.slice(2));
+	const pick = stylesheetNames.find((name) => css.includes(name)) ?? css[0];
+	return pick && packageEntry(pkg, "style", pick) ? pick : void 0;
+}
+/** `exports` by subpath: a map as written, or the package's one entry point, which is `.`. */
+function subpaths(exports) {
+	if (typeof exports !== "object" || exports === null || Array.isArray(exports)) return { ".": exports };
+	return Object.keys(exports).some((key) => key.startsWith(".")) ? exports : { ".": exports };
+}
+/**
+* Where `exports` leads for an entry point under these conditions: the entry point as written, else the longest
+* pattern that matches it (`./icons/*`), with what `*` stood for put in.
+*/
+function exportTarget(exports, entry, wanted, accept) {
+	if (exports === void 0) return void 0;
+	const map = subpaths(exports);
+	if (Object.hasOwn(map, entry)) return resolveTarget(map[entry], wanted, accept);
+	let best;
+	for (const key of Object.keys(map)) {
+		const star = key.indexOf("*");
+		if (star === -1) continue;
+		const [prefix, suffix] = [key.slice(0, star), key.slice(star + 1)];
+		if (entry.length < key.length || !entry.startsWith(prefix) || !entry.endsWith(suffix)) continue;
+		if (!best || prefix.length > best.prefix.length) best = {
+			key,
+			prefix,
+			match: entry.slice(prefix.length, entry.length - suffix.length)
+		};
+	}
+	if (!best) return void 0;
+	const { key, match } = best;
+	return resolveTarget(map[key], wanted, (file) => accept(file.replaceAll("*", match)))?.replaceAll("*", match);
+}
+/** The first file a target leads to under the wanted conditions, taken in the order they're wanted. */
+function resolveTarget(target, wanted, accept) {
+	if (typeof target === "string") return accept(target) ? target : void 0;
+	if (target === null) return void 0;
+	if (Array.isArray(target)) {
+		for (const each of target) {
+			const found = resolveTarget(each, wanted, accept);
+			if (found) return found;
+		}
+		return;
+	}
+	for (const condition of wanted) {
+		const found = Object.hasOwn(target, condition) ? resolveTarget(target[condition], wanted, accept) : void 0;
+		if (found) return found;
+	}
+}
+function isDeclaration(file) {
+	return /\.d\.[cm]?ts$/.test(file);
+}
+/** The declarations TypeScript looks for beside a module: `index.d.ts` for `index.js`, `index.d.mts` for `index.mjs`. */
+function declarationOf(file) {
+	const match = /\.([cm]?)jsx?$/.exec(file);
+	return match ? `${file.slice(0, match.index)}.d.${match[1]}ts` : void 0;
+}
+/** Folders a package's build writes to, which its source isn't in. */
+const builtFolders = /* @__PURE__ */ new Set([
+	"dist",
+	"build",
+	"lib",
+	"out",
+	"esm",
+	"cjs"
+]);
+/** A file a build wrote: declarations, or anything in a build folder at the package's root. */
+function isBuilt(file) {
+	return isDeclaration(file) || builtFolders.has(file.replace(/^\.\//, "").split("/")[0]);
+}
+const sourceExtensions = [
+	".tsx",
+	".ts",
+	".jsx",
+	".js"
+];
+/**
+* Where a built file's source may be, in the order to look: `dist/index.js` and `dist/index.d.ts` were built from
+* `src/index.tsx`, `src/index.ts`, `src/index.jsx` or `src/index.js`, and `dist/esm/button.js` from `src/button.tsx`.
+*/
+function sourcesOf(file) {
+	const parts = file.replace(/^\.\//, "").split("/");
+	let start = 0;
+	while (start < parts.length - 1 && builtFolders.has(parts[start])) start++;
+	const rest = parts.slice(start).join("/").replace(/\.d\.[cm]?ts$|\.[cm]?jsx?$/, "");
+	const stem = start > 0 ? `src/${rest}` : rest;
+	return sourceExtensions.map((extension) => stem + extension);
+}
+function isFile(path) {
+	return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+}
 // ../project/src/styles.ts
 /**
 * Where an app keeps its global styles when neither `components.json` nor the entry says: Vite's and Create React App's
@@ -1047,21 +1266,6 @@ async function readText(path) {
 function toPosix(path) {
 	return path.replaceAll("\\", "/").replace(/^\.\//, "");
 }
-// ../project/src/libraries.ts
-/**
-* Where a dependency is installed, found the way Node finds packages: in `node_modules` here or in a folder above. It
-* doesn't resolve `<name>/package.json`, because a package whose `exports` leaves that out can't be resolved that way.
-*/
-async function installedPackage(root, importName) {
-	for (let folder = resolve(root);; folder = dirname(folder)) {
-		const candidate = join(folder, "node_modules", importName);
-		if (await isFile(join(candidate, "package.json"))) return realpath(candidate);
-		if (dirname(folder) === folder) return void 0;
-	}
-}
-async function isFile(path) {
-	return stat(path).then((stats) => stats.isFile(), () => false);
-}
 /** A sentence that ends this far in is kept whole, rather than its words cut down to the length. */
 const shortestSentence = 20;
 /**
@@ -3924,7 +4128,6 @@ const presets = {
 			id: style,
 			name: `Shadcn ${style.charAt(0).toUpperCase()}${style.slice(1)}`,
 			description: `Every shadcn component on Base UI, in the ${style} style, kept in step with upstream.`,
-			styles: "tailwind.css",
 			examples: {
 				paths: ["apps/v4/examples/base/"],
 				anatomy: ["apps/v4/content/docs/components/base/"]
@@ -4627,16 +4830,16 @@ async function generateLibrary(options) {
 }
 async function describePackage(options, importName) {
 	const root = resolve(options.root);
-	const dir = await installedPackage(root, importName);
-	if (!dir) throw new Error(`${importName} isn't installed in ${root}. Install it with the project's package manager first.`);
-	const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+	const installed = await findPackage(root, importName);
+	if (!installed) throw new Error(`${importName} isn't installed in ${root}. Install it with the project's package manager first.`);
+	const { dir, manifest: pkg } = installed;
 	const name = pkg.name ?? importName;
 	const version = pkg.version ?? "0.0.0";
 	const preset = presets[name];
 	const notes = [...preset?.notes ?? []];
 	const iconImport = preset?.icons?.import;
 	const componentImport = iconImport ?? preset?.components;
-	const entry = typesEntry(dir, pkg, componentImport ? subpath(componentImport, name) : ".");
+	const entry = packageEntry(installed, "types", componentImport ? splitSpecifier(componentImport).subpath : ".")?.replaceAll("\\", "/");
 	if (!entry) notes.push("No type declarations were found, so no components could be read.");
 	const scan = entry ? findComponents({
 		entries: [entry],
@@ -4651,8 +4854,9 @@ async function describePackage(options, importName) {
 	const dataIcons = preset?.icons?.render !== void 0 && preset.icons.render !== "export";
 	const isIcons = preset?.icons !== void 0 || looksLikeIcons(scan);
 	const tokens = /* @__PURE__ */ new Map();
-	const styles = preset?.styles ?? stylesheetOf(dir, pkg);
-	if (styles) for (const token of cssTokens(await readStylesheet(exportedFile(dir, pkg, styles)))) tokens.set(token.var, token);
+	const styles = preset?.styles ?? packageStylesheet(installed);
+	const stylesheet = styles && packageEntry(installed, "style", styles);
+	if (stylesheet) for (const token of cssTokens(await readStylesheet(stylesheet))) tokens.set(token.var, token);
 	let breakpoints;
 	if (preset?.theme) try {
 		const theme = await preset.theme(loader(root, dir));
@@ -4700,7 +4904,7 @@ async function describePackage(options, importName) {
 		if (preset?.icons?.variants) icons.variants = preset.icons.variants;
 		if (!dataIcons) {
 			const load = loader(root, dir);
-			const modules = await styleModules(name, typeof pkg.exports === "object" && pkg.exports !== null ? Object.keys(pkg.exports) : [], iconImport ?? name, load, await iconDrawer(load));
+			const modules = await styleModules(name, typeof pkg.exports === "object" && pkg.exports !== null && !Array.isArray(pkg.exports) ? Object.keys(pkg.exports) : [], iconImport ?? name, load, await iconDrawer(load));
 			if (modules) {
 				const main = Object.keys(modules).find((style) => modules[style] === (iconImport ?? name));
 				icons.variants = {
@@ -4841,7 +5045,7 @@ async function reviseLibrary(generated, options) {
 	const edits = options.edits ?? kept;
 	if (edits !== void 0) {
 		manifest.edits = edits;
-		const resolved = parseLibraryEdits(typeof edits === "string" ? parseJsonc(await readFile(resolve(options.editsBase ?? options.root, edits), "utf8")) : edits);
+		const resolved = await readLibraryEdits(edits, resolve(options.editsBase ?? options.root));
 		const { orphans } = applyLibraryEdits(parseLibraryManifest(manifest), resolved);
 		if (orphans.length > 0) report.orphanEdits = orphans;
 	}
@@ -4931,7 +5135,7 @@ function summarizeParts(relations) {
 const appExtensions = [".tsx", ".jsx"];
 async function describeApp(options) {
 	const root = resolve(options.root);
-	const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	const pkg = (await readPackage(root))?.manifest ?? {};
 	const notes = [];
 	const tsconfig = readTsconfig(root);
 	const { files } = await appFiles(root, { componentExtensions: appExtensions }, tsconfig);
@@ -4988,8 +5192,8 @@ async function describeApp(options) {
 async function appManifestPath(root) {
 	const existing = (await readdir(root)).find((file) => file.endsWith(libraryManifestExtension));
 	if (existing) return join(root, existing);
-	const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
-	return join(root, `${(pkg.name ?? basename(root)).replace(/^@[^/]+\//, "")}${libraryManifestExtension}`);
+	const name = (await readPackage(root))?.manifest.name ?? basename(root);
+	return join(root, `${name.replace(/^@[^/]+\//, "")}${libraryManifestExtension}`);
 }
 /**
 * A generated manifest laid over the file already there: what generating finds replaces what it found before, and
@@ -5050,56 +5254,6 @@ function defaultRange(version) {
 	const [major = "0", minor = "0"] = version.split(/[.-]/);
 	return major === "0" ? `^0.${minor}.0` : `^${major}.0.0`;
 }
-function subpath(specifier, packageName) {
-	return specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
-}
-/** The type declarations for one of a package's entry points, from `exports`, else `types`, else `index.d.ts`. */
-function typesEntry(dir, pkg, entry) {
-	const exported = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
-	const condition = (value) => {
-		if (typeof value === "string") return /\.d\.[cm]?ts$/.test(value) ? value : void 0;
-		if (typeof value !== "object" || value === null) return void 0;
-		const record = value;
-		for (const key of [
-			"types",
-			"import",
-			"default",
-			"require"
-		]) {
-			const found = condition(record[key]);
-			if (found) return found;
-		}
-	};
-	const candidates = [
-		condition(exported[entry]),
-		entry === "." ? pkg.types ?? pkg.typings : void 0,
-		entry === "." ? "index.d.ts" : `${entry.slice(2)}/index.d.ts`,
-		entry === "." ? void 0 : `${entry.slice(2)}.d.ts`
-	];
-	for (const candidate of candidates) if (candidate && existsSync(join(dir, candidate))) return join(dir, candidate).replaceAll("\\", "/");
-}
-/** The stylesheet a project imports to use a package: its `style` field, else the CSS its `exports` list first. */
-function stylesheetOf(dir, pkg) {
-	if (pkg.style && existsSync(join(dir, pkg.style))) return pkg.style;
-	const css = (typeof pkg.exports === "object" && pkg.exports !== null ? Object.keys(pkg.exports) : []).filter((key) => key.endsWith(".css")).map((key) => key.slice(2));
-	const pick = [
-		"tailwind.css",
-		"styles.css",
-		"style.css",
-		"index.css",
-		"theme.css"
-	].find((name) => css.includes(name)) ?? css[0];
-	if (!pick) return void 0;
-	const target = pkg.exports[`./${pick}`];
-	const file = typeof target === "string" ? target : target?.default;
-	return typeof file === "string" && existsSync(join(dir, file)) ? pick : void 0;
-}
-/** The file an export such as `tailwind.css` points at: `dist/tailwind.css` for Buildkit's styles. */
-function exportedFile(dir, pkg, specifier) {
-	const target = (typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {})[`./${specifier}`];
-	const file = typeof target === "string" ? target : target?.default;
-	return join(dir, typeof file === "string" ? file : specifier);
-}
 /** A DTCG token file the package ships, if it has one in the format; Buildkit's `tokens.json` isn't yet. */
 async function dtcgIn(dir) {
 	for (const candidate of [
@@ -5230,25 +5384,8 @@ function resolveRequire(from, specifier) {
 }
 /** An ESM-only package's entry, from the `import` condition of its `exports`, which `require` can't see. */
 async function resolveImport(from, specifier) {
-	const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-	const dir = await installedPackage(from, name);
-	if (!dir) return void 0;
-	const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
-	const exported = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
-	const pick = (value) => {
-		if (typeof value === "string") return /\.d\.[cm]?ts$/.test(value) ? void 0 : value;
-		if (typeof value !== "object" || value === null) return void 0;
-		const record = value;
-		for (const key of [
-			"node",
-			"import",
-			"default"
-		]) {
-			const found = pick(record[key]);
-			if (found) return found;
-		}
-	};
-	const file = pick(exported[subpath(specifier, name)]) ?? (specifier === name ? pkg.module : void 0);
-	return file ? join(dir, file) : void 0;
+	const { name, subpath } = splitSpecifier(specifier);
+	const installed = await findPackage(from, name);
+	return installed && packageEntry(installed, "runtime", subpath);
 }
 export { appManifestPath, generateLibrary, manifestText, mergeManifest, parseLibraryEdits, reviseLibrary, iconVariants as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity-app/cli",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "license": "MIT",
   "type": "module",
   "description": "Drive the Parity app from a terminal or an agent: read state, run edits, take screenshots, serve MCP.",

package/skills/SKILL.md

@@ -27,22 +27,22 @@ The same tools are MCP tools and `parity` commands in a terminal. They act on a
 the active tab of the Parity window they used last. When the person says "this" or "what I've selected" without naming a
 project, pass `tab: "active"` (`--tab active`) and read `get_app_state` for the selection.
 
-| MCP                   | CLI                          | What it does                                                                                                                                               |
-| --------------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `get_app_state`       | `parity state`               | Designs, the selection, modes, components and token names, and what Parity detected (builder and config, package manager, installed versions). Start here. |
-| `get_status`          | `parity status`              | The revision, whether anything is unsaved and which files and tokens, the last save, and undo and redo; `summary` names them.                              |
-| `get_modes`           | `parity modes [design]`      | Viewports (the ids `Responsive` takes), modes (the ids renders take) and what each design shows; a design adds its frames.                                 |
-| `execute`             | `parity exec`                | Runs a JavaScript snippet against the designs. Its changes land as one undo step, merged per design with edits made meanwhile.                             |
-| `screenshot`          | `parity screenshot <design>` | Renders a design in its states and modes, offscreen, and returns the images.                                                                               |
-| `find_problems`       | `parity problems <design>`   | Render errors, overflow, clipping and unknown components, per frame.                                                                                       |
-| `check_accessibility` | `parity a11y <design>`       | axe-core against WCAG 2.2 AA, per frame, on the layers that break each rule.                                                                               |
-| `get_console`         | `parity console`             | What the project's own code wrote to the console, on the canvas and offscreen.                                                                             |
-| `get_tokens`          | `parity tokens`              | Tokens filtered by category, source or name, with values in every theme.                                                                                   |
-| `get_components`      | `parity components`          | Components, libraries, icon sets and exports left out or failing to render.                                                                                |
-| `get_props`           | `parity props <Component>`   | Props from source, then what it goes inside and holds, its slots and an example to insert; `all` adds passed-through attributes.                           |
-| `get_tabs`            | `parity tabs`                | The open projects.                                                                                                                                         |
-| `open_project`        | `parity open <folder>`       | Opens a project in a new tab.                                                                                                                              |
-| `read_skill`          | `parity skill [file]`        | This skill.                                                                                                                                                |
+| MCP                   | CLI                          | What it does                                                                                                                                                                        |
+| --------------------- | ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `get_app_state`       | `parity state`               | Designs, the selection, modes (the primary one marked), components and token names, and what Parity detected (builder and config, package manager, installed versions). Start here. |
+| `get_status`          | `parity status`              | The revision, whether anything is unsaved and which files and tokens, the last save, and undo and redo; `summary` names them.                                                       |
+| `get_modes`           | `parity modes [design]`      | Viewports (the ids `Responsive` takes), modes (the ids renders take) and what each design shows; a design adds its frames.                                                          |
+| `execute`             | `parity exec`                | Runs a JavaScript snippet against the designs. Its changes land as one undo step, merged per design with edits made meanwhile.                                                      |
+| `screenshot`          | `parity screenshot <design>` | Renders a design in its states and modes, offscreen, and returns the images.                                                                                                        |
+| `find_problems`       | `parity problems <design>`   | Render errors, overflow, clipping and unknown components, per frame.                                                                                                                |
+| `check_accessibility` | `parity a11y <design>`       | axe-core against WCAG 2.2 AA, per frame, on the layers that break each rule.                                                                                                        |
+| `get_console`         | `parity console`             | What the project's own code wrote to the console, on the canvas and offscreen.                                                                                                      |
+| `get_tokens`          | `parity tokens`              | Tokens filtered by category, source or name, with values in every theme.                                                                                                            |
+| `get_components`      | `parity components`          | Components, libraries, icon sets and exports left out or failing to render.                                                                                                         |
+| `get_props`           | `parity props <Component>`   | Props from source, then what it goes inside and holds, its slots and an example to insert; `all` adds passed-through attributes.                                                    |
+| `get_tabs`            | `parity tabs`                | The open projects.                                                                                                                                                                  |
+| `open_project`        | `parity open <folder>`       | Opens a project in a new tab.                                                                                                                                                       |
+| `read_skill`          | `parity skill [file]`        | This skill.                                                                                                                                                                         |
 
 The token, component and prop tools read what designs can use without writing a snippet in either transport.
 `parity components` also says which of the app's exports aren't components and why, which components fail to draw on the