@parity-app/cli 0.7.4 → 0.7.6

package/dist/bin.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { c as CodedError, d as errorDetails, f as readErrorDetails, i as jsonText, l as closest, s as plainObject, t as checkData, u as errorCodes } from "./schema-CemdtCeF.mjs";
-import { _ as requests, a as describeExec, c as describeProps, f as setCaller, g as requestJsonSchema, h as replies, i as describeConsole, l as describeStatus, m as readRequest, n as describeAccessibility, o as describeModes, p as mcpCallerName, r as describeComponents, s as describeProblems, t as call, u as describeTokens, v as skillRequest } from "./client-D6bpjpy-.mjs";
+import { c as CodedError, d as errorDetails, f as readErrorDetails, i as jsonText, l as closest, s as plainObject, t as checkData, u as errorCodes } from "./schema-Dp5Jhloe.mjs";
+import { _ as requests, a as describeExec, c as describeProps, f as setCaller, g as requestJsonSchema, h as replies, i as describeConsole, l as describeStatus, m as readRequest, n as describeAccessibility, o as describeModes, p as mcpCallerName, r as describeComponents, s as describeProblems, t as call, u as describeTokens, v as skillRequest } from "./client-BkLeG26A.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";
@@ -160,8 +160,8 @@ const appErrorsFile = jsonText(z.record(z.string(), z.string()));
 */
 async function runCheck(library, options) {
 	if (!library) throw new Error("parity lib check <library> [--tab t] [--mode m]");
-	const { componentNode, generateId, librarySource, withLibraryContext } = await import("./src-Btr2eWdT.mjs");
-	const { newestEntries, registryDir } = await import("./src-Q382DbAK.mjs");
+	const { componentNode, generateId, librarySource, withLibraryContext } = await import("./src-CbLrA8BA.mjs");
+	const { newestEntries, registryDir } = await import("./src-DHuMBGiB.mjs");
 	const entry = (await newestEntries()).find((item) => item.manifest.id === library);
 	if (!entry) throw new Error(`The registry has no library "${library}"`);
 	const list = entry.manifest.components?.list ?? {};
@@ -295,8 +295,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-Bf12xdm5.mjs");
-	const { covers, registryDir, registryEntries } = await import("./src-Q382DbAK.mjs");
+	const { appManifestPath, generateLibrary, manifestText, mergeManifest, reviseLibrary } = await import("./src-CMPL5C8p.mjs");
+	const { covers, registryDir, registryEntries } = await import("./src-DHuMBGiB.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)) {
@@ -307,7 +307,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-Bf12xdm5.mjs");
+	const { parseLibraryEdits } = await import("./src-CMPL5C8p.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-D6bpjpy-.mjs → client-BkLeG26A.mjs}

@@ -1,4 +1,4 @@
-import { a as nonBlankString, c as CodedError, f as readErrorDetails, i as jsonText, p as unknownReference, s as plainObject, t as checkData } from "./schema-CemdtCeF.mjs";
+import { a as nonBlankString, c as CodedError, f as readErrorDetails, i as jsonText, p as unknownReference, s as plainObject, t as checkData } from "./schema-Dp5Jhloe.mjs";
 import { join } from "node:path";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";

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-D6bpjpy-.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-BkLeG26A.mjs";

package/dist/{schema-CemdtCeF.mjs → schema-Dp5Jhloe.mjs}

@@ -95,7 +95,7 @@ function readErrorDetails(value) {
 // ../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
+* schema is both the check and the type. A failed check reads as core's hand-written ones in `validate.ts` did: 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. */
@@ -204,7 +204,7 @@ 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. */
+/** Zod's issues in the words of core's old `validate.ts`. 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)}`;

package/dist/{src-DjSCuWcT.mjs → src-BZFjMWhp.mjs}

@@ -1,4 +1,4 @@
-import { n as fileObject, o as parseData, r as finiteNumber, s as plainObject } from "./schema-CemdtCeF.mjs";
+import { n as fileObject, o as parseData, r as finiteNumber, s as plainObject } from "./schema-Dp5Jhloe.mjs";
 import { z } from "zod";
 // ../core/src/adapters.ts
 const packageVersions = z.record(z.string(), z.string());
@@ -341,6 +341,7 @@ const detectionCorrections = fileObject({
 	include: z.array(componentRef).optional(),
 	exclude: z.unknown().optional()
 }).transform(({ exclude: _dropped, ...corrections }) => corrections);
+/** Text on the canvas outside any design, as a project file or the clipboard holds it. */
 const noteSpec = fileObject({
 	id: z.string(),
 	text: z.string(),
@@ -535,6 +536,7 @@ const imageFits = [
 	"contain",
 	"fill"
 ];
+/** Who made a stock image and where it came from, as an image node or a dragged image holds it. */
 const imageCredit = fileObject({
 	name: z.string(),
 	url: z.string(),
@@ -652,6 +654,7 @@ const stateSpec = fileObject({
 	*/
 	overrides: nodePatches.optional()
 });
+/** One design, as a project file or the clipboard holds it (see `ContainerSpec`). */
 const containerSpec = fileObject({
 	id: z.string(),
 	name: z.string(),
@@ -750,42 +753,22 @@ const canvasDocument = fileObject({
 	/** The source each lens reads, where the person switched from the one Parity picked. */
 	sources: lensSources.optional()
 });
-/** Reads a project file, or throws `TypeError` with the first problem as `/json/pointer: message`. */
-function parseCanvasDocument(value) {
-	return parseData(canvasDocument, value);
-}
-// ../core/src/validate.ts
-function expectObject(value, path) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${path || "/"}: expected an object`);
-	return value;
-}
-function expectString(value, path) {
-	if (typeof value !== "string") throw new TypeError(`${path}: expected a string`);
-	return value;
-}
-function expectNumber(value, path) {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${path}: expected a number`);
-	return value;
-}
-function expectArray(value, path) {
-	if (!Array.isArray(value)) throw new TypeError(`${path}: expected an array`);
-	return value;
-}
-function expectOneOf(value, options, path) {
-	if (typeof value !== "string" || !options.includes(value)) throw new TypeError(`${path}: expected one of ${options.map((option) => `"${option}"`).join(", ")}`);
-	return value;
-}
-function optional(value, parse) {
-	return value === void 0 ? void 0 : parse(value);
-}
-/** Drops `undefined` entries, so parsed patches can be spread over defaults without erasing them. */
-function compact(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-function expectKnownKeys(value, keys, path) {
-	for (const key of Object.keys(value)) if (!keys.includes(key)) throw new TypeError(`${path}/${key}: unknown property`);
-}
 // ../core/src/library.ts
+const libraryBreakpoint = fileObject({
+	id: z.string(),
+	name: z.string(),
+	/** The width where it starts, in CSS pixels. */
+	width: finiteNumber
+});
+/** The package a manifest describes. */
+const libraryPackage = fileObject({
+	/** Its name on npm, as in `@mui/material`. */
+	name: z.string(),
+	/** The version it was generated from. */
+	version: z.string().optional(),
+	/** The versions it describes, as a semver range such as `^9.0.0`. Unset means any. */
+	range: z.string().optional()
+});
 /** How a component was recognised, which is also why it's believed to be one. */
 const componentEvidence = [
 	"function",
@@ -809,6 +792,41 @@ const parentSignals = [
 	"edit",
 	"app"
 ];
+/**
+* A function returning these children. With `spread`, the object it's called with is spread onto the one element it
+* returns, as MUI's `renderInput={(params) => <TextField {...params} />}`; `pass` names props of that element that take
+* it whole, as React Aria's `{(segment) => <DateSegment segment={segment} />}`.
+*/
+const sampleRender = fileObject({
+	get $render() {
+		return z.array(sampleChild);
+	},
+	spread: z.literal(true).optional(),
+	pass: z.array(z.string()).optional()
+});
+/** A component of the same library, by its name in `components.list`, with its props and children. */
+const sampleComponent = fileObject({
+	component: z.string(),
+	props: plainObject.optional(),
+	get children() {
+		return z.array(sampleChild).optional();
+	}
+});
+/**
+* Text, a component of the same library by its name in `components.list`, or a render function: what a part calls to
+* draw, as children (`Field.Validity`) or as a prop's value (`renderInput`).
+*/
+const sampleChild = z.union([
+	z.string(),
+	sampleRender,
+	sampleComponent
+]);
+z.object({ $element: z.array(sampleChild) });
+/** What a component needs to draw something: props with sample values, and children, as for a collection's items. */
+const componentSample = fileObject({
+	props: plainObject.optional(),
+	children: z.array(sampleChild).optional()
+});
 /** Whether a sample's prop value is elements. */
 function isSampleElement(value) {
 	return typeof value === "object" && value !== null && Array.isArray(value.$element);
@@ -838,204 +856,316 @@ function renderSlotOf(sample) {
 		render: entry[1]
 	} : void 0;
 }
-const decoratorKeys = [
-	"when",
+/** A regular expression's source, checked by compiling it. */
+const pattern = z.string().refine((source) => {
+	try {
+		new RegExp(source);
+		return true;
+	} catch {
+		return false;
+	}
+}, "expected a regular expression");
+const flag = z.boolean("expected a boolean");
+/** What a component says about itself that a hand edit can change too. */
+const componentFields = {
+	/** The type declarations that define it, relative to the package, for reading its props. */
+	declaration: z.string().optional(),
+	/** The family it belongs to in the Components panel, as Card, CardHeader and CardTitle share `Card`. */
+	group: z.string().optional(),
+	/**
+	* The components a part is placed inside, outermost first, as `["Accordion", "AccordionItem"]` for
+	* `AccordionTrigger`, and what said so.
+	*/
+	parents: z.array(z.string()).optional(),
+	parentsFrom: z.enum(parentSignals).optional(),
+	/**
+	* Parents most examples show but it renders without (`DropdownMenuGroup`), a subset of `parents`: inserting it
+	* where the parents outside them are already leaves them out.
+	*/
+	optionalParents: z.array(z.string()).optional(),
+	/**
+	* `true` when its parents need the other parts their samples hold around it to draw (a table's header beside the
+	* body a row is in): inserting it alone puts it in its outermost parent's whole sample, in place of the first like it.
+	*/
+	parentParts: flag.optional(),
+	/** `false` for exports that draw nothing of their own, such as a context's consumer or a `RootProvider`. */
+	visual: flag.optional(),
+	/**
+	* `true` for a part the package renders inside its own components and that no example or docs page places
+	* (`ChartStyle` in `ChartContainer`, a Select's scroll buttons). It can still be placed; the Components panel lists
+	* it apart.
+	*/
+	internal: flag.optional(),
+	/** What it needs to draw something: props with sample values, and children, as for a collection's items. */
+	sample: componentSample.optional()
+};
+const libraryComponent = fileObject({
+	as: z.enum(componentEvidence),
+	...componentFields,
+	/** A hash of what it was found as and its own props, to tell what changed when the file is regenerated. */
+	fingerprint: z.string().optional(),
+	/** Its own props (not the HTML attributes it passes on), each with a hash of its type; `?` marks an optional one. */
+	props: z.record(z.string(), z.string()).optional()
+});
+const libraryComponentEdit = fileObject({
+	as: z.enum(componentEvidence).optional(),
+	...componentFields
+});
+const libraryComponents = fileObject({
+	/** The module components are imported from. Defaults to the package name. */
+	import: z.string().optional(),
+	/**
+	* Components by the name they're imported by: an export, or `Namespace.Member` for libraries that group a
+	* component's parts, as Base UI's `Dialog.Root` does.
+	*/
+	list: z.record(z.string(), libraryComponent)
+});
+/** One React component that draws an icon given as data, as Hugeicons' `HugeiconsIcon` does with its `icon` prop. */
+const iconRenderer = fileObject({
+	import: z.string(),
+	component: z.string(),
+	prop: z.string()
+});
+const iconVariants = fileObject({
+	/**
+	* Splits an export name into named groups: `name`, and optionally `size` and `style`, for sets that write them into
+	* names (Fluent's `Add24Regular`). A name without a style has the default style.
+	*/
+	pattern: pattern.optional(),
+	/** The prop that picks a style, for sets that take it as a prop (Phosphor's `weight`). */
+	prop: z.string().optional(),
+	/**
+	* The module each style's icons are imported from, for sets that keep each style in a module of its own, as
+	* Heroicons does in `@heroicons/react/16/solid`. The default style's is the set's `import`.
+	*/
+	modules: z.record(z.string(), z.string()).optional(),
+	styles: z.array(z.string()).optional(),
+	sizes: z.array(finiteNumber).optional(),
+	/** What the picker shows first. An icon without a size in its name scales with the text. */
+	default: fileObject({
+		style: z.string().optional(),
+		size: finiteNumber.optional()
+	}).optional()
+});
+const libraryIcons = fileObject({
+	/** The module icons are imported from. Defaults to the package name. */
+	import: z.string().optional(),
+	/**
+	* `export` when every icon is a component of its own; otherwise the component that draws icons from data. A string
+	* is checked as one, so a renderer with a mistake in it reports the mistake rather than `expected "export"`.
+	*/
+	render: z.union([z.string().pipe(z.literal("export")), iconRenderer]),
+	/** A regular expression for the export names that are icons. Defaults to every export that can be one. */
+	match: pattern.optional(),
+	/** Exports that look like icons but aren't, such as Lucide's generic `Icon` and its provider. */
+	exclude: z.array(z.string()).optional(),
+	/**
+	* For icons exported under several names, the one to insert where it isn't the shortest: the name the set's types
+	* don't mark deprecated (Phosphor's `GearIcon`, not `Gear`), or the one an icon is declared under rather than an
+	* alias. Read from the types when the file is generated.
+	*/
+	prefer: z.array(z.string()).optional(),
+	/** Styles and sizes written into icon names, as in Fluent's `Add24Regular`. */
+	variants: iconVariants.optional(),
+	/** How many icons it had when it was generated. */
+	count: finiteNumber.optional(),
+	/**
+	* Words to find each icon by, from the set's own published metadata: its tags and categories, by the icon's name
+	* without a style or size (`Add` for Fluent's `Add24Regular`). Read when the file is generated, never typed by hand.
+	*/
+	tags: z.record(z.string(), z.array(z.string())).optional(),
+	/** Where `tags` were read from, as `package@version/path`. */
+	tagSource: z.string().optional()
+});
+/**
+* A decorator's value: JSON, or one of five forms that the guest works out for each frame. An object with one of the
+* forms' keys must be that form; any other object is plain JSON, its values decorator values too.
+*
+* - `{ "$import": "pkg", "export": "name" }`: something the package exports, such as a theme object. `export` defaults
+*   to `default`.
+* - `{ "$call": { "import": "pkg", "export": "name" }, "args": [...], "methods": [...] }`: what calling it returns.
+* - `{ "$global": "theme", "values": { "dark": ... }, "default": ... }`: picked by the frame's global, which is the
+*   mode's option for that variable.
+* - `{ "$frame": "root" | "host" | "body" }`: the frame's shadow root, the element it hangs from (which `:root[...]`
+*   rules match, as `:host(...)`), or the element standing in for its `<body>`. Also `document`, `dir`, `lang`, and
+*   `selector`, a CSS selector for the body alone.
+* - `{ "$function": ... }`: a function returning the value it holds.
+*
+* Values are checked once, when their library file loads. The guest evaluates them on every frame without zod.
+*/
+const decoratorValue = z.lazy(() => z.union([
+	z.string(),
+	finiteNumber,
+	z.boolean(),
+	z.null(),
+	z.array(decoratorValue),
+	form("$import", importedValue),
+	form("$call", madeValue),
+	form("$global", globalValue),
+	form("$frame", frameValue),
+	form("$function", functionValue),
+	plainValue
+]));
+const valueForms = [
+	"$import",
+	"$call",
+	"$global",
+	"$frame",
+	"$function"
+];
+/** Something the package exports, such as a theme object. */
+const importedValue = fileObject({
+	$import: z.string(),
+	export: z.string().optional()
+});
+/**
+* A value the package makes by calling one of its own functions, as an example does (Chakra's
+* `collection={createTreeCollection({ rootNode })}`): the canvas calls it with `args`, once per frame.
+*/
+const madeValue = fileObject({
+	$call: fileObject({
+		import: z.string(),
+		export: z.string()
+	}),
+	args: z.array(decoratorValue).optional(),
+	/**
+	* Methods called on what it makes, in order, as the examples call them (Chakra's `toaster.create({ title })`), so a
+	* toaster is drawn with a toast in it.
+	*/
+	methods: z.array(fileObject({
+		method: z.string(),
+		args: z.array(decoratorValue).optional()
+	})).optional()
+});
+/** Picked by the frame's global, which is the mode's option for that variable, else `default`. */
+const globalValue = fileObject({
+	$global: z.string(),
+	values: z.record(z.string(), decoratorValue),
+	default: decoratorValue.optional()
+});
+/** Part of the frame itself. */
+const frameValue = fileObject({ $frame: z.enum([
+	"root",
+	"host",
+	"body",
+	"document",
+	"dir",
+	"lang",
+	"selector"
+]) });
+/** A function returning the value it holds. */
+const functionValue = fileObject({ $function: decoratorValue });
+/**
+* An object with a form's key is that form. Any other object is refused as another type of value would be, which
+* `parseData` passes over, so a broken form reports its own mistake and not the closest of the other forms.
+*/
+function form(key, schema) {
+	return z.unknown().superRefine((value, context) => {
+		if (!(typeof value === "object" && value !== null && key in value)) context.addIssue({
+			code: "invalid_type",
+			expected: "object",
+			input: value
+		});
+	}).pipe(schema);
+}
+/** Plain JSON, its values decorator values too. An object with a form's key is refused, for the form to report. */
+const plainValue = plainObject.superRefine((record, context) => {
+	if (valueForms.some((key) => key in record)) context.addIssue({
+		code: "invalid_type",
+		expected: "object",
+		input: record
+	});
+}).pipe(z.record(z.string(), decoratorValue));
+const decoratorElement = fileObject({
+	import: z.string(),
+	/** The export to render; `default` for a default export. */
+	component: z.string(),
+	props: z.record(z.string(), decoratorValue).optional()
+});
+const decoratorEffects = [
 	"wrap",
 	"add",
 	"class",
 	"attributes",
 	"style"
 ];
+/**
+* A decorator written as data, so it runs no code of its own: a component wrapped around the design, one rendered
+* beside it (a toast host), or a class, attributes or styles on the frame's body. A manifest lists them outermost
+* first, as the JSX they make reads. That is Parity's order, the reverse of Storybook's, where the first decorator in a
+* list is innermost, so a list compiled into Storybook's decorators is reversed first.
+*/
+const libraryDecorator = fileObject({
+	/** Applies only when the frame's globals have these values, as in `{ "theme": "dark" }`. */
+	when: z.record(z.string(), z.string()).optional(),
+	wrap: decoratorElement.optional(),
+	add: decoratorElement.optional(),
+	class: decoratorValue.optional(),
+	attributes: z.record(z.string(), decoratorValue).optional(),
+	style: z.record(z.string(), decoratorValue).optional()
+}).superRefine((decorator, context) => {
+	if (decoratorEffects.filter((key) => decorator[key] !== void 0).length !== 1) context.addIssue({
+		code: "custom",
+		message: "expected one of wrap, add, class, attributes or style"
+	});
+});
+/**
+* Hand edits to a library file, kept apart from what `parity lib` generates so regenerating keeps them. Components are
+* keyed by export name and merged over the generated entry; `false` leaves a component out. Decorators, when given,
+* replace the generated ones. A manifest can name a shared file of edits instead, relative to itself.
+*/
+const libraryEdits = fileObject({
+	$schema: z.string().optional(),
+	components: z.record(z.string(), z.union([z.boolean().pipe(z.literal(false)), libraryComponentEdit])).optional(),
+	decorators: z.array(libraryDecorator).optional()
+});
+/**
+* What a library says about itself, in a `.lib.par` file at its package root: its name, the stylesheet a project
+* imports to use it, the breakpoints it's designed for, its design tokens, its components, icons and decorators, and its
+* own canvas of designs. Any package with one is a library Parity can load. Packages that don't ship one are described
+* by Parity's registry, in the same format.
+*/
+const libraryManifest = fileObject({
+	$schema: z.string().optional(),
+	/** The current manifest format; obsolete formats are rejected rather than migrated. */
+	version: z.literal(3),
+	/** Short name its components are namespaced by, as in `nova/Button`. Defaults to the package name. */
+	id: z.string().optional(),
+	name: z.string(),
+	description: z.string().optional(),
+	/** The npm package it describes, and the versions it was made for. */
+	package: libraryPackage.optional(),
+	/** The stylesheet to import, relative to the package: its Tailwind entry, or plain CSS. */
+	styles: z.string().optional(),
+	/** The viewport widths it's designed around, smallest first, however the file lists them. */
+	breakpoints: z.array(libraryBreakpoint).transform((breakpoints) => breakpoints.toSorted((a, b) => a.width - b.width)).optional(),
+	/**
+	* Its design tokens, in the DTCG format (2025.10): a path relative to the package, to a token file or to a resolver
+	* that names its themes, or a resolver or token groups written inline.
+	*/
+	tokens: z.union([z.string(), plainObject]).optional(),
+	/** The components it exports, as the type checker found them. */
+	components: libraryComponents.optional(),
+	/** Its icons, when it's an icon set: how they're imported and drawn. */
+	icons: libraryIcons.optional(),
+	/** What its components need around them in every frame: providers, toast hosts, theme classes. */
+	decorators: z.array(libraryDecorator).optional(),
+	/** Hand edits merged over the generated parts, or the path of a shared file of them, relative to this file. */
+	edits: z.union([z.string(), libraryEdits]).optional(),
+	/** The library's own canvas: its designs where its author placed them, its notes and its modes, as in a `.par`. */
+	canvas: canvasDocument.optional()
+});
 /** A library manifest's extension. It describes a library, and its `canvas` holds the library's own designs. */
 const libraryManifestExtension = ".lib.par";
+/** Reads a library file, or throws `TypeError` with the first problem as `/json/pointer: message`. */
 function parseLibraryManifest(value) {
-	const manifest = expectObject(value, "");
-	expectKnownKeys(manifest, [
-		"$schema",
-		"version",
-		"id",
-		"name",
-		"description",
-		"styles",
-		"breakpoints",
-		"tokens",
-		"canvas",
-		"package",
-		"components",
-		"icons",
-		"decorators",
-		"edits"
-	], "");
-	if (manifest.version !== 3) throw new TypeError("/version: expected 3");
-	return compact({
-		version: 3,
-		id: optional(manifest.id, (v) => expectString(v, "/id")),
-		name: expectString(manifest.name, "/name"),
-		description: optional(manifest.description, (v) => expectString(v, "/description")),
-		package: optional(manifest.package, parsePackage),
-		styles: optional(manifest.styles, (v) => expectString(v, "/styles")),
-		breakpoints: optional(manifest.breakpoints, (v) => expectArray(v, "/breakpoints").map((item, index) => {
-			const at = `/breakpoints/${index}`;
-			const breakpoint = expectObject(item, at);
-			expectKnownKeys(breakpoint, [
-				"id",
-				"name",
-				"width"
-			], at);
-			return {
-				id: expectString(breakpoint.id, `${at}/id`),
-				name: expectString(breakpoint.name, `${at}/name`),
-				width: expectNumber(breakpoint.width, `${at}/width`)
-			};
-		}).sort((a, b) => a.width - b.width)),
-		tokens: optional(manifest.tokens, (v) => typeof v === "string" ? v : expectObject(v, "/tokens")),
-		components: optional(manifest.components, parseComponents),
-		icons: optional(manifest.icons, parseIcons),
-		decorators: optional(manifest.decorators, (v) => expectArray(v, "/decorators").map(parseDecorator)),
-		edits: optional(manifest.edits, (v) => typeof v === "string" ? v : parseLibraryEdits(v, "/edits")),
-		canvas: optional(manifest.canvas, (v) => {
-			try {
-				return parseCanvasDocument(v);
-			} catch (error) {
-				throw new TypeError(`/canvas${error instanceof Error ? error.message : String(error)}`);
-			}
-		})
-	});
-}
-function parsePackage(value) {
-	const pkg = expectObject(value, "/package");
-	expectKnownKeys(pkg, [
-		"name",
-		"version",
-		"range"
-	], "/package");
-	return compact({
-		name: expectString(pkg.name, "/package/name"),
-		version: optional(pkg.version, (v) => expectString(v, "/package/version")),
-		range: optional(pkg.range, (v) => expectString(v, "/package/range"))
-	});
-}
-function parseComponents(value) {
-	const components = expectObject(value, "/components");
-	expectKnownKeys(components, ["import", "list"], "/components");
-	const list = {};
-	for (const [name, entry] of Object.entries(expectObject(components.list, "/components/list"))) {
-		const at = `/components/list/${name}`;
-		const component = expectObject(entry, at);
-		expectKnownKeys(component, [
-			...componentKeys,
-			"fingerprint",
-			"props"
-		], at);
-		list[name] = compact({
-			...parseComponentFields(component, at),
-			as: expectOneOf(component.as, componentEvidence, `${at}/as`),
-			fingerprint: optional(component.fingerprint, (v) => expectString(v, `${at}/fingerprint`)),
-			props: optional(component.props, (v) => expectStringRecord(v, `${at}/props`))
-		});
-	}
-	return compact({
-		import: optional(components.import, (v) => expectString(v, "/components/import")),
-		list
-	});
-}
-const componentKeys = [
-	"as",
-	"declaration",
-	"group",
-	"parents",
-	"parentsFrom",
-	"optionalParents",
-	"parentParts",
-	"visual",
-	"internal",
-	"sample"
-];
-function parseComponentFields(component, at) {
-	return compact({
-		as: optional(component.as, (v) => expectOneOf(v, componentEvidence, `${at}/as`)),
-		declaration: optional(component.declaration, (v) => expectString(v, `${at}/declaration`)),
-		group: optional(component.group, (v) => expectString(v, `${at}/group`)),
-		parents: optional(component.parents, (v) => expectArray(v, `${at}/parents`).map((name, index) => expectString(name, `${at}/parents/${index}`))),
-		parentsFrom: optional(component.parentsFrom, (v) => expectOneOf(v, parentSignals, `${at}/parentsFrom`)),
-		optionalParents: optional(component.optionalParents, (v) => expectArray(v, `${at}/optionalParents`).map((name, index) => expectString(name, `${at}/optionalParents/${index}`))),
-		parentParts: optional(component.parentParts, (v) => {
-			if (typeof v !== "boolean") throw new TypeError(`${at}/parentParts: expected a boolean`);
-			return v;
-		}),
-		visual: optional(component.visual, (v) => {
-			if (typeof v !== "boolean") throw new TypeError(`${at}/visual: expected a boolean`);
-			return v;
-		}),
-		internal: optional(component.internal, (v) => {
-			if (typeof v !== "boolean") throw new TypeError(`${at}/internal: expected a boolean`);
-			return v;
-		}),
-		sample: optional(component.sample, (v) => parseSample(v, `${at}/sample`))
-	});
-}
-function parseSample(value, at) {
-	const sample = expectObject(value, at);
-	expectKnownKeys(sample, ["props", "children"], at);
-	return compact({
-		props: optional(sample.props, (v) => expectObject(v, `${at}/props`)),
-		children: optional(sample.children, (v) => parseSampleChildren(v, `${at}/children`))
-	});
-}
-function parseSampleChildren(value, at) {
-	return expectArray(value, at).map((item, index) => {
-		const here = `${at}/${index}`;
-		if (typeof item === "string") return item;
-		const child = expectObject(item, here);
-		if ("$render" in child) {
-			expectKnownKeys(child, [
-				"$render",
-				"spread",
-				"pass"
-			], here);
-			if (child.spread !== void 0 && child.spread !== true) throw new TypeError(`${here}/spread: expected true`);
-			const render = { $render: parseSampleChildren(child.$render, `${here}/$render`) };
-			if (child.spread) render.spread = true;
-			if (child.pass !== void 0) render.pass = expectArray(child.pass, `${here}/pass`).map((prop, index) => expectString(prop, `${here}/pass/${index}`));
-			return render;
-		}
-		expectKnownKeys(child, [
-			"component",
-			"props",
-			"children"
-		], here);
-		return compact({
-			component: expectString(child.component, `${here}/component`),
-			props: optional(child.props, (v) => expectObject(v, `${here}/props`)),
-			children: optional(child.children, (v) => parseSampleChildren(v, `${here}/children`))
-		});
-	});
+	const { $schema: _schema, ...manifest } = parseData(libraryManifest, value);
+	return manifest;
 }
 /** Reads hand edits to a library file, from its `edits` or a shared file of them. */
 function parseLibraryEdits(value, at = "") {
-	const edits = expectObject(value, at);
-	expectKnownKeys(edits, [
-		"$schema",
-		"components",
-		"decorators"
-	], at);
-	return compact({
-		components: optional(edits.components, (v) => {
-			const result = {};
-			for (const [name, entry] of Object.entries(expectObject(v, `${at}/components`))) {
-				const here = `${at}/components/${name}`;
-				if (entry === false) {
-					result[name] = false;
-					continue;
-				}
-				const component = expectObject(entry, here);
-				expectKnownKeys(component, componentKeys, here);
-				result[name] = parseComponentFields(component, here);
-			}
-			return result;
-		}),
-		decorators: optional(edits.decorators, (v) => expectArray(v, `${at}/decorators`).map(parseDecorator))
-	});
+	const { $schema: _schema, ...edits } = parseData(libraryEdits, value, at);
+	return edits;
 }
 /**
 * The manifest with hand edits merged over what was generated, and the edited exports it no longer has, which are
@@ -1074,125 +1204,18 @@ function applyLibraryEdits(manifest, edits) {
 			list
 		};
 	}
+	const merged = {
+		...manifest,
+		components,
+		decorators: edits.decorators ?? manifest.decorators
+	};
+	if (!merged.components) delete merged.components;
+	if (!merged.decorators) delete merged.decorators;
 	return {
-		manifest: compact({
-			...manifest,
-			components,
-			decorators: edits.decorators ?? manifest.decorators
-		}),
+		manifest: merged,
 		orphans
 	};
 }
-function parseIcons(value) {
-	const icons = expectObject(value, "/icons");
-	expectKnownKeys(icons, [
-		"import",
-		"render",
-		"match",
-		"exclude",
-		"prefer",
-		"variants",
-		"count",
-		"tags",
-		"tagSource"
-	], "/icons");
-	let render;
-	if (icons.render === "export") render = "export";
-	else {
-		const renderer = expectObject(icons.render, "/icons/render");
-		expectKnownKeys(renderer, [
-			"import",
-			"component",
-			"prop"
-		], "/icons/render");
-		render = {
-			import: expectString(renderer.import, "/icons/render/import"),
-			component: expectString(renderer.component, "/icons/render/component"),
-			prop: expectString(renderer.prop, "/icons/render/prop")
-		};
-	}
-	return compact({
-		import: optional(icons.import, (v) => expectString(v, "/icons/import")),
-		render,
-		match: optional(icons.match, (v) => expectPattern(v, "/icons/match")),
-		exclude: optional(icons.exclude, (v) => expectArray(v, "/icons/exclude").map((name, index) => expectString(name, `/icons/exclude/${index}`))),
-		prefer: optional(icons.prefer, (v) => expectArray(v, "/icons/prefer").map((name, index) => expectString(name, `/icons/prefer/${index}`))),
-		variants: optional(icons.variants, (v) => {
-			const variants = expectObject(v, "/icons/variants");
-			expectKnownKeys(variants, [
-				"pattern",
-				"prop",
-				"modules",
-				"styles",
-				"sizes",
-				"default"
-			], "/icons/variants");
-			return compact({
-				pattern: optional(variants.pattern, (pattern) => expectPattern(pattern, "/icons/variants/pattern")),
-				prop: optional(variants.prop, (prop) => expectString(prop, "/icons/variants/prop")),
-				modules: optional(variants.modules, (modules) => expectStringRecord(modules, "/icons/variants/modules")),
-				styles: optional(variants.styles, (list) => expectArray(list, "/icons/variants/styles").map((style, index) => expectString(style, `/icons/variants/styles/${index}`))),
-				sizes: optional(variants.sizes, (list) => expectArray(list, "/icons/variants/sizes").map((size, index) => expectNumber(size, `/icons/variants/sizes/${index}`))),
-				default: optional(variants.default, (d) => {
-					const fallback = expectObject(d, "/icons/variants/default");
-					expectKnownKeys(fallback, ["style", "size"], "/icons/variants/default");
-					return compact({
-						style: optional(fallback.style, (s) => expectString(s, "/icons/variants/default/style")),
-						size: optional(fallback.size, (s) => expectNumber(s, "/icons/variants/default/size"))
-					});
-				})
-			});
-		}),
-		count: optional(icons.count, (v) => expectNumber(v, "/icons/count")),
-		tags: optional(icons.tags, (v) => Object.fromEntries(Object.entries(expectObject(v, "/icons/tags")).map(([name, list]) => [name, expectArray(list, `/icons/tags/${name}`).map((tag, index) => expectString(tag, `/icons/tags/${name}/${index}`))]))),
-		tagSource: optional(icons.tagSource, (v) => expectString(v, "/icons/tagSource"))
-	});
-}
-function parseDecorator(value, index) {
-	const at = `/decorators/${index}`;
-	const decorator = expectObject(value, at);
-	expectKnownKeys(decorator, decoratorKeys, at);
-	if (decoratorKeys.filter((key) => key !== "when" && decorator[key] !== void 0).length !== 1) throw new TypeError(`${at}: expected one of wrap, add, class, attributes or style`);
-	const element = (v, path) => {
-		const spec = expectObject(v, path);
-		expectKnownKeys(spec, [
-			"import",
-			"component",
-			"props"
-		], path);
-		return compact({
-			import: expectString(spec.import, `${path}/import`),
-			component: expectString(spec.component, `${path}/component`),
-			props: optional(spec.props, (props) => expectObject(props, `${path}/props`))
-		});
-	};
-	return compact({
-		when: optional(decorator.when, (v) => {
-			const when = expectObject(v, `${at}/when`);
-			for (const [name, option] of Object.entries(when)) expectString(option, `${at}/when/${name}`);
-			return when;
-		}),
-		wrap: optional(decorator.wrap, (v) => element(v, `${at}/wrap`)),
-		add: optional(decorator.add, (v) => element(v, `${at}/add`)),
-		class: decorator.class,
-		attributes: optional(decorator.attributes, (v) => expectObject(v, `${at}/attributes`)),
-		style: optional(decorator.style, (v) => expectObject(v, `${at}/style`))
-	});
-}
-function expectPattern(value, path) {
-	const pattern = expectString(value, path);
-	try {
-		new RegExp(pattern);
-	} catch {
-		throw new TypeError(`${path}: expected a regular expression`);
-	}
-	return pattern;
-}
-function expectStringRecord(value, path) {
-	const record = expectObject(value, path);
-	for (const [key, item] of Object.entries(record)) expectString(item, `${path}/${key}`);
-	return record;
-}
 // ../core/src/project.ts
 /**
 * Props that say what's open or chosen: `defaultOpen` on what opens (a dialog, a popover, a menu), `defaultValue` on
@@ -1468,4 +1491,4 @@ function sampleIds(sample, library) {
 		...sample.children ? { children: sample.children.map(child) } : {}
 	};
 }
-export { remProperty as A, linkTypes as C, generateId as D, walkNodes as E, packageManifest as F, viewportWidthProperty as M, deviceKinds as N, modeSettings as O, lengthToPixels as P, linkEndKinds as S, parseCanvasDocument as T, canvasObjectKinds as _, openProps as a, imageFits as b, isMadeValue as c, libraryManifestExtension as d, parentSignals as f, canvasDocument as g, renderSlotOf as h, withLibraryContext as i, viewportHeightProperty as j, collectCustomProperties as k, isSampleElement as l, parseLibraryManifest as m, librarySource as n, applyLibraryEdits as o, parseLibraryEdits as p, sampleIds as r, componentEvidence as s, componentNode as t, isSampleRender as u, containerKinds as v, paramTypes as w, linkAllowed as x, detectionCorrections as y };
+export { paramTypes as A, packageManifest as B, imageCredit as C, linkTypes as D, linkEndKinds as E, remProperty as F, viewportHeightProperty as I, viewportWidthProperty as L, generateId as M, modeSettings as N, nodeTree as O, collectCustomProperties as P, deviceKinds as R, detectionCorrections as S, linkAllowed as T, renderSlotOf as _, openProps as a, containerKinds as b, isMadeValue as c, libraryManifest as d, libraryManifestExtension as f, parseLibraryManifest as g, parseLibraryEdits as h, withLibraryContext as i, walkNodes as j, noteSpec as k, isSampleElement as l, parentSignals as m, librarySource as n, applyLibraryEdits as o, libraryPackage as p, sampleIds as r, componentEvidence as s, componentNode as t, isSampleRender as u, canvasDocument as v, imageFits as w, containerSpec as x, canvasObjectKinds as y, lengthToPixels as z };

package/dist/{src-Bf12xdm5.mjs → src-CMPL5C8p.mjs}

@@ -1,6 +1,6 @@
-import { i as jsonText, o as parseData, r as finiteNumber, s as plainObject } from "./schema-CemdtCeF.mjs";
-import { F as packageManifest, P as lengthToPixels, c as isMadeValue, d as libraryManifestExtension, h as renderSlotOf, k as collectCustomProperties, l as isSampleElement, m as parseLibraryManifest, o as applyLibraryEdits, p as parseLibraryEdits, u as isSampleRender } from "./src-DjSCuWcT.mjs";
-import { r as readLibraryEdits, s as parseJsonc } from "./src-B9VW36v9.mjs";
+import { i as jsonText, o as parseData, r as finiteNumber, s as plainObject } from "./schema-Dp5Jhloe.mjs";
+import { B as packageManifest, P as collectCustomProperties, _ as renderSlotOf, c as isMadeValue, f as libraryManifestExtension, g as parseLibraryManifest, h as parseLibraryEdits, l as isSampleElement, o as applyLibraryEdits, u as isSampleRender, z as lengthToPixels } from "./src-BZFjMWhp.mjs";
+import { r as readLibraryEdits, s as parseJsonc } from "./src-CdMzjFSa.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";

package/dist/src-CbLrA8BA.mjs

@@ -0,0 +1,5 @@
+import "./schema-Dp5Jhloe.mjs";
+import "./client-BkLeG26A.mjs";
+export { t as componentNode, M as generateId, n as librarySource, i as withLibraryContext } from "./src-BZFjMWhp.mjs";
+import "./src-CdMzjFSa.mjs";
+import "./src-CMPL5C8p.mjs";

package/dist/{src-B9VW36v9.mjs → src-CdMzjFSa.mjs}

@@ -1,7 +1,9 @@
-import { d as libraryManifestExtension, m as parseLibraryManifest, o as applyLibraryEdits, p as parseLibraryEdits } from "./src-DjSCuWcT.mjs";
+import { n as fileObject, o as parseData } from "./schema-Dp5Jhloe.mjs";
+import { d as libraryManifest, f as libraryManifestExtension, h as parseLibraryEdits, o as applyLibraryEdits, p as libraryPackage } from "./src-BZFjMWhp.mjs";
 import { createRequire } from "node:module";
 import { readFile, readdir } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
+import { z } from "zod";
 import { existsSync } from "node:fs";
 import semver from "semver";
 // ../core/src/jsonc.ts
@@ -28,6 +30,11 @@ function parseJsonc(text) {
 }
 // ../registry/src/index.ts
 const require = createRequire(import.meta.url);
+/** A library file in the registry, which names the package it describes, since that's how it's found. */
+const registryManifest = fileObject({
+	...libraryManifest.shape,
+	package: z.unknown().refine((value) => value !== void 0, "a registry file names the package it describes").pipe(libraryPackage)
+});
 /**
 * 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
@@ -51,8 +58,7 @@ async function readEntries(dir) {
 	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");
+			const { $schema: _schema, ...manifest } = parseData(registryManifest, JSON.parse(await readFile(path, "utf8")));
 			entries.push({
 				file,
 				path,

package/dist/{src-Q382DbAK.mjs → src-DHuMBGiB.mjs}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity-app/cli",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "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/src-Btr2eWdT.mjs

@@ -1,5 +0,0 @@
-import "./schema-CemdtCeF.mjs";
-import "./client-D6bpjpy-.mjs";
-export { t as componentNode, D as generateId, n as librarySource, i as withLibraryContext } from "./src-DjSCuWcT.mjs";
-import "./src-B9VW36v9.mjs";
-import "./src-Bf12xdm5.mjs";