@parity-app/cli 0.7.5 → 0.7.7

package/dist/{src-DjSCuWcT.mjs → src-Ck9A-Gxr.mjs}

@@ -1,4 +1,4 @@
-import { n as fileObject, o as parseData, r as finiteNumber, s as plainObject } from "./schema-CemdtCeF.mjs";
+import { i as jsonText, 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());
@@ -18,6 +18,7 @@ const packageManifest = z.looseObject({
 	version: z.string().optional(),
 	dependencies: packageVersions.optional(),
 	devDependencies: packageVersions.optional(),
+	optionalDependencies: packageVersions.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(),
@@ -28,8 +29,28 @@ const packageManifest = z.looseObject({
 	/** 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()
+	workspaces: z.union([z.array(z.string()), z.looseObject({ packages: z.array(z.string()).optional() })]).optional(),
+	/** The command line it installs: one file named after the package, or files by command name. */
+	bin: z.union([z.string(), z.record(z.string(), z.string())]).optional(),
+	/** Where its source is, which libgen reads examples from. */
+	repository: z.union([z.string(), z.looseObject({
+		url: z.string().optional(),
+		directory: z.string().optional()
+	})]).optional(),
+	/** The package manager and version a project asks for, as Corepack writes it (`pnpm@10.4.0`). */
+	packageManager: z.string().optional()
 });
+/**
+* A package.json's text, read through {@link packageManifest}. Throws `TypeError` naming the file and the field at
+* fault, as in `/app/package.json: /scripts/dev: expected a string`, or `/: expected JSON`.
+*/
+function parseManifest(text, file) {
+	try {
+		return parseData(jsonText(packageManifest), text);
+	} catch (error) {
+		throw new TypeError(`${file}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+}
 // ../core/src/devices.ts
 const deviceKinds = [
 	"phone",
@@ -341,6 +362,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(),
@@ -504,18 +526,20 @@ const componentNode$1 = nodeBase.extend({
 		return z.record(z.string(), z.array(designNode)).optional();
 	}
 });
+/** The elements a text node can be. */
+const textTags = [
+	"p",
+	"span",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"strong"
+];
 const textNode = nodeBase.extend({
 	type: z.literal("text"),
 	text: z.string(),
-	tag: z.enum([
-		"p",
-		"span",
-		"h1",
-		"h2",
-		"h3",
-		"h4",
-		"strong"
-	]).optional()
+	tag: z.enum(textTags).optional()
 });
 const instanceNode = nodeBase.extend({
 	type: z.literal("instance"),
@@ -535,6 +559,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 +677,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 +776,285 @@ 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/values/evaluate.ts
+/** The keys that mark an object as one of the value forms rather than plain JSON. */
+const valueForms = [
+	"$import",
+	"$call",
+	"$global",
+	"$frame",
+	"$function"
+];
+/** The parts of a frame a `$frame` value can name. */
+const frameParts = [
+	"root",
+	"host",
+	"body",
+	"document",
+	"dir",
+	"lang",
+	"selector"
+];
+/** Whether a sample's prop value is elements. */
+function isSampleElement(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.$element);
+}
+/** Whether a value is one the package makes. */
+function isMadeValue(value) {
+	const call = typeof value === "object" && value !== null ? value.$call : void 0;
+	return typeof call === "object" && call !== null && typeof call.import === "string";
+}
+/** Whether a sample's child or prop value is a render function. */
+function isSampleRender(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.$render);
+}
+/**
+* A value worked out against a host: plain JSON as written, and its kind's forms made. A `$import` without an `export`
+* is the module's default export. A `$call` calls its function with its `args`, then the `methods` in order on what it
+* returned, wherever the call is; a method that's missing or throws is passed over, as the made value is still usable.
+* Arrays and objects with no form inside them come back as they were, so a prop keeps its identity between draws.
+*/
+function evaluateValue(value, host, kind = "decorator") {
+	const evaluate = (item) => evaluateValue(item, host, kind);
+	if (Array.isArray(value)) {
+		const items = value.map(evaluate);
+		return items.every((item, index) => item === value[index]) ? value : items;
+	}
+	if (typeof value !== "object" || value === null) return value;
+	const record = value;
+	if (isMadeValue(record)) return made$1(record, host, kind);
+	if (kind === "sample") return evaluateEntries(record, evaluate);
+	if (typeof record.$import === "string") {
+		const imported = record;
+		return host.exported(imported.$import, imported.export ?? "default");
+	}
+	if (typeof record.$global === "string") {
+		const global = record;
+		const chosen = host.global(global.$global);
+		const values = global.values ?? {};
+		return evaluate(chosen !== void 0 && Object.hasOwn(values, chosen) ? values[chosen] : global.default);
+	}
+	if (typeof record.$frame === "string") return host.frame(record.$frame);
+	if ("$function" in record) return () => evaluate(record.$function);
+	return evaluateEntries(record, evaluate);
+}
+/** Plain JSON's entries worked out, or the object as it was when none of them changed. */
+function evaluateEntries(record, evaluate) {
+	let changed = false;
+	const entries = Object.entries(record).map(([key, item]) => {
+		const evaluated = evaluate(item);
+		if (evaluated !== item) changed = true;
+		return [key, evaluated];
+	});
+	return changed ? Object.fromEntries(entries) : record;
 }
-// ../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 made$1(value, host, kind) {
+	const key = JSON.stringify(value);
+	if (host.made.has(key)) return host.made.get(key);
+	const { import: specifier, export: name } = value.$call;
+	const fn = host.exported(specifier, name);
+	if (typeof fn !== "function") throw new Error(`${specifier} has no function ${name}`);
+	const result = fn(...(value.args ?? []).map((arg) => evaluateValue(arg, host, kind)));
+	for (const step of value.methods ?? []) {
+		const method = result?.[step.method];
+		if (typeof method !== "function") continue;
+		try {
+			method.apply(result, (step.args ?? []).map((arg) => evaluateValue(arg, host, kind)));
+		} catch {}
+	}
+	host.made.set(key, result);
+	return result;
 }
-function expectString(value, path) {
-	if (typeof value !== "string") throw new TypeError(`${path}: expected a string`);
-	return value;
+/** The modules a value imports from, each once, in the order they first appear. Plain JSON imports none. */
+function valueImports(value, kind = "decorator") {
+	const found = /* @__PURE__ */ new Set();
+	const visit = (item) => {
+		if (Array.isArray(item)) return item.forEach(visit);
+		if (typeof item !== "object" || item === null) return;
+		const record = item;
+		if (kind === "decorator" && typeof record.$import === "string") {
+			found.add(record.$import);
+			return;
+		}
+		if (isMadeValue(record)) {
+			found.add(record.$call.import);
+			record.args?.forEach(visit);
+			for (const step of record.methods ?? []) step.args?.forEach(visit);
+			return;
+		}
+		if (kind === "decorator" && typeof record.$frame === "string") return;
+		Object.values(record).forEach(visit);
+	};
+	visit(value);
+	return [...found];
+}
+/** An export of a module, following dots into namespaces (`Tooltip.Provider`). */
+function exportOf(module, path) {
+	let found = module;
+	for (const part of path.split(".")) found = found?.[part];
+	return found;
 }
-function expectNumber(value, path) {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${path}: expected a number`);
-	return value;
+/**
+* Where a part's sample calls what's inside it: its function children, else a render prop (Chakra's `TreeView.Node`
+* `render`), with the render function.
+*/
+function renderSlotOf(sample) {
+	const children = sample?.children?.find(isSampleRender);
+	if (children) return {
+		prop: "children",
+		render: children
+	};
+	const entry = Object.entries(sample?.props ?? {}).find(([, value]) => isSampleRender(value));
+	return entry ? {
+		prop: entry[0],
+		render: entry[1]
+	} : void 0;
 }
-function expectArray(value, path) {
-	if (!Array.isArray(value)) throw new TypeError(`${path}: expected an array`);
-	return value;
+/**
+* The key a component node keeps a render function's nodes under (`renderInput`, function children): `$render:` and the
+* prop, `$renderWith:` when what it's called with is spread onto them, and `?pass=a,b` for the props that take it.
+*/
+function renderSlotKey(prop, render) {
+	const pass = render.pass ? `?pass=${render.pass.join(",")}` : "";
+	return `${render.spread ? "$renderWith" : "$render"}:${prop}${pass}`;
 }
-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;
+/** A slot key `renderSlotKey` wrote, read back; `undefined` for a slot of plain nodes. */
+function readRenderSlotKey(key) {
+	const match = /^\$render(With)?:([^?]+)(?:\?pass=(.+))?$/.exec(key);
+	if (!match) return void 0;
+	const [, spread, prop, pass] = match;
+	return {
+		prop,
+		spread: spread !== void 0,
+		...pass ? { pass: pass.split(",") } : {}
+	};
 }
-function optional(value, parse) {
-	return value === void 0 ? void 0 : parse(value);
+// ../core/src/values/grammar.ts
+const primitives = [
+	z.string(),
+	finiteNumber,
+	z.boolean(),
+	z.null()
+];
+/**
+* A decorator's or sample's value: JSON, or one of five forms that `evaluateValue` works out against a host, the frame
+* in the guest and a trial outside one in libgen. An object with one of the forms' keys must be that form; any other
+* object is plain JSON, its values values too.
+*
+* - `{ "$import": "pkg", "export": "name" }`: something the package exports, such as a theme object. `export` defaults
+*   to `default`, the default export.
+* - `{ "$call": { "import": "pkg", "export": "name" }, "args": [...], "methods": [...] }`: what calling it returns,
+*   after calling `methods` on it in order.
+* - `{ "$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. A
+* sample's values are `sampleValue`s.
+*/
+const decoratorValue = z.lazy(() => z.union([
+	...primitives,
+	z.array(decoratorValue),
+	form("$import", importedValue),
+	form("$call", madeValue),
+	form("$global", globalValue),
+	form("$frame", frameValue),
+	form("$function", functionValue),
+	plain(valueForms, decoratorValue)
+]));
+/**
+* A sample's value, which a design node's props copy: JSON, and values the package makes (`$call`), as an example
+* passes them. The other forms are a decorator's alone, so in a sample an object with their keys is data as written.
+*/
+const sampleValue = z.lazy(() => z.union([
+	...primitives,
+	z.array(sampleValue),
+	form("$call", made(sampleValue)),
+	plain(["$call"], sampleValue)
+]));
+/** 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.
+*/
+function made(value) {
+	return fileObject({
+		$call: fileObject({
+			import: z.string(),
+			export: z.string()
+		}),
+		args: z.array(value).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(value).optional()
+		})).optional()
+	});
 }
-/** 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));
+const madeValue = made(decoratorValue);
+/** 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(frameParts) });
+/** 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);
 }
-function expectKnownKeys(value, keys, path) {
-	for (const key of Object.keys(value)) if (!keys.includes(key)) throw new TypeError(`${path}/${key}: unknown property`);
+/** Plain JSON, its values values too. An object with a form's key is refused, for the form to report. */
+function plain(forms, value) {
+	return plainObject.superRefine((record, context) => {
+		if (forms.some((key) => key in record)) context.addIssue({
+			code: "invalid_type",
+			expected: "object",
+			input: record
+		});
+	}).pipe(z.record(z.string(), value));
 }
+/** A decorator's attributes, styles and element props. */
+const decoratorProps = z.record(z.string(), decoratorValue);
+/** A sample's props, and those of the components in its children. */
+const sampleProps = z.record(z.string(), sampleValue);
 // ../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,233 +1078,252 @@ const parentSignals = [
 	"edit",
 	"app"
 ];
-/** Whether a sample's prop value is elements. */
-function isSampleElement(value) {
-	return typeof value === "object" && value !== null && Array.isArray(value.$element);
-}
-/** Whether a sample's prop value is one the package makes. */
-function isMadeValue(value) {
-	const call = typeof value === "object" && value !== null ? value.$call : void 0;
-	return typeof call === "object" && call !== null && typeof call.import === "string";
-}
-/** Whether a sample's child or prop value is a render function. */
-function isSampleRender(value) {
-	return typeof value === "object" && value !== null && Array.isArray(value.$render);
-}
 /**
-* Where a part's sample calls what's inside it: its function children, else a render prop (Chakra's `TreeView.Node`
-* `render`), with the render function.
+* 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} />}`.
 */
-function renderSlotOf(sample) {
-	const children = sample?.children?.find(isSampleRender);
-	if (children) return {
-		prop: "children",
-		render: children
-	};
-	const entry = Object.entries(sample?.props ?? {}).find(([, value]) => isSampleRender(value));
-	return entry ? {
-		prop: entry[0],
-		render: entry[1]
-	} : void 0;
-}
-const decoratorKeys = [
-	"when",
+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: sampleProps.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: sampleProps.optional(),
+	children: z.array(sampleChild).optional()
+});
+/** 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()
+});
+const decoratorElement = fileObject({
+	import: z.string(),
+	/** The export to render; `default` for a default export. */
+	component: z.string(),
+	props: decoratorProps.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: decoratorProps.optional(),
+	style: decoratorProps.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 +1362,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
@@ -1273,8 +1454,7 @@ function withLibraryContext(node, sources, around, taken) {
 		const plain = {};
 		const slots = {};
 		const renderSlot = (prop, render) => {
-			const pass = render.pass ? `?pass=${render.pass.join(",")}` : "";
-			slots[`${render.spread ? "$renderWith" : "$render"}:${prop}${pass}`] = nodes(render.$render);
+			slots[renderSlotKey(prop, render)] = nodes(render.$render);
 		};
 		for (const [key, value] of Object.entries(props)) if (isSampleRender(value)) renderSlot(key, value);
 		else if (isSampleElement(value)) slots[key] = nodes(value.$element);
@@ -1331,8 +1511,8 @@ function withLibraryContext(node, sources, around, taken) {
 	for (const parent of added.reverse()) {
 		const wrapper = component(parent);
 		const calls = renderSlotOf(sources[parent]?.sample);
-		const slot = calls ? `$render:${calls.prop}${calls.render.pass ? `?pass=${calls.render.pass.join(",")}` : ""}` : "children";
-		const kept = Object.fromEntries(Object.entries(wrapper.type === "component" ? wrapper.slots ?? {} : {}).filter(([name]) => !calls || !name.startsWith(`$render:${calls.prop}`)));
+		const slot = calls ? renderSlotKey(calls.prop, calls.render) : "children";
+		const kept = Object.fromEntries(Object.entries(wrapper.type === "component" ? wrapper.slots ?? {} : {}).filter(([name]) => !calls || readRenderSlotKey(name)?.prop !== calls.prop));
 		placed = wrapper.type === "component" ? {
 			...wrapper,
 			slots: {
@@ -1468,4 +1648,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 { lengthToPixels as $, canvasObjectKinds as A, nodeTree as B, isSampleRender as C, valueForms as D, renderSlotOf as E, imageFits as F, walkNodes as G, paramTypes as H, linkAllowed as I, collectCustomProperties as J, generateId as K, linkEndKinds as L, containerSpec as M, detectionCorrections as N, valueImports as O, imageCredit as P, deviceKinds as Q, linkTypes as R, isSampleElement as S, renderSlotKey as T, patchUnset as U, noteSpec as V, textTags as W, viewportHeightProperty as X, remProperty as Y, viewportWidthProperty as Z, sampleValue as _, openProps as a, frameParts as b, libraryManifest as c, parentSignals as d, packageManifest as et, parseLibraryEdits as f, sampleProps as g, decoratorValue as h, withLibraryContext as i, containerKinds as j, canvasDocument as k, libraryManifestExtension as l, decoratorProps as m, librarySource as n, applyLibraryEdits as o, parseLibraryManifest as p, modeSettings as q, sampleIds as r, componentEvidence as s, componentNode as t, parseManifest as tt, libraryPackage as u, evaluateValue as v, readRenderSlotKey as w, isMadeValue as x, exportOf as y, nodeStyle as z };