@parity-app/cli 0.6.1 → 0.6.3

package/dist/{src-Zm_PYFFH.mjs → src-C5-HaJcA.mjs}

@@ -1,13 +1,15 @@
-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-C4faIpux.mjs";
-import "./src-5CrSA_RX.mjs";
+import { a as plainObject, i as parseData, n as jsonText, t as finiteNumber } from "./schema-CiVy9tZT.mjs";
+import { D 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-YQY8r4mh.mjs";
+import { r as readLibraryEdits, s as parseJsonc } from "./src-DzU4U2rh.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";
 import ts from "typescript";
 import "semver";
@@ -526,28 +528,182 @@ 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();
+const colorSpace = z.enum([
+	"srgb",
+	"srgb-linear",
+	"hsl",
+	"hwb",
+	"lab",
+	"lch",
+	"oklab",
+	"oklch",
+	"display-p3",
+	"a98-rgb",
+	"prophoto-rgb",
+	"rec2020",
+	"xyz-d65",
+	"xyz-d50"
+]);
+const colorObject = z.object({
+	colorSpace,
+	components: z.array(z.union([finiteNumber, z.literal("none")])).length(3, "expected 3 components"),
+	alpha: finiteNumber.min(0).max(1).optional(),
+	hex: z.string().regex(/^#[\da-f]{6}$/i, "expected a 6-digit hex color such as #0a0a0a").optional()
+});
+const color = z.union([css, colorObject]);
+const dimensionObject = z.object({
+	value: finiteNumber,
+	unit: z.string().regex(/^([a-z]+|%)$/i, "expected a unit such as px or rem")
+});
+const dimension = z.union([css, dimensionObject]);
+const duration = z.union([css, z.object({
+	value: finiteNumber,
+	unit: z.enum(["ms", "s"])
+})]);
+/** A cubic Bézier's x coordinates, which CSS keeps between 0 and 1. */
+const unitInterval = finiteNumber.min(0).max(1);
+const cubicBezier = z.union([css, z.tuple([
+	unitInterval,
+	finiteNumber,
+	unitInterval,
+	finiteNumber
+])]);
+const fontFamily = z.union([css, z.array(z.string()).min(1)]);
+const fontWeight = z.union([css, finiteNumber.min(1).max(1e3)]);
+const number = z.union([css, finiteNumber]);
+const strokeStyle = z.union([css, z.object({
+	dashArray: z.array(dimension).min(1),
+	lineCap: z.enum([
+		"round",
+		"butt",
+		"square"
+	])
+})]);
+const border = z.union([css, z.object({
+	color,
+	width: dimension,
+	style: strokeStyle
+})]);
+const transition = z.union([css, z.object({
+	duration,
+	delay: duration,
+	timingFunction: cubicBezier
+})]);
+const shadowLayer = z.object({
+	color,
+	offsetX: dimension.default("0"),
+	offsetY: dimension.default("0"),
+	blur: dimension.default("0"),
+	spread: dimension.default("0"),
+	inset: z.boolean().default(false)
+});
+const shadow = z.union([
+	css,
+	shadowLayer,
+	z.array(z.union([css, shadowLayer])).min(1)
+]);
+const gradient = z.union([css, z.array(z.object({
+	color,
+	position: finiteNumber
+})).min(1)]);
+const typography = z.union([css, z.object({
+	fontFamily,
+	fontSize: dimension,
+	fontWeight: fontWeight.default("normal"),
+	letterSpacing: dimension.optional(),
+	lineHeight: z.union([number, dimensionObject]).optional()
+})]);
+border.transform(borderCss), color.transform(colorCss), cubicBezier.transform(cubicBezierCss), dimension.transform(dimensionCss), duration.transform(dimensionCss), fontFamily.transform(fontFamilyCss), fontWeight.transform(String), gradient.transform(gradientCss), number.transform(String), shadow.transform(shadowCss), strokeStyle.transform(strokeStyleCss), transition.transform(transitionCss), typography.transform(typographyCss);
+const colorFunctions = /* @__PURE__ */ new Set([
+	"hsl",
+	"hwb",
+	"lab",
+	"lch",
+	"oklab",
+	"oklch"
+]);
+function colorCss(value) {
+	if (typeof value === "string") return value;
+	const alpha = value.alpha !== void 0 && value.alpha < 1 ? value.alpha : void 0;
+	if (value.hex && alpha === void 0) return value.hex;
+	const slash = alpha === void 0 ? "" : ` / ${alpha}`;
+	if (value.colorSpace === "srgb") {
+		const [r, g, b] = value.components.map((part) => part === "none" ? part : Math.round(part * 255));
+		return `rgb(${r} ${g} ${b}${slash})`;
+	}
+	const components = value.components.join(" ");
+	if (colorFunctions.has(value.colorSpace)) return `${value.colorSpace}(${components}${slash})`;
+	return `color(${value.colorSpace} ${components}${slash})`;
+}
+function dimensionCss(value) {
+	return typeof value === "string" ? value : `${value.value}${value.unit}`;
+}
+function cubicBezierCss(value) {
+	return typeof value === "string" ? value : `cubic-bezier(${value.join(", ")})`;
+}
+function fontFamilyCss(value) {
+	return typeof value === "string" ? value : value.map(fontName).join(", ");
+}
+function fontName(name) {
+	return /^[\w-]+$/.test(name) ? name : `"${name}"`;
+}
+/** A stroke style as CSS: a border can't draw a dash pattern, so one is written as dashed. */
+function strokeStyleCss(value) {
+	return typeof value === "string" ? value : "dashed";
+}
+function borderCss(value) {
+	if (typeof value === "string") return value;
+	return `${dimensionCss(value.width)} ${strokeStyleCss(value.style)} ${colorCss(value.color)}`;
+}
+function transitionCss(value) {
+	if (typeof value === "string") return value;
+	return `${dimensionCss(value.duration)} ${cubicBezierCss(value.timingFunction)} ${dimensionCss(value.delay)}`;
+}
+function shadowCss(value) {
+	if (typeof value === "string") return value;
+	return (Array.isArray(value) ? value : [value]).map((layer) => typeof layer === "string" ? layer : shadowLayerCss(layer)).join(", ");
+}
+function shadowLayerCss(layer) {
+	const lengths = [
+		layer.offsetX,
+		layer.offsetY,
+		layer.blur,
+		layer.spread
+	].map(dimensionCss).join(" ");
+	return `${layer.inset ? "inset " : ""}${lengths} ${colorCss(layer.color)}`;
+}
+function gradientCss(value) {
+	if (typeof value === "string") return value;
+	return `linear-gradient(${value.map((stop) => `${colorCss(stop.color)} ${Math.round(stop.position * 1e3) / 10}%`).join(", ")})`;
+}
+function typographyCss(value) {
+	if (typeof value === "string") return value;
+	const { lineHeight } = value;
+	const line = lineHeight === void 0 ? "" : `/${typeof lineHeight === "object" ? dimensionCss(lineHeight) : lineHeight}`;
+	return `${value.fontWeight} ${dimensionCss(value.fontSize)}${line} ${fontFamilyCss(value.fontFamily)}`;
+}
+// ../tokens/src/dtcg.ts
+/** Token groups, or `$ref`s to them in this file or another. */
+const tokenSources = z.array(plainObject);
+z.object({ sources: tokenSources });
+const resolverModifier = z.object({
+	contexts: z.record(z.string(), tokenSources).transform((contexts) => new Map(Object.entries(contexts))),
+	default: z.string().optional()
+});
+z.object({ $ref: z.string() });
+resolverModifier.extend({ name: z.string().optional() });
+z.object({
+	$type: z.string().optional(),
+	$description: z.string().optional(),
+	$extensions: z.object({ parity: z.object({
+		var: z.string().optional(),
+		category: z.string().optional(),
+		lineHeight: z.string().optional()
+	}).optional() }).optional()
+});
 // ../tokens/src/policy.ts
 /**
 * At-rules that don't pick a theme: a cascade layer only orders rules, and a feature check holds whatever the theme.
@@ -757,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
@@ -869,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;
 /**
@@ -3746,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/"]
@@ -4449,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],
@@ -4473,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));
@@ -4522,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 = {
@@ -4663,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;
 	}
@@ -4753,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);
@@ -4810,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
@@ -4872,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 [
@@ -5052,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 };