@parity-app/cli 0.6.2 → 0.6.3

package/dist/bin.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as CodedError, c as errorDetails, l as readErrorDetails, o as closest, s as errorCodes } from "./schema-zRNxotYl.mjs";
-import { a as describeExec, c as describeProps, f as setCaller, i as describeConsole, l as describeStatus, n as describeAccessibility, o as describeModes, p as mcpCallerName, r as describeComponents, s as describeProblems, t as call, u as describeTokens } from "./client-BUaE9b77.mjs";
+import { c as errorCodes, l as errorDetails, o as CodedError, s as closest, u as readErrorDetails } from "./schema-CiVy9tZT.mjs";
+import { a as describeExec, c as describeProps, f as setCaller, i as describeConsole, l as describeStatus, n as describeAccessibility, o as describeModes, p as mcpCallerName, r as describeComponents, s as describeProblems, t as call, u as describeTokens } from "./client-C4An81o9.mjs";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { dirname, join, normalize, relative, resolve, sep } from "node:path";
 import { parseArgs } from "node:util";
@@ -387,16 +387,11 @@ const executeOperation = {
 */
 async function runCheck(library, options) {
 	if (!library) throw new Error("parity lib check <library> [--tab t] [--mode m]");
-	const { applyLibraryEdits, componentNode, generateId, librarySource, parseLibraryEdits, withLibraryContext } = await import("./src-BgQ7gnXE.mjs");
-	const { registryDir, registryEntries } = await import("./src-CiqdFzei.mjs");
-	const entry = (await registryEntries()).find((item) => item.manifest.id === library);
+	const { componentNode, generateId, librarySource, withLibraryContext } = await import("./src-AKjejfTT.mjs");
+	const { newestEntries, registryDir } = await import("./src-B40wy5fK.mjs");
+	const entry = (await newestEntries()).find((item) => item.manifest.id === library);
 	if (!entry) throw new Error(`The registry has no library "${library}"`);
-	let manifest = entry.manifest;
-	if (manifest.edits) {
-		const edits = typeof manifest.edits === "string" ? parseLibraryEdits(JSON.parse(await readFile(join(dirname(entry.path), manifest.edits), "utf8"))) : manifest.edits;
-		manifest = applyLibraryEdits(manifest, edits).manifest;
-	}
-	const list = manifest.components?.list ?? {};
+	const list = entry.manifest.components?.list ?? {};
 	const names = Object.keys(list).filter((name) => list[name].visual !== false);
 	const id = (name) => `${library}/${name}`;
 	const sources = Object.fromEntries(Object.keys(list).map((name) => [id(name), {
@@ -516,8 +511,8 @@ function describeCheck(report) {
 * because it reads the project's files and its own copy of TypeScript.
 */
 async function runLib(packageName, options) {
-	const { appManifestPath, generateLibrary, manifestText, mergeManifest, reviseLibrary } = await import("./src-BvKhu6dX.mjs");
-	const { covers, registryDir, registryEntries } = await import("./src-CiqdFzei.mjs");
+	const { appManifestPath, generateLibrary, manifestText, mergeManifest, reviseLibrary } = await import("./src-C5-HaJcA.mjs");
+	const { covers, registryDir, registryEntries } = await import("./src-B40wy5fK.mjs");
 	const spec = packageName === void 0 ? void 0 : packageSpec(packageName);
 	let root = resolve(options.root ?? ".");
 	if (spec && (spec.version !== void 0 || options.registry && !options.root)) {
@@ -528,7 +523,7 @@ async function runLib(packageName, options) {
 		console.error(`Installing ${spec.name} ${version} on its own…`);
 		root = await installedVersion(spec.name, version);
 	}
-	const { parseLibraryEdits } = await import("./src-BvKhu6dX.mjs");
+	const { parseLibraryEdits } = await import("./src-C5-HaJcA.mjs");
 	const trialEdits = options.edits ? parseLibraryEdits(JSON.parse(await readFile(resolve(options.edits), "utf8"))) : void 0;
 	const recordedId = options.registry && spec ? options.id ?? (await registryEntries()).find((entry) => entry.manifest.package?.name === spec.name)?.manifest.id : void 0;
 	const appErrors = recordedId ? await readAppErrors(registryDir(), recordedId) : void 0;

package/dist/{client-BUaE9b77.mjs → client-C4An81o9.mjs}

@@ -1,4 +1,4 @@
-import { a as CodedError, l as readErrorDetails, n as jsonText, r as nonBlankString, u as unknownReference } from "./schema-zRNxotYl.mjs";
+import { d as unknownReference, n as jsonText, o as CodedError, r as nonBlankString, u as readErrorDetails } from "./schema-CiVy9tZT.mjs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";

package/dist/index.mjs

@@ -1 +1 @@
-export { t as call, n as describeAccessibility, r as describeComponents, i as describeConsole, a as describeExec, o as describeModes, s as describeProblems, c as describeProps, l as describeStatus, u as describeTokens, d as registry, f as setCaller } from "./client-BUaE9b77.mjs";
+export { t as call, n as describeAccessibility, r as describeComponents, i as describeConsole, a as describeExec, o as describeModes, s as describeProblems, c as describeProps, l as describeStatus, u as describeTokens, d as registry, f as setCaller } from "./client-C4An81o9.mjs";

package/dist/schema-CiVy9tZT.mjs

@@ -0,0 +1,227 @@
+import { z } from "zod";
+// ../core/src/errors.ts
+/**
+* Why an agent's call failed, as a stable code it can act on without reading the message. The CLI and MCP publish
+* these; the app throws them where it knows the cause.
+*/
+const errorCodes = [
+	"invalid_input",
+	"not_running",
+	"not_answering",
+	"unknown_tab",
+	"tab_not_ready",
+	"unknown_design",
+	"unknown_node",
+	"ambiguous_reference",
+	"unknown_state",
+	"unknown_mode",
+	"unknown_viewport",
+	"unknown_component",
+	"unknown_icon_set",
+	"unknown_edit_id",
+	"conflict",
+	"execution_failed",
+	"app_error"
+];
+/** Details as another process sends them. Each field that's malformed falls back on its own; only the code must hold. */
+const errorDetailsSchema = z.object({
+	code: z.enum(errorCodes),
+	/** Whether sending the same request again, unchanged, can succeed. */
+	retryable: z.boolean().catch(false),
+	/** The request field at fault, as a path: `design`, `state`, `edits/0/find`. */
+	field: z.string().min(1).optional().catch(void 0),
+	/** Valid references to use instead of an unknown or ambiguous one, at most `alternativeLimit` of them. */
+	alternatives: z.array(z.unknown()).transform((items) => items.filter((item) => typeof item === "string").slice(0, 20)).optional().catch(void 0)
+});
+/** An error with a stable code, the field it's about and what to use instead. */
+var CodedError = class extends Error {
+	details;
+	constructor(message, details) {
+		super(message);
+		this.name = "CodedError";
+		this.details = {
+			...details,
+			retryable: details.retryable ?? false
+		};
+	}
+};
+/** An unknown reference, naming the valid ones closest to what was asked for, up to `alternativeLimit`. */
+function unknownReference(code, message, reference, candidates, field) {
+	return new CodedError(message, {
+		code,
+		...field === void 0 ? {} : { field },
+		alternatives: closest(reference, candidates)
+	});
+}
+/**
+* Candidates sharing text with the reference first, ignoring case, then the rest by how few single-character edits
+* away they are, so a typo's intended id makes the cut; ties keep their own order. All of them when they fit.
+*/
+function closest(reference, candidates, limit = 20) {
+	const unique = [...new Set(candidates)];
+	if (unique.length <= limit) return unique;
+	const wanted = reference.toLowerCase();
+	const ranked = unique.map((candidate, index) => {
+		const lower = candidate.toLowerCase();
+		const near = wanted.length > 0 && (lower.includes(wanted) || wanted.includes(lower));
+		return {
+			candidate,
+			index,
+			near: near ? 0 : 1,
+			distance: near ? 0 : editDistance(wanted, lower)
+		};
+	});
+	ranked.sort((a, b) => a.near - b.near || a.distance - b.distance || a.index - b.index);
+	return ranked.slice(0, limit).map(({ candidate }) => candidate);
+}
+/** How many single-character insertions, deletions or substitutions turn one string into the other. */
+function editDistance(a, b) {
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i++) {
+		const row = [i];
+		for (let j = 1; j <= b.length; j++) row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		previous = row;
+	}
+	return previous[b.length];
+}
+/** A thrown value's details, when it carries them. */
+function errorDetails(error) {
+	return error instanceof CodedError ? error.details : void 0;
+}
+/** Details that came from another process, checked before they're trusted. Anything malformed reads as none. */
+function readErrorDetails(value) {
+	return errorDetailsSchema.safeParse(value).data;
+}
+// ../core/src/schema.ts
+/**
+* Checks for data Parity didn't make (PAR-578): files, agent input, environment variables, other programs' JSON. A zod
+* schema is both the check and the type. A failed check reads as core's hand-written ones in `validate.ts` do: a JSON
+* pointer to the value at fault, then what was expected there, as in `/containers/0/name: expected a string`.
+*/
+/** An object with string keys, and not an array or null. */
+const plainObject = z.record(z.string(), z.unknown());
+/** Text with something besides whitespace, trimmed. */
+const nonBlankString = z.string().trim().min(1, "can't be blank");
+/** A number other than NaN or ±Infinity, which zod 4 refuses on its own. */
+const finiteNumber = z.number();
+/** JSON text holding what `schema` checks. Text that isn't JSON fails as `expected JSON`. */
+function jsonText(schema) {
+	return z.string().transform((text, context) => {
+		try {
+			return JSON.parse(text);
+		} catch {
+			context.addIssue({
+				code: "custom",
+				message: "expected JSON"
+			});
+			return z.NEVER;
+		}
+	}).pipe(schema);
+}
+/**
+* Checks data Parity didn't make and returns what the schema reads from it, or throws `TypeError` with the first
+* problem as `/json/pointer: message`. `at` is where the value sits in a larger one, so its pointers start there.
+*/
+function parseData(schema, value, at = "") {
+	const result = schema.safeParse(value, { error: issueText });
+	if (result.success) return result.data;
+	const { pointer, message } = firstProblem(result.error.issues, at);
+	throw new TypeError(`${pointer || "/"}: ${message}`);
+}
+/** A path inside a value as a JSON pointer (RFC 6901): `/edits/0/find`, or `` for the value itself. */
+function jsonPointer(path) {
+	return path.map((key) => `/${String(key).replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+}
+/**
+* The problem to report from a failed check: its first issue. An unknown property points at that property. A union
+* that no option matched reports the option that came closest, or every type it takes when none got past the value's
+* type. An option for another type of value isn't close, so `{ size: "big" }` against a string or an object with a
+* numeric size reports the size, however many issues the object has.
+*/
+function firstProblem(issues, at) {
+	const [issue] = issues;
+	if (!issue) return {
+		pointer: at,
+		message: "isn't valid"
+	};
+	const pointer = at + jsonPointer(issue.path);
+	if (issue.code === "unrecognized_keys") return {
+		pointer: pointer + jsonPointer(issue.keys.slice(0, 1)),
+		message: issue.message
+	};
+	if (issue.code === "invalid_union" && issue.errors.length > 0) return unionProblem(issue.errors, pointer);
+	return {
+		pointer,
+		message: issue.message
+	};
+}
+function unionProblem(options, pointer) {
+	const issues = options.flat();
+	const shallow = issues.every((issue) => issue.path.length === 0);
+	const expected = issues.map(expectation);
+	if (shallow && expected.every((text) => text !== void 0)) return {
+		pointer,
+		message: `expected ${[...new Set(expected)].join(" or ")}`
+	};
+	const depth = (option) => option[0]?.path.length ?? 0;
+	const typed = options.filter((option) => !refusesType(option));
+	return firstProblem((typed.length > 0 ? typed : options).reduce((best, option) => option.length < best.length || option.length === best.length && depth(option) > depth(best) ? option : best), pointer);
+}
+/** Whether a union's option failed on the value's type itself, as a string option does for an object. */
+function refusesType(option) {
+	const [first] = option;
+	return first?.code === "invalid_type" && first.path.length === 0;
+}
+/** What one type or value check wanted, as `a string` or `"row"`; nothing for other checks. */
+function expectation(issue) {
+	if (issue.code === "invalid_type") return typeName(issue.expected);
+	if (issue.code === "invalid_value") return issue.values.map(literal).join(" or ");
+}
+/** Zod's issues in `validate.ts`'s words. Messages a schema gives itself win, and anything else keeps zod's own. */
+function issueText(issue) {
+	switch (issue.code) {
+		case "invalid_type": return `expected ${typeName(issue.expected)}`;
+		case "invalid_value": return issue.values.length === 1 ? `expected ${literal(issue.values[0])}` : `expected one of ${issue.values.map(literal).join(", ")}`;
+		case "unrecognized_keys": return "unknown property";
+		case "invalid_union": {
+			const options = "options" in issue ? issue.options : void 0;
+			return Array.isArray(options) && options.length > 0 ? `expected one of ${options.map(literal).join(", ")}` : void 0;
+		}
+		case "too_small": return bound("at least", "more than", issue.origin, issue.minimum, issue.inclusive);
+		case "too_big": return bound("at most", "less than", issue.origin, issue.maximum, issue.inclusive);
+		default: return;
+	}
+}
+const typeNames = {
+	array: "an array",
+	boolean: "true or false",
+	int: "a whole number",
+	number: "a number",
+	object: "an object",
+	record: "an object",
+	string: "a string",
+	tuple: "an array"
+};
+function typeName(expected) {
+	return typeNames[expected] ?? expected;
+}
+function literal(value) {
+	return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+const units = {
+	string: "character",
+	array: "item",
+	set: "item"
+};
+/** A size or range check's limit, as `expected at least 1 item` or `expected less than 10`. */
+function bound(inclusiveWords, exclusiveWords, origin, limit, inclusive = true) {
+	const words = inclusive ? inclusiveWords : exclusiveWords;
+	const unit = units[origin];
+	if (unit) return `expected ${words} ${limit} ${unit}${Number(limit) === 1 ? "" : "s"}`;
+	return [
+		"number",
+		"int",
+		"bigint"
+	].includes(origin) ? `expected ${words} ${limit}` : void 0;
+}
+export { plainObject as a, errorCodes as c, unknownReference as d, parseData as i, errorDetails as l, jsonText as n, CodedError as o, nonBlankString as r, closest as s, finiteNumber as t, readErrorDetails as u };

package/dist/src-AKjejfTT.mjs

@@ -0,0 +1,4 @@
+import "./schema-CiVy9tZT.mjs";
+export { t as componentNode, T as generateId, n as librarySource, i as withLibraryContext } from "./src-YQY8r4mh.mjs";
+import "./src-DzU4U2rh.mjs";
+import "./src-C5-HaJcA.mjs";

package/dist/src-B40wy5fK.mjs

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

package/dist/{src-BvKhu6dX.mjs → src-C5-HaJcA.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 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";
@@ -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/dist/src-DzU4U2rh.mjs

@@ -0,0 +1,129 @@
+import { a as applyLibraryEdits, f as parseLibraryEdits, p as parseLibraryManifest, u as libraryManifestExtension } from "./src-YQY8r4mh.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-V9wTMkxO.mjs → src-YQY8r4mh.mjs}

@@ -1,12 +1,34 @@
-import "./schema-zRNxotYl.mjs";
+import "./schema-CiVy9tZT.mjs";
 import { z } from "zod";
 // ../core/src/adapters.ts
 const packageVersions = z.record(z.string(), z.string());
-z.looseObject({
+const exportsTarget = z.lazy(() => z.union([
+	z.string(),
+	z.null(),
+	z.array(exportsTarget),
+	z.record(z.string(), exportsTarget)
+]));
+/**
+* The parts of a package.json Parity reads: the dependencies adapters detect a stack by, and where an installed
+* package's entry points and a workspace's packages are (PAR-573). It's someone else's file, so the fields Parity
+* doesn't read pass through unchecked.
+*/
+const packageManifest = z.looseObject({
 	name: z.string().optional(),
+	version: z.string().optional(),
 	dependencies: packageVersions.optional(),
 	devDependencies: packageVersions.optional(),
-	scripts: z.record(z.string(), z.string()).optional()
+	scripts: z.record(z.string(), z.string()).optional(),
+	/** Entry points by subpath (`.`, `./tailwind.css`), or where the package's one entry point leads. */
+	exports: exportsTarget.optional(),
+	types: z.string().optional(),
+	typings: z.string().optional(),
+	module: z.string().optional(),
+	main: z.string().optional(),
+	/** The stylesheet a project imports to use the package, as some packages name it. */
+	style: z.string().optional(),
+	/** A workspace root's package folders, as npm, Yarn and Bun write them. */
+	workspaces: z.union([z.array(z.string()), z.looseObject({ packages: z.array(z.string()).optional() })]).optional()
 });
 // ../core/src/devices.ts
 const deviceKinds = [
@@ -1341,7 +1363,8 @@ function expectStringRecord(value, path) {
 const named = /* @__PURE__ */ new WeakSet();
 /**
 * A new node for a component, ready to show something: required props get their default or first option, and a
-* component that takes children gets its own name as text, so it isn't an empty box, unless `given` has its own.
+* component that takes children gets its own name as text, so it isn't an empty box, unless `given` has its own or the
+* component sets its own size (`fixedSize`), where the name would be cut off ("Avata").
 */
 function componentNode(component, info, taken, given = {}) {
 	const props = { ...given };
@@ -1353,7 +1376,7 @@ function componentNode(component, info, taken, given = {}) {
 		else if (prop.kind === "number") props[prop.name] = 0;
 		else if (prop.kind === "string") props[prop.name] = prop.name;
 	}
-	const labelled = !("children" in given) && info?.props.some((prop) => prop.name === "children" && prop.kind === "node");
+	const labelled = !("children" in given) && !info?.fixedSize && info?.props.some((prop) => prop.name === "children" && prop.kind === "node");
 	if (labelled) props.children = component.split("/").at(-1) ?? component;
 	const node = {
 		type: "component",
@@ -1434,10 +1457,10 @@ function withLibraryContext(node, sources, around, taken) {
 		};
 	};
 	let placed = node;
-	const sample = source.sample;
+	const sample = source.sample ?? (named.has(node) ? usedIn(node.component, sources) : void 0);
 	if (sample) {
 		const given = { ...node.props };
-		if (sample.props && "children" in sample.props && named.has(node)) delete given.children;
+		if (named.has(node)) delete given.children;
 		const { props, slots } = held({
 			...sample.props,
 			...given
@@ -1514,6 +1537,39 @@ function withLibraryContext(node, sources, around, taken) {
 	}
 }
 /**
+* How a part with no sample of its own is used in its library's other samples: with the children the first use gives it,
+* or none when it's used without any (`<MarkerIcon />`) or with elements the sample can't show (an icon, `[]`).
+* Undefined when no sample uses it.
+*/
+function usedIn(component, sources) {
+	const find = (children) => {
+		for (const child of children ?? []) {
+			if (typeof child === "string") continue;
+			if (isSampleRender(child)) {
+				const found = find(child.$render);
+				if (found) return found;
+				continue;
+			}
+			if (child.component === component) return child;
+			const found = find(child.children) ?? find(elementProps(child.props));
+			if (found) return found;
+		}
+	};
+	const library = sources[component]?.library;
+	for (const source of Object.values(sources)) {
+		if (source.library !== library || !source.sample) continue;
+		const found = find(source.sample.children) ?? find(elementProps(source.sample.props));
+		if (found) return { children: found.children ?? [] };
+	}
+}
+/** The elements and render functions a sample gives as props' values, as children are. */
+function elementProps(props) {
+	return Object.values(props ?? {}).flatMap((value) => {
+		if (isSampleRender(value)) return [value];
+		return isSampleElement(value) ? value.$element : [];
+	});
+}
+/**
 * A library file's component as the canvas inserts it, with its parents and sample named by component id.
 * Discovery has already rewritten module imports for the name the project installed the package under.
 */
@@ -1564,4 +1620,4 @@ function sampleIds(sample, library) {
 		...sample.children ? { children: sample.children.map(child) } : {}
 	};
 }
-export { deviceKinds as A, parseCanvasDocument as C, collectCustomProperties as D, parseModeSettings as E, viewportHeightProperty as O, paramTypes as S, generateId as T, imageFits as _, applyLibraryEdits as a, linkEndKinds as b, isSampleElement as c, parentSignals as d, parseLibraryEdits as f, containerKinds as g, canvasObjectKinds as h, withLibraryContext as i, lengthToPixels as j, viewportWidthProperty as k, isSampleRender as l, renderSlotOf as m, librarySource as n, componentEvidence as o, parseLibraryManifest as p, sampleIds as r, isMadeValue as s, componentNode as t, libraryManifestExtension as u, lenses as v, styleKeys as w, linkTypes as x, linkAllowed as y };
+export { deviceKinds as A, parseCanvasDocument as C, collectCustomProperties as D, parseModeSettings as E, packageManifest as M, viewportHeightProperty as O, paramTypes as S, generateId as T, imageFits as _, applyLibraryEdits as a, linkEndKinds as b, isSampleElement as c, parentSignals as d, parseLibraryEdits as f, containerKinds as g, canvasObjectKinds as h, withLibraryContext as i, lengthToPixels as j, viewportWidthProperty as k, isSampleRender as l, renderSlotOf as m, librarySource as n, componentEvidence as o, parseLibraryManifest as p, sampleIds as r, isMadeValue as s, componentNode as t, libraryManifestExtension as u, lenses as v, styleKeys as w, linkTypes as x, linkAllowed as y };

package/package.json

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

package/dist/schema-zRNxotYl.mjs

@@ -1,121 +0,0 @@
-import { z } from "zod";
-// ../core/src/errors.ts
-/**
-* Why an agent's call failed, as a stable code it can act on without reading the message. The CLI and MCP publish
-* these; the app throws them where it knows the cause.
-*/
-const errorCodes = [
-	"invalid_input",
-	"not_running",
-	"not_answering",
-	"unknown_tab",
-	"tab_not_ready",
-	"unknown_design",
-	"unknown_node",
-	"ambiguous_reference",
-	"unknown_state",
-	"unknown_mode",
-	"unknown_viewport",
-	"unknown_component",
-	"unknown_icon_set",
-	"unknown_edit_id",
-	"conflict",
-	"execution_failed",
-	"app_error"
-];
-/** Details as another process sends them. Each field that's malformed falls back on its own; only the code must hold. */
-const errorDetailsSchema = z.object({
-	code: z.enum(errorCodes),
-	/** Whether sending the same request again, unchanged, can succeed. */
-	retryable: z.boolean().catch(false),
-	/** The request field at fault, as a path: `design`, `state`, `edits/0/find`. */
-	field: z.string().min(1).optional().catch(void 0),
-	/** Valid references to use instead of an unknown or ambiguous one, at most `alternativeLimit` of them. */
-	alternatives: z.array(z.unknown()).transform((items) => items.filter((item) => typeof item === "string").slice(0, 20)).optional().catch(void 0)
-});
-/** An error with a stable code, the field it's about and what to use instead. */
-var CodedError = class extends Error {
-	details;
-	constructor(message, details) {
-		super(message);
-		this.name = "CodedError";
-		this.details = {
-			...details,
-			retryable: details.retryable ?? false
-		};
-	}
-};
-/** An unknown reference, naming the valid ones closest to what was asked for, up to `alternativeLimit`. */
-function unknownReference(code, message, reference, candidates, field) {
-	return new CodedError(message, {
-		code,
-		...field === void 0 ? {} : { field },
-		alternatives: closest(reference, candidates)
-	});
-}
-/**
-* Candidates sharing text with the reference first, ignoring case, then the rest by how few single-character edits
-* away they are, so a typo's intended id makes the cut; ties keep their own order. All of them when they fit.
-*/
-function closest(reference, candidates, limit = 20) {
-	const unique = [...new Set(candidates)];
-	if (unique.length <= limit) return unique;
-	const wanted = reference.toLowerCase();
-	const ranked = unique.map((candidate, index) => {
-		const lower = candidate.toLowerCase();
-		const near = wanted.length > 0 && (lower.includes(wanted) || wanted.includes(lower));
-		return {
-			candidate,
-			index,
-			near: near ? 0 : 1,
-			distance: near ? 0 : editDistance(wanted, lower)
-		};
-	});
-	ranked.sort((a, b) => a.near - b.near || a.distance - b.distance || a.index - b.index);
-	return ranked.slice(0, limit).map(({ candidate }) => candidate);
-}
-/** How many single-character insertions, deletions or substitutions turn one string into the other. */
-function editDistance(a, b) {
-	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-	for (let i = 1; i <= a.length; i++) {
-		const row = [i];
-		for (let j = 1; j <= b.length; j++) row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-		previous = row;
-	}
-	return previous[b.length];
-}
-/** A thrown value's details, when it carries them. */
-function errorDetails(error) {
-	return error instanceof CodedError ? error.details : void 0;
-}
-/** Details that came from another process, checked before they're trusted. Anything malformed reads as none. */
-function readErrorDetails(value) {
-	return errorDetailsSchema.safeParse(value).data;
-}
-// ../core/src/schema.ts
-/**
-* Checks for data Parity didn't make (PAR-578): files, agent input, environment variables, other programs' JSON. A zod
-* schema is both the check and the type. A failed check reads as core's hand-written ones in `validate.ts` do: a JSON
-* pointer to the value at fault, then what was expected there, as in `/containers/0/name: expected a string`.
-*/
-/** An object with string keys, and not an array or null. */
-const plainObject = z.record(z.string(), z.unknown());
-/** Text with something besides whitespace, trimmed. */
-const nonBlankString = z.string().trim().min(1, "can't be blank");
-/** A number other than NaN or ±Infinity, which zod 4 refuses on its own. */
-const finiteNumber = z.number();
-/** JSON text holding what `schema` checks. Text that isn't JSON fails as `expected JSON`. */
-function jsonText(schema) {
-	return z.string().transform((text, context) => {
-		try {
-			return JSON.parse(text);
-		} catch {
-			context.addIssue({
-				code: "custom",
-				message: "expected JSON"
-			});
-			return z.NEVER;
-		}
-	}).pipe(schema);
-}
-export { CodedError as a, errorDetails as c, plainObject as i, readErrorDetails as l, jsonText as n, closest as o, nonBlankString as r, errorCodes as s, finiteNumber as t, unknownReference as u };

package/dist/src-BIVDlIGc.mjs

@@ -1,53 +0,0 @@
-import { p as parseLibraryManifest, u as libraryManifestExtension } from "./src-V9wTMkxO.mjs";
-import { createRequire } from "node:module";
-import { readFile, readdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { existsSync } from "node:fs";
-import semver from "semver";
-// ../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}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	return entries;
-}
-/** 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 });
-}
-export { registryDir as n, registryEntries as r, covers as t };

package/dist/src-BgQ7gnXE.mjs

@@ -1,3 +0,0 @@
-import "./schema-zRNxotYl.mjs";
-export { a as applyLibraryEdits, t as componentNode, T as generateId, n as librarySource, f as parseLibraryEdits, i as withLibraryContext } from "./src-V9wTMkxO.mjs";
-import "./src-BvKhu6dX.mjs";

package/dist/src-CiqdFzei.mjs

@@ -1 +0,0 @@
-export { t as covers, n as registryDir, r as registryEntries } from "./src-BIVDlIGc.mjs";