@parity-app/cli 0.6.3 → 0.7.1

package/dist/{src-YQY8r4mh.mjs → src-IWA2JHPw.mjs}

@@ -1,4 +1,4 @@
-import "./schema-CiVy9tZT.mjs";
+import { a as parseData, n as finiteNumber, o as plainObject, t as fileObject } from "./schema-DcQLoUPP.mjs";
 import { z } from "zod";
 // ../core/src/adapters.ts
 const packageVersions = z.record(z.string(), z.string());
@@ -55,6 +55,11 @@ function lengthToPixels(value) {
 */
 const viewportWidthProperty = "--canvas-vw";
 const viewportHeightProperty = "--canvas-vh";
+/**
+* The custom property `rem` is rewritten to: in a frame, the project's root font size, not Parity's. A frame sets it
+* from `rootFontSizeProperty`, a length registered so that `1em` on the frame's root becomes that root's font size.
+*/
+const remProperty = "--canvas-rem";
 /** Every custom property declaration in a stylesheet, in source order. */
 function collectCustomProperties(css) {
 	const declarations = [];
@@ -151,42 +156,7 @@ function findStringEnd(css, start) {
 	else index++;
 	return css.length;
 }
-new RegExp(String.raw`"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|url\([^)]*\)|var\((?:${viewportWidthProperty}|${viewportHeightProperty}),[^)]*\)`, "g");
-// ../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 expectBoolean(value, path) {
-	if (typeof value !== "boolean") throw new TypeError(`${path}: expected true or false`);
-	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`);
-}
+new RegExp(String.raw`"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|url\([^)]*\)|var\((?:${viewportWidthProperty}|${viewportHeightProperty}|${remProperty}),[^)]*\)`, "g");
 // ../core/src/modes.ts
 const variableKinds = [
 	"viewport",
@@ -194,87 +164,69 @@ const variableKinds = [
 	"locale",
 	"custom"
 ];
-function parseModeSettings(value) {
-	const settings = expectObject(value, "");
-	expectKnownKeys(settings, [
-		"$schema",
-		"version",
-		"variables",
-		"modes"
-	], "");
-	if (settings.version !== 1) throw new TypeError("/version: expected 1");
-	const variables = expectArray(settings.variables, "/variables").map((item, index) => {
-		const at = `/variables/${index}`;
-		const variable = expectObject(item, at);
-		expectKnownKeys(variable, [
-			"id",
-			"name",
-			"kind",
-			"options"
-		], at);
-		const options = expectArray(variable.options, `${at}/options`).map((entry, optionIndex) => {
-			const optionAt = `${at}/options/${optionIndex}`;
-			const option = expectObject(entry, optionAt);
-			expectKnownKeys(option, [
-				"id",
-				"name",
-				"width",
-				"height",
-				"device",
-				"className",
-				"attributes"
-			], optionAt);
-			return compact({
-				id: expectString(option.id, `${optionAt}/id`),
-				name: expectString(option.name, `${optionAt}/name`),
-				width: optional(option.width, (v) => expectNumber(v, `${optionAt}/width`)),
-				height: optional(option.height, (v) => expectNumber(v, `${optionAt}/height`)),
-				device: optional(option.device, (v) => expectOneOf(v, deviceKinds, `${optionAt}/device`)),
-				className: optional(option.className, (v) => expectString(v, `${optionAt}/className`)),
-				attributes: optional(option.attributes, (v) => {
-					const attributes = expectObject(v, `${optionAt}/attributes`);
-					for (const [name, attribute] of Object.entries(attributes)) expectString(attribute, `${optionAt}/attributes/${name}`);
-					return attributes;
-				})
-			});
+/** What choosing this option does to a rendered frame. */
+const variableOption = fileObject({
+	id: z.string(),
+	name: z.string(),
+	/** Frame width in CSS pixels (viewport options). */
+	width: finiteNumber.optional(),
+	/** The screen's height, for viewports taken from a device. Frames still grow with their content. */
+	height: finiteNumber.optional(),
+	/** What the viewport is, for its icon. Otherwise judged by its width. */
+	device: z.enum(deviceKinds).optional(),
+	/** Class added to the frame body, e.g. `dark` for shadcn themes. */
+	className: z.string().optional(),
+	/** Attributes set on the frame body, e.g. `lang` and `dir` for locales. */
+	attributes: z.record(z.string(), z.string()).optional()
+});
+const modeVariable = fileObject({
+	id: z.string(),
+	name: z.string(),
+	kind: z.enum(variableKinds),
+	options: z.array(variableOption).min(1, "expected at least one option")
+});
+const modeSpec = fileObject({
+	id: z.string(),
+	name: z.string(),
+	/** Option id per variable id. A variable that isn't listed uses its first option. */
+	values: z.record(z.string(), z.string())
+});
+/**
+* Project-wide modes, like Chromatic modes in Storybook. A variable is one axis of the environment (viewport, theme,
+* locale…); a mode is a named combination of one option per variable. Every design can show any mode, and each design
+* chooses which ones it shows. The first mode is the primary one: the main frame of every design.
+*/
+const modeSettings = fileObject({
+	$schema: z.string().optional(),
+	version: z.literal(1),
+	variables: z.array(modeVariable),
+	modes: z.array(modeSpec).min(1, "expected at least one mode")
+}).superRefine((settings, context) => {
+	for (const [index, mode] of settings.modes.entries()) for (const [variableId, optionId] of Object.entries(mode.values)) {
+		const path = [
+			"modes",
+			index,
+			"values",
+			variableId
+		];
+		const variable = settings.variables.find((candidate) => candidate.id === variableId);
+		if (!variable) context.addIssue({
+			code: "custom",
+			message: "unknown variable",
+			path,
+			input: variableId
 		});
-		if (options.length === 0) throw new TypeError(`${at}/options: expected at least one option`);
-		return {
-			id: expectString(variable.id, `${at}/id`),
-			name: expectString(variable.name, `${at}/name`),
-			kind: expectOneOf(variable.kind, variableKinds, `${at}/kind`),
-			options
-		};
-	});
-	const modes = expectArray(settings.modes, "/modes").map((item, index) => {
-		const at = `/modes/${index}`;
-		const mode = expectObject(item, at);
-		expectKnownKeys(mode, [
-			"id",
-			"name",
-			"values"
-		], at);
-		const values = {};
-		for (const [variableId, optionId] of Object.entries(expectObject(mode.values, `${at}/values`))) {
-			const variable = variables.find((candidate) => candidate.id === variableId);
-			if (!variable) throw new TypeError(`${at}/values/${variableId}: unknown variable`);
-			const option = expectString(optionId, `${at}/values/${variableId}`);
-			if (!variable.options.some((candidate) => candidate.id === option)) throw new TypeError(`${at}/values/${variableId}: "${option}" is not an option of ${variable.name}`);
-			values[variableId] = option;
+		else if (!variable.options.some((option) => option.id === optionId)) {
+			const message = `"${optionId}" is not an option of ${variable.name}`;
+			context.addIssue({
+				code: "custom",
+				message,
+				path,
+				input: optionId
+			});
 		}
-		return {
-			id: expectString(mode.id, `${at}/id`),
-			name: expectString(mode.name, `${at}/name`),
-			values
-		};
-	});
-	if (modes.length === 0) throw new TypeError("/modes: expected at least one mode");
-	return {
-		version: 1,
-		variables,
-		modes
-	};
-}
+	}
+});
 // ../core/src/edit.ts
 const idAlphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 /** A short random id that isn't in `taken`, for nodes and designs created in the editor or by agents. */
@@ -286,16 +238,45 @@ function generateId(taken, length = 5) {
 	}
 }
 // ../core/src/document.ts
+const position = fileObject({
+	x: finiteNumber,
+	y: finiteNumber
+});
 const canvasObjectKinds = [
 	"table",
 	"operation",
 	"route"
 ];
+const canvasObjectSpec = fileObject({
+	kind: z.enum(canvasObjectKinds),
+	/** A table as `schema.table`, an operation by its id, a route by its URL pattern. */
+	ref: z.string(),
+	position
+});
+/** The canvas objects, each table, operation and route at most once. */
+const canvasObjects = z.array(canvasObjectSpec).superRefine((objects, context) => {
+	const placed = /* @__PURE__ */ new Set();
+	for (const [index, { kind, ref }] of objects.entries()) {
+		const key = JSON.stringify([kind, ref]);
+		if (placed.has(key)) problem(context, [index], `the ${kind} "${ref}" is already on the canvas`);
+		placed.add(key);
+	}
+});
 const linkEndKinds = [
 	"screen",
 	"component",
 	...canvasObjectKinds
 ];
+const linkEnd = fileObject({
+	kind: z.enum(linkEndKinds),
+	ref: z.string()
+});
+const linkType = z.enum([
+	"shows",
+	"calls",
+	"reads",
+	"writes"
+]);
 /** Each type of link, and the kinds it may join, from and to. */
 const linkTypes = {
 	/** A screen shown at a route's URL. */
@@ -328,30 +309,301 @@ function linkAllowed(type, from, to) {
 	const allowed = linkTypes[type];
 	return allowed.from.includes(from) && allowed.to.includes(to);
 }
-const lenses = [
-	"data",
-	"api",
-	"routes"
+const linkSpec = fileObject({
+	id: z.string(),
+	type: linkType,
+	from: linkEnd,
+	to: linkEnd
+}).superRefine((link, context) => {
+	if (linkAllowed(link.type, link.from.kind, link.to.kind)) return;
+	const { from, to } = linkTypes[link.type];
+	const joined = `${from.join(" or ")} to ${to.join(" or ")}, not ${link.from.kind} to ${link.to.kind}`;
+	problem(context, [], `a ${link.type} link goes from ${joined}`);
+});
+/** The links the person drew, each id once. */
+const linkSpecs = z.array(linkSpec).superRefine((links, context) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, { id }] of links.entries()) {
+		if (ids.has(id)) problem(context, [index, "id"], `duplicate link id "${id}"`);
+		ids.add(id);
+	}
+});
+const lensSources = fileObject({
+	data: z.string().optional(),
+	api: z.string().optional(),
+	routes: z.string().optional()
+});
+const componentRef = fileObject({
+	path: z.string(),
+	export: z.string()
+});
+const detectionCorrections = fileObject({
+	include: z.array(componentRef).optional(),
+	exclude: z.unknown().optional()
+}).transform(({ exclude: _dropped, ...corrections }) => corrections);
+const noteSpec = fileObject({
+	id: z.string(),
+	text: z.string(),
+	position,
+	/** Wraps at this width; unset notes grow with their text. */
+	width: finiteNumber.optional()
+});
+/** Steps of the spacing scale (`4` is `calc(var(--spacing) * 4)`), or the name of a length token. */
+const length = z.union([finiteNumber, z.string()]);
+const sides = "expected a length, [vertical, horizontal] or [top, right, bottom, left]";
+const padding = z.union([
+	z.tuple([length, length], sides),
+	z.tuple([
+		length,
+		length,
+		length,
+		length
+	], sides),
+	length
+]);
+const alignment = z.enum([
+	"start",
+	"center",
+	"end",
+	"stretch"
+]);
+const nodeStyle = fileObject({
+	/** Auto layout (flex, the default) or a grid. */
+	display: z.enum(["flex", "grid"]).optional(),
+	direction: z.enum(["row", "column"]).optional(),
+	/** A grid's columns, all the same width; or rows, all the same height. */
+	columns: finiteNumber.optional(),
+	rows: finiteNumber.optional(),
+	gap: length.optional(),
+	/** In a grid or wrapping layout, the gap between rows when it differs from `gap`. */
+	rowGap: length.optional(),
+	/** All sides, `[vertical, horizontal]`, or `[top, right, bottom, left]`. */
+	padding: padding.optional(),
+	/** Space outside the node, in the same forms as padding. */
+	margin: padding.optional(),
+	/** Children on the cross axis. */
+	align: alignment.optional(),
+	/** Children on the main axis. */
+	justify: z.enum([
+		"start",
+		"center",
+		"end",
+		"between",
+		"around",
+		"evenly"
+	]).optional(),
+	wrap: z.boolean().optional(),
+	width: length.optional(),
+	height: length.optional(),
+	minWidth: length.optional(),
+	maxWidth: length.optional(),
+	minHeight: length.optional(),
+	maxHeight: length.optional(),
+	/** Grid cells the node spans, in a grid. */
+	colSpan: finiteNumber.optional(),
+	rowSpan: finiteNumber.optional(),
+	/** Fill along the parent's direction. Same as `fill` for the parent's main axis. */
+	grow: z.boolean().optional(),
+	/** Where this node sits on its parent's cross axis, overriding the parent's `align`. */
+	self: alignment.optional(),
+	position: z.enum(["absolute"]).optional(),
+	top: length.optional(),
+	right: length.optional(),
+	bottom: length.optional(),
+	left: length.optional(),
+	background: z.string().optional(),
+	foreground: z.string().optional(),
+	/** Border color. */
+	border: z.string().optional(),
+	/** Border width in pixels, as in Tailwind: 0, 1, 2, 4 or 8. */
+	borderWidth: finiteNumber.optional(),
+	borderStyle: z.enum([
+		"solid",
+		"dashed",
+		"dotted"
+	]).optional(),
+	radius: z.string().optional(),
+	shadow: z.string().optional(),
+	/** Percent, 0 to 100. */
+	opacity: finiteNumber.optional(),
+	overflow: z.enum([
+		"visible",
+		"hidden",
+		"scroll"
+	]).optional(),
+	font: z.string().optional(),
+	size: z.string().optional(),
+	weight: finiteNumber.optional(),
+	leading: z.string().optional(),
+	tracking: z.string().optional(),
+	textAlign: z.enum([
+		"start",
+		"center",
+		"end",
+		"justify"
+	]).optional(),
+	transform: z.enum([
+		"uppercase",
+		"lowercase",
+		"capitalize"
+	]).optional(),
+	decoration: z.enum(["underline", "line-through"]).optional(),
+	italic: z.boolean().optional(),
+	/** Lines of text before it's cut off with an ellipsis. */
+	lines: finiteNumber.optional()
+});
+const styleKey = nodeStyle.keyof();
+styleKey.options;
+const patchUnset = fileObject({
+	props: z.array(z.string()).optional(),
+	style: z.array(styleKey).optional()
+});
+const nodePatch = fileObject({
+	hidden: z.boolean().optional(),
+	text: z.string().optional(),
+	props: plainObject.optional(),
+	style: nodeStyle.optional(),
+	/** What the patch takes away from what's under it, so a state can turn off a prop or style the design sets. */
+	unset: patchUnset.optional()
+});
+/** Patches keyed by node id, or by `instance/inner` for a node inside an instance. */
+const nodePatches = z.record(z.string(), nodePatch);
+const nodeBinding = fileObject({
+	text: z.string().optional(),
+	props: z.record(z.string(), z.string()).optional(),
+	visible: z.string().optional()
+});
+const nodeBase = fileObject({
+	id: z.string(),
+	name: z.string().optional(),
+	hidden: z.boolean().optional(),
+	style: nodeStyle.optional(),
+	/**
+	* Patches applied in one viewport, keyed by the viewport option id from the project's modes. Layout changes per
+	* viewport live here, not in copies.
+	*/
+	responsive: nodePatches.optional(),
+	/**
+	* Inside a component design: which of this node's values come from the component's params, so each instance can
+	* show its own. `text` and `props` name a param; `visible` names a boolean param that shows or hides the node.
+	*/
+	bind: nodeBinding.optional()
+});
+const layoutNode = nodeBase.extend({
+	type: z.literal("layout"),
+	get children() {
+		return z.array(designNode);
+	}
+});
+const componentNode$1 = nodeBase.extend({
+	type: z.literal("component"),
+	component: z.string(),
+	props: plainObject.optional(),
+	/** Child nodes by slot. `children` is the default slot; other names become node-valued props. */
+	get slots() {
+		return z.record(z.string(), z.array(designNode)).optional();
+	}
+});
+const textNode = nodeBase.extend({
+	type: z.literal("text"),
+	text: z.string(),
+	tag: z.enum([
+		"p",
+		"span",
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"strong"
+	]).optional()
+});
+const instanceNode = nodeBase.extend({
+	type: z.literal("instance"),
+	/** The component design's id. */
+	design: z.string(),
+	args: plainObject.optional(),
+	/** Which of the component's states this copy shows. */
+	state: z.string().optional(),
+	/**
+	* What this copy changes inside the component, keyed by the inner node's id, or `nested/inner` for a node inside a
+	* nested instance. The copy stays linked: everything it doesn't change follows the component.
+	*/
+	overrides: nodePatches.optional()
+});
+const imageFits = [
+	"cover",
+	"contain",
+	"fill"
 ];
+const imageCredit = fileObject({
+	name: z.string(),
+	url: z.string(),
+	/** The library it came from. */
+	source: z.string().optional()
+});
+const imageNode = nodeBase.extend({
+	type: z.literal("image"),
+	/** A URL, or a path the project's dev server serves, like `/images/photo.jpg`. */
+	src: z.string(),
+	alt: z.string().optional(),
+	/** How it fills its box: cropped to cover it (the default), shown whole, or stretched. */
+	fit: z.enum(imageFits).optional(),
+	/** Who made it and where it came from, for photos that ask to be credited. */
+	credit: imageCredit.optional()
+});
+const designNode = z.discriminatedUnion("type", [
+	layoutNode,
+	componentNode$1,
+	textNode,
+	instanceNode,
+	imageNode
+]);
+/** A node tree as a design or an insertion holds it, each node with an id of its own. */
+const nodeTree = designNode.superRefine((root, context) => {
+	const ids = /* @__PURE__ */ new Set();
+	const visit = (node, path) => {
+		if (ids.has(node.id)) problem(context, [...path, "id"], `duplicate node id "${node.id}"`);
+		ids.add(node.id);
+		if (node.type === "layout") for (const [index, child] of node.children.entries()) visit(child, [
+			...path,
+			"children",
+			index
+		]);
+		else if (node.type === "component") for (const [slot, children] of Object.entries(node.slots ?? {})) for (const [index, child] of children.entries()) visit(child, [
+			...path,
+			"slots",
+			slot,
+			index
+		]);
+	};
+	visit(root, []);
+});
+/** Calls `visit` for every node in a tree, depth first, including nodes in slots. */
+function walkNodes(node, visit, depth = 0) {
+	visit(node, depth);
+	let children = [];
+	if (node.type === "layout") children = node.children;
+	else if (node.type === "component") children = Object.values(node.slots ?? {}).flat();
+	for (const child of children) walkNodes(child, visit, depth + 1);
+}
 const containerKinds = [
 	"screen",
 	"component",
 	"frame"
 ];
-const textTags = [
-	"p",
-	"span",
-	"h1",
-	"h2",
-	"h3",
-	"h4",
-	"strong"
-];
-const imageFits = [
-	"cover",
-	"contain",
-	"fill"
-];
+const frameSize = fileObject({
+	width: finiteNumber.optional(),
+	height: finiteNumber.optional()
+});
+const variantOption = fileObject({
+	id: z.string(),
+	name: z.string(),
+	/**
+	* Patches keyed by node id, or by `instance/inner` for a node inside an instance. They apply over the design and
+	* under its states.
+	*/
+	overrides: nodePatches.optional()
+});
 const paramTypes = [
 	"text",
 	"boolean",
@@ -359,596 +611,178 @@ const paramTypes = [
 	"value",
 	"variant"
 ];
-const alignments = [
-	"start",
-	"center",
-	"end",
-	"stretch"
-];
-const justifications = [
-	"start",
-	"center",
-	"end",
-	"between",
-	"around",
-	"evenly"
-];
-/** Every style key, in the order panels show them. */
-const styleKeys = [
-	"display",
-	"direction",
-	"columns",
-	"rows",
-	"gap",
-	"rowGap",
-	"padding",
-	"margin",
-	"align",
-	"justify",
-	"wrap",
-	"width",
-	"height",
-	"minWidth",
-	"maxWidth",
-	"minHeight",
-	"maxHeight",
-	"colSpan",
-	"rowSpan",
-	"grow",
-	"self",
-	"position",
-	"top",
-	"right",
-	"bottom",
-	"left",
-	"background",
-	"foreground",
-	"border",
-	"borderWidth",
-	"borderStyle",
-	"radius",
-	"shadow",
-	"opacity",
-	"overflow",
-	"font",
-	"size",
-	"weight",
-	"leading",
-	"tracking",
-	"textAlign",
-	"transform",
-	"decoration",
-	"italic",
-	"lines"
-];
-function parseCanvasDocument(value) {
-	const document = expectObject(value, "");
-	if (document.version !== 3) throw new TypeError("/version: expected 3");
-	expectKnownKeys(document, [
-		"version",
-		"containers",
-		"notes",
-		"modes",
-		"detection",
-		"objects",
-		"links",
-		"sources"
-	], "");
-	return compact({
-		version: 3,
-		containers: expectArray(document.containers, "/containers").map((item, index) => parseContainer(item, `/containers/${index}`)),
-		modes: optional(document.modes, (value) => parseModeSettings(value)),
-		notes: optional(document.notes, (value) => expectArray(value, "/notes").map((item, index) => parseNote(item, `/notes/${index}`))),
-		detection: optional(document.detection, (value) => parseDetection(value, "/detection")),
-		objects: optional(document.objects, (value) => parseObjects(value, "/objects")),
-		links: optional(document.links, (value) => parseLinks(value, "/links")),
-		sources: optional(document.sources, (value) => parseSources(value, "/sources"))
-	});
-}
-function parsePosition(value, path) {
-	const position = expectObject(value, path);
-	expectKnownKeys(position, ["x", "y"], path);
-	return {
-		x: expectNumber(position.x, `${path}/x`),
-		y: expectNumber(position.y, `${path}/y`)
-	};
-}
-function parseObjects(value, path) {
-	const placed = /* @__PURE__ */ new Set();
-	return expectArray(value, path).map((item, index) => {
-		const at = `${path}/${index}`;
-		const object = expectObject(item, at);
-		expectKnownKeys(object, [
-			"kind",
-			"ref",
-			"position"
-		], at);
-		const kind = expectOneOf(object.kind, canvasObjectKinds, `${at}/kind`);
-		const ref = expectString(object.ref, `${at}/ref`);
-		const key = JSON.stringify([kind, ref]);
-		if (placed.has(key)) throw new TypeError(`${at}: the ${kind} "${ref}" is already on the canvas`);
-		placed.add(key);
-		return {
-			kind,
-			ref,
-			position: parsePosition(object.position, `${at}/position`)
-		};
-	});
-}
-function parseLinkEnd(value, path) {
-	const end = expectObject(value, path);
-	expectKnownKeys(end, ["kind", "ref"], path);
-	return {
-		kind: expectOneOf(end.kind, linkEndKinds, `${path}/kind`),
-		ref: expectString(end.ref, `${path}/ref`)
-	};
-}
-function parseLinks(value, path) {
+const paramSpec = fileObject({
+	type: z.enum(paramTypes),
+	/** A variant's default is the id of one of its options; unset means the first. */
+	default: z.unknown().optional(),
+	description: z.string().optional(),
+	/** A variant's choices: size small, medium or large. Each option patches the design, the way a state does. */
+	options: z.array(variantOption).optional()
+}).superRefine((param, context) => {
 	const ids = /* @__PURE__ */ new Set();
-	const types = Object.keys(linkTypes);
-	return expectArray(value, path).map((item, index) => {
-		const at = `${path}/${index}`;
-		const link = expectObject(item, at);
-		expectKnownKeys(link, [
-			"id",
-			"type",
-			"from",
-			"to"
-		], at);
-		const id = expectString(link.id, `${at}/id`);
-		if (ids.has(id)) throw new TypeError(`${at}/id: duplicate link id "${id}"`);
+	for (const [index, { id }] of (param.options ?? []).entries()) {
+		if (ids.has(id)) problem(context, [
+			"options",
+			index,
+			"id"
+		], `duplicate option id "${id}"`);
 		ids.add(id);
-		const type = expectOneOf(link.type, types, `${at}/type`);
-		const from = parseLinkEnd(link.from, `${at}/from`);
-		const to = parseLinkEnd(link.to, `${at}/to`);
-		if (!linkAllowed(type, from.kind, to.kind)) {
-			const { from: froms, to: tos } = linkTypes[type];
-			throw new TypeError(`${at}: a ${type} link goes from ${froms.join(" or ")} to ${tos.join(" or ")}, not ${from.kind} to ${to.kind}`);
-		}
-		return {
-			id,
-			type,
-			from,
-			to
-		};
-	});
-}
-function parseSources(value, path) {
-	const sources = expectObject(value, path);
-	expectKnownKeys(sources, lenses, path);
-	const chosen = {};
-	for (const lens of lenses) if (sources[lens] !== void 0) chosen[lens] = expectString(sources[lens], `${path}/${lens}`);
-	return chosen;
-}
-function parseDetection(value, path) {
-	const detection = expectObject(value, path);
-	expectKnownKeys(detection, ["include", "exclude"], path);
-	const refs = (list, at) => expectArray(list, at).map((item, index) => {
-		const ref = expectObject(item, `${at}/${index}`);
-		expectKnownKeys(ref, ["path", "export"], `${at}/${index}`);
-		return {
-			path: expectString(ref.path, `${at}/${index}/path`),
-			export: expectString(ref.export, `${at}/${index}/export`)
-		};
-	});
-	return compact({ include: optional(detection.include, (list) => refs(list, `${path}/include`)) });
-}
-function parseNote(value, path) {
-	const note = expectObject(value, path);
-	expectKnownKeys(note, [
-		"id",
-		"text",
-		"position",
-		"width"
-	], path);
-	const position = expectObject(note.position, `${path}/position`);
-	return compact({
-		id: expectString(note.id, `${path}/id`),
-		text: expectString(note.text, `${path}/text`),
-		position: {
-			x: expectNumber(position.x, `${path}/position/x`),
-			y: expectNumber(position.y, `${path}/position/y`)
-		},
-		width: optional(note.width, (v) => expectNumber(v, `${path}/width`))
-	});
-}
-function parseContainer(value, path) {
-	const container = expectObject(value, path);
-	expectKnownKeys(container, [
-		"id",
-		"name",
-		"kind",
-		"position",
-		"root",
+	}
+	if (param.type === "variant" && !param.options?.length) problem(context, ["options"], "a variant needs options");
+	if (param.type !== "variant" && param.options) problem(context, ["options"], "only variants have options");
+});
+const containerViewSettings = fileObject({
+	/** The mode of the main frame. Defaults to the project's primary mode. */
+	mode: z.string().optional(),
+	/** Other modes shown beside the main frame. */
+	modes: z.array(z.string()).optional(),
+	/** The state the canvas shows. Defaults to the first. */
+	state: z.string().optional(),
+	/** Show every state, one row each, instead of only the active one. */
+	allStates: z.boolean().optional(),
+	/** The option the board shows for each variant param, by option id. Unset ones show their default. */
+	variants: z.record(z.string(), z.string()).optional()
+});
+const stateSpec = fileObject({
+	id: z.string(),
+	name: z.string(),
+	/**
+	* Patches keyed by node id, or by `instance/inner` for a node inside an instance. A state wins over a viewport's
+	* responsive patch and over the design's variants.
+	*/
+	overrides: nodePatches.optional()
+});
+const containerSpec = fileObject({
+	id: z.string(),
+	name: z.string(),
+	/** Defaults to `screen`. */
+	kind: z.enum(containerKinds).optional(),
+	position,
+	root: nodeTree,
+	states: z.array(stateSpec).min(1, "expected at least one state"),
+	view: containerViewSettings.optional(),
+	/** A component's inputs. Instances pass values for them; nodes inside bind to them. */
+	params: z.record(z.string(), paramSpec).optional(),
+	/**
+	* Components this design sits inside when shown on its own board, outermost first, like a Storybook decorator: a
+	* table row needs a table around it to render properly.
+	*/
+	context: z.array(fileObject({
+		component: z.string(),
+		props: plainObject.optional()
+	})).optional(),
+	/**
+	* A screen's or component's frame sizes in CSS pixels, keyed by viewport option id. Without one, a frame is as wide
+	* as its mode's viewport and as tall as its content.
+	*/
+	frames: z.record(z.string(), frameSize).optional(),
+	/**
+	* A frame's own size in CSS pixels, whatever the project's viewports are. Without a width it's as wide as the primary
+	* mode's viewport, and without a height as tall as its content. Only a frame has one.
+	*/
+	size: frameSize.optional()
+}).superRefine((container, context) => {
+	const ids = /* @__PURE__ */ new Set();
+	walkNodes(container.root, (node) => ids.add(node.id));
+	for (const [index, state] of container.states.entries()) checkPatchKeys(state.overrides, ids, context, [
 		"states",
-		"view",
+		index,
+		"overrides"
+	]);
+	if (container.kind === "frame") checkFrame(container, context);
+	else if (container.size !== void 0) problem(context, ["size"], `only a frame has a size of its own; size a ${container.kind ?? "screen"} in frames`);
+	for (const [name, param] of Object.entries(container.params ?? {})) for (const [index, option] of (param.options ?? []).entries()) checkPatchKeys(option.overrides, ids, context, [
 		"params",
-		"context",
-		"frames",
-		"size"
-	], path);
-	const position = expectObject(container.position, `${path}/position`);
-	const view = optional(container.view, (v) => {
-		const settings = expectObject(v, `${path}/view`);
-		expectKnownKeys(settings, [
-			"mode",
-			"modes",
-			"state",
-			"allStates",
-			"variants"
-		], `${path}/view`);
-		return compact({
-			mode: optional(settings.mode, (mode) => expectString(mode, `${path}/view/mode`)),
-			modes: optional(settings.modes, (list) => expectArray(list, `${path}/view/modes`).map((mode, index) => expectString(mode, `${path}/view/modes/${index}`))),
-			state: optional(settings.state, (state) => expectString(state, `${path}/view/state`)),
-			allStates: optional(settings.allStates, (all) => expectBoolean(all, `${path}/view/allStates`)),
-			variants: optional(settings.variants, (choices) => {
-				const variants = {};
-				for (const [param, option] of Object.entries(expectObject(choices, `${path}/view/variants`))) variants[param] = expectString(option, `${path}/view/variants/${param}`);
-				return variants;
-			})
-		});
-	});
-	const ids = /* @__PURE__ */ new Set();
-	const root = parseNode(container.root, `${path}/root`, ids);
-	const states = expectArray(container.states, `${path}/states`).map((item, index) => {
-		const at = `${path}/states/${index}`;
-		const state = expectObject(item, at);
-		expectKnownKeys(state, [
-			"id",
-			"name",
-			"overrides"
-		], at);
-		return {
-			id: expectString(state.id, `${at}/id`),
-			name: expectString(state.name, `${at}/name`),
-			overrides: optional(state.overrides, (v) => parsePatches(v, `${at}/overrides`, ids))
-		};
-	});
-	if (states.length === 0) throw new TypeError(`${path}/states: expected at least one state`);
-	const kind = optional(container.kind, (v) => expectOneOf(v, containerKinds, `${path}/kind`));
-	if (kind === "frame") checkFrame(container, root, states, path);
-	else if (container.size !== void 0) throw new TypeError(`${path}/size: only a frame has a size of its own; size a ${kind ?? "screen"} in frames`);
-	return compact({
-		id: expectString(container.id, `${path}/id`),
-		name: expectString(container.name, `${path}/name`),
-		kind,
-		context: optional(container.context, (v) => expectArray(v, `${path}/context`).map((item, index) => {
-			const at = `${path}/context/${index}`;
-			const wrapper = expectObject(item, at);
-			expectKnownKeys(wrapper, ["component", "props"], at);
-			return compact({
-				component: expectString(wrapper.component, `${at}/component`),
-				props: optional(wrapper.props, (p) => expectObject(p, `${at}/props`))
-			});
-		})),
-		params: optional(container.params, (v) => {
-			const params = {};
-			for (const [name, entry] of Object.entries(expectObject(v, `${path}/params`))) {
-				const at = `${path}/params/${name}`;
-				const param = expectObject(entry, at);
-				expectKnownKeys(param, [
-					"type",
-					"default",
-					"description",
-					"options"
-				], at);
-				const type = expectOneOf(param.type, paramTypes, `${at}/type`);
-				const options = optional(param.options, (list) => {
-					const seen = /* @__PURE__ */ new Set();
-					return expectArray(list, `${at}/options`).map((item, index) => {
-						const where = `${at}/options/${index}`;
-						const option = expectObject(item, where);
-						expectKnownKeys(option, [
-							"id",
-							"name",
-							"overrides"
-						], where);
-						const id = expectString(option.id, `${where}/id`);
-						if (seen.has(id)) throw new TypeError(`${where}/id: duplicate option id "${id}"`);
-						seen.add(id);
-						return compact({
-							id,
-							name: expectString(option.name, `${where}/name`),
-							overrides: optional(option.overrides, (v) => parsePatches(v, `${where}/overrides`, ids))
-						});
-					});
-				});
-				if (type === "variant" && !options?.length) throw new TypeError(`${at}/options: a variant needs options`);
-				if (type !== "variant" && options) throw new TypeError(`${at}/options: only variants have options`);
-				params[name] = compact({
-					type,
-					default: param.default,
-					description: optional(param.description, (d) => expectString(d, `${at}/description`)),
-					options
-				});
-			}
-			return params;
-		}),
-		frames: optional(container.frames, (v) => {
-			const frames = {};
-			for (const [viewport, entry] of Object.entries(expectObject(v, `${path}/frames`))) frames[viewport] = parseFrameSize(entry, `${path}/frames/${viewport}`);
-			return frames;
-		}),
-		size: optional(container.size, (v) => parseFrameSize(v, `${path}/size`)),
-		position: {
-			x: expectNumber(position.x, `${path}/position/x`),
-			y: expectNumber(position.y, `${path}/position/y`)
-		},
-		root,
-		states,
-		view
-	});
-}
-function parseFrameSize(value, path) {
-	const size = expectObject(value, path);
-	expectKnownKeys(size, ["width", "height"], path);
-	return compact({
-		width: optional(size.width, (w) => expectNumber(w, `${path}/width`)),
-		height: optional(size.height, (h) => expectNumber(h, `${path}/height`))
-	});
+		name,
+		"options",
+		index,
+		"overrides"
+	]);
+});
+/**
+* A design's patches keyed by its own nodes. A key names a node of the design, or starts with one: `instance/inner`
+* reaches inside an instance, which can't be checked without the component.
+*/
+function checkPatchKeys(patches, ids, context, path) {
+	for (const key of Object.keys(patches ?? {})) {
+		const [node] = key.split("/");
+		if (!ids.has(node)) problem(context, [...path, key], "no node has this id");
+	}
 }
 /**
 * What a frame may hold: a layout at its root and one state, drawn as its layers are, with no params, no view (it
 * shows only the primary mode and that state) and no sizes per viewport, since it has one of its own.
 */
-function checkFrame(container, root, states, path) {
-	if (root.type !== "layout") throw new TypeError(`${path}/root: a frame's root is a layout`);
-	if (states.length > 1) throw new TypeError(`${path}/states: a frame has one state`);
-	if (Object.keys(states[0].overrides ?? {}).length > 0) throw new TypeError(`${path}/states/0/overrides: a frame is drawn as its layers are`);
-	if (container.params !== void 0) throw new TypeError(`${path}/params: a frame has no params`);
-	if (container.view !== void 0) throw new TypeError(`${path}/view: a frame shows only the primary mode and its one state`);
-	if (container.frames !== void 0) throw new TypeError(`${path}/frames: a frame's size is in size, not per viewport`);
+function checkFrame(frame, context) {
+	if (frame.root.type !== "layout") problem(context, ["root"], "a frame's root is a layout");
+	if (frame.states.length > 1) problem(context, ["states"], "a frame has one state");
+	if (Object.keys(frame.states[0]?.overrides ?? {}).length > 0) problem(context, [
+		"states",
+		0,
+		"overrides"
+	], "a frame is drawn as its layers are");
+	if (frame.params !== void 0) problem(context, ["params"], "a frame has no params");
+	if (frame.view !== void 0) problem(context, ["view"], "a frame shows only the primary mode and its one state");
+	if (frame.frames !== void 0) problem(context, ["frames"], "a frame's size is in size, not per viewport");
 }
-function parseNode(value, path, ids) {
-	const node = expectObject(value, path);
-	const type = expectOneOf(node.type, [
-		"layout",
-		"component",
-		"text",
-		"instance",
-		"image"
-	], `${path}/type`);
-	const id = expectString(node.id, `${path}/id`);
-	if (ids.has(id)) throw new TypeError(`${path}/id: duplicate node id "${id}"`);
-	ids.add(id);
-	const base = compact({
-		id,
-		name: optional(node.name, (v) => expectString(v, `${path}/name`)),
-		hidden: optional(node.hidden, (v) => expectBoolean(v, `${path}/hidden`)),
-		style: optional(node.style, (v) => parseStyle(v, `${path}/style`)),
-		responsive: optional(node.responsive, (v) => parsePatches(v, `${path}/responsive`)),
-		bind: optional(node.bind, (v) => parseBinding(v, `${path}/bind`))
+/** A rule's problem with the value it checks, at `path` inside that value. */
+function problem(context, path, message) {
+	context.addIssue({
+		code: "custom",
+		message,
+		path
 	});
-	const common = [
-		"type",
-		"id",
-		"name",
-		"hidden",
-		"style",
-		"responsive",
-		"bind"
-	];
-	switch (type) {
-		case "layout":
-			expectKnownKeys(node, [...common, "children"], path);
-			return {
-				...base,
-				type,
-				children: expectArray(node.children, `${path}/children`).map((child, index) => parseNode(child, `${path}/children/${index}`, ids))
-			};
-		case "component": {
-			expectKnownKeys(node, [
-				...common,
-				"component",
-				"props",
-				"slots"
-			], path);
-			const slots = optional(node.slots, (v) => {
-				const result = {};
-				for (const [slot, children] of Object.entries(expectObject(v, `${path}/slots`))) result[slot] = expectArray(children, `${path}/slots/${slot}`).map((child, index) => parseNode(child, `${path}/slots/${slot}/${index}`, ids));
-				return result;
-			});
-			return {
-				...base,
-				type,
-				component: expectString(node.component, `${path}/component`),
-				props: optional(node.props, (v) => expectObject(v, `${path}/props`)),
-				slots
-			};
-		}
-		case "instance":
-			expectKnownKeys(node, [
-				...common,
-				"design",
-				"args",
-				"state",
-				"overrides"
-			], path);
-			return compact({
-				...base,
-				type,
-				design: expectString(node.design, `${path}/design`),
-				args: optional(node.args, (v) => expectObject(v, `${path}/args`)),
-				state: optional(node.state, (v) => expectString(v, `${path}/state`)),
-				overrides: optional(node.overrides, (v) => parsePatches(v, `${path}/overrides`))
-			});
-		case "text":
-			expectKnownKeys(node, [
-				...common,
-				"text",
-				"tag"
-			], path);
-			return {
-				...base,
-				type,
-				text: expectString(node.text, `${path}/text`),
-				tag: optional(node.tag, (v) => expectOneOf(v, textTags, `${path}/tag`))
-			};
-		case "image":
-			expectKnownKeys(node, [
-				...common,
-				"src",
-				"alt",
-				"fit",
-				"credit"
-			], path);
-			return compact({
-				...base,
-				type,
-				src: expectString(node.src, `${path}/src`),
-				alt: optional(node.alt, (v) => expectString(v, `${path}/alt`)),
-				fit: optional(node.fit, (v) => expectOneOf(v, imageFits, `${path}/fit`)),
-				credit: optional(node.credit, (v) => {
-					const credit = expectObject(v, `${path}/credit`);
-					expectKnownKeys(credit, [
-						"name",
-						"url",
-						"source"
-					], `${path}/credit`);
-					return compact({
-						name: expectString(credit.name, `${path}/credit/name`),
-						url: expectString(credit.url, `${path}/credit/url`),
-						source: optional(credit.source, (s) => expectString(s, `${path}/credit/source`))
-					});
-				})
-			});
-	}
 }
-function parseBinding(value, path) {
-	const binding = expectObject(value, path);
-	expectKnownKeys(binding, [
-		"text",
-		"props",
-		"visible"
-	], path);
-	return compact({
-		text: optional(binding.text, (v) => expectString(v, `${path}/text`)),
-		visible: optional(binding.visible, (v) => expectString(v, `${path}/visible`)),
-		props: optional(binding.props, (v) => {
-			const props = {};
-			for (const [prop, param] of Object.entries(expectObject(v, `${path}/props`))) props[prop] = expectString(param, `${path}/props/${prop}`);
-			return props;
-		})
-	});
+const canvasDocument = fileObject({
+	version: z.literal(3),
+	containers: z.array(containerSpec),
+	/** The project's modes. Unset means the defaults. */
+	modes: modeSettings.optional(),
+	/** Text placed on the canvas itself, outside any design: annotations, flow labels, explanations. */
+	notes: z.array(noteSpec).optional(),
+	/** Where the person corrected which exports are components. Unset while detection gets them right. */
+	detection: detectionCorrections.optional(),
+	/** Where the person put tables, operations and routes on the canvas. The models are read from the project. */
+	objects: canvasObjects.optional(),
+	/** Links the person drew by hand. Links found in code or traces are read each time and never saved. */
+	links: linkSpecs.optional(),
+	/** 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);
 }
-/**
-* Patches keyed by node id. With `ids`, each key must name a node of the design, or start with one: `instance/inner`
-* reaches inside an instance, which can't be checked without the component.
-*/
-function parsePatches(value, path, ids) {
-	const patches = {};
-	for (const [key, entry] of Object.entries(expectObject(value, path))) {
-		if (ids && !ids.has(key.split("/")[0])) throw new TypeError(`${path}/${key}: no node has this id`);
-		patches[key] = parsePatch(entry, `${path}/${key}`);
-	}
-	return patches;
+// ../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 parsePatch(value, path) {
-	const patch = expectObject(value, path);
-	expectKnownKeys(patch, [
-		"hidden",
-		"text",
-		"props",
-		"style",
-		"unset"
-	], path);
-	return compact({
-		hidden: optional(patch.hidden, (v) => expectBoolean(v, `${path}/hidden`)),
-		text: optional(patch.text, (v) => expectString(v, `${path}/text`)),
-		props: optional(patch.props, (v) => expectObject(v, `${path}/props`)),
-		style: optional(patch.style, (v) => parseStyle(v, `${path}/style`)),
-		unset: optional(patch.unset, (v) => parseUnset(v, `${path}/unset`))
-	});
+function expectString(value, path) {
+	if (typeof value !== "string") throw new TypeError(`${path}: expected a string`);
+	return value;
 }
-function parseUnset(value, path) {
-	const unset = expectObject(value, path);
-	expectKnownKeys(unset, ["props", "style"], path);
-	const keys = (key, item) => optional(unset[key], (v) => expectArray(v, `${path}/${key}`).map((entry, index) => item(entry, `${path}/${key}/${index}`)));
-	return compact({
-		props: keys("props", expectString),
-		style: keys("style", (v, where) => expectOneOf(v, styleKeys, where))
-	});
+function expectNumber(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${path}: expected a number`);
+	return value;
 }
-function parseStyle(value, path) {
-	const style = expectObject(value, path);
-	const at = (key) => `${path}/${key}`;
-	const token = (key) => optional(style[key], (v) => expectString(v, at(key)));
-	const number = (key) => optional(style[key], (v) => expectNumber(v, at(key)));
-	const flag = (key) => optional(style[key], (v) => expectBoolean(v, at(key)));
-	const lengthAt = (v, where) => typeof v === "number" ? v : expectString(v, where);
-	const length = (key) => optional(style[key], (v) => lengthAt(v, at(key)));
-	const size = (key) => optional(style[key], (v) => lengthAt(v, at(key)));
-	const sides = (key) => optional(style[key], (v) => {
-		if (!Array.isArray(v)) return lengthAt(v, at(key));
-		if (v.length !== 2 && v.length !== 4) throw new TypeError(`${at(key)}: expected a length, [vertical, horizontal] or [top, right, bottom, left]`);
-		return v.map((side, index) => lengthAt(side, `${at(key)}/${index}`));
-	});
-	expectKnownKeys(style, styleKeys, path);
-	return compact({
-		display: optional(style.display, (v) => expectOneOf(v, ["flex", "grid"], at("display"))),
-		direction: optional(style.direction, (v) => expectOneOf(v, ["row", "column"], at("direction"))),
-		columns: number("columns"),
-		rows: number("rows"),
-		gap: length("gap"),
-		rowGap: length("rowGap"),
-		padding: sides("padding"),
-		margin: sides("margin"),
-		align: optional(style.align, (v) => expectOneOf(v, alignments, at("align"))),
-		justify: optional(style.justify, (v) => expectOneOf(v, justifications, at("justify"))),
-		wrap: flag("wrap"),
-		width: size("width"),
-		height: size("height"),
-		minWidth: length("minWidth"),
-		maxWidth: length("maxWidth"),
-		minHeight: length("minHeight"),
-		maxHeight: length("maxHeight"),
-		colSpan: number("colSpan"),
-		rowSpan: number("rowSpan"),
-		grow: flag("grow"),
-		self: optional(style.self, (v) => expectOneOf(v, alignments, at("self"))),
-		position: optional(style.position, (v) => expectOneOf(v, ["absolute"], at("position"))),
-		top: length("top"),
-		right: length("right"),
-		bottom: length("bottom"),
-		left: length("left"),
-		background: token("background"),
-		foreground: token("foreground"),
-		border: token("border"),
-		borderWidth: number("borderWidth"),
-		borderStyle: optional(style.borderStyle, (v) => expectOneOf(v, [
-			"solid",
-			"dashed",
-			"dotted"
-		], at("borderStyle"))),
-		radius: token("radius"),
-		shadow: token("shadow"),
-		opacity: number("opacity"),
-		overflow: optional(style.overflow, (v) => expectOneOf(v, [
-			"visible",
-			"hidden",
-			"scroll"
-		], at("overflow"))),
-		font: token("font"),
-		size: token("size"),
-		weight: number("weight"),
-		leading: token("leading"),
-		tracking: token("tracking"),
-		textAlign: optional(style.textAlign, (v) => expectOneOf(v, [
-			"start",
-			"center",
-			"end",
-			"justify"
-		], at("textAlign"))),
-		transform: optional(style.transform, (v) => expectOneOf(v, [
-			"uppercase",
-			"lowercase",
-			"capitalize"
-		], at("transform"))),
-		decoration: optional(style.decoration, (v) => expectOneOf(v, ["underline", "line-through"], at("decoration"))),
-		italic: flag("italic"),
-		lines: number("lines")
-	});
+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
 /** How a component was recognised, which is also why it's believed to be one. */
@@ -1358,6 +1192,16 @@ function expectStringRecord(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
+* what opens or chooses its items by value (an accordion, a navigation menu, tabs) and `value` on those items.
+*/
+const openProps = [
+	"defaultOpen",
+	"defaultValue",
+	"value"
+];
 // ../core/src/library-insert.ts
 /** Nodes whose `children` is the name `componentNode` gave them, rather than text someone set. */
 const named = /* @__PURE__ */ new WeakSet();
@@ -1574,6 +1418,8 @@ function elementProps(props) {
 * Discovery has already rewritten module imports for the name the project installed the package under.
 */
 function librarySource(library, name, component, path) {
+	const declared = new Set(Object.keys(component.props ?? {}).map((prop) => prop.replace(/\?$/, "")));
+	const open = openProps.filter((prop) => declared.has(prop));
 	return {
 		path,
 		export: name,
@@ -1585,7 +1431,8 @@ function librarySource(library, name, component, path) {
 		...component.visual === false ? { visual: false } : {},
 		...component.optionalParents ? { optionalParents: component.optionalParents.map((parent) => `${library}/${parent}`) } : {},
 		...component.parentParts ? { parentParts: true } : {},
-		...component.sample ? { sample: sampleIds(component.sample, library) } : {}
+		...component.sample ? { sample: sampleIds(component.sample, library) } : {},
+		...open.length > 0 ? { openProps: open } : {}
 	};
 }
 /**
@@ -1620,4 +1467,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, 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 };
+export { viewportWidthProperty as A, parseCanvasDocument as C, collectCustomProperties as D, modeSettings as E, lengthToPixels as M, packageManifest as N, remProperty as O, paramTypes as S, generateId as T, containerKinds as _, openProps as a, linkEndKinds as b, isMadeValue as c, libraryManifestExtension as d, parentSignals as f, canvasObjectKinds as g, renderSlotOf as h, withLibraryContext as i, deviceKinds as j, viewportHeightProperty 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, imageFits as v, walkNodes as w, linkTypes as x, linkAllowed as y };