@parity-app/cli 0.4.0 → 0.5.1

package/dist/{client-Cf66-n3R.mjs → client-CoW-KcnT.mjs}

@@ -1,35 +1,38 @@
+import { c as unknownReference, n as nonBlankString, r as CodedError, s as readErrorDetails, t as jsonText } from "./schema-BpGSCLEu.mjs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";
 import { homedir } from "node:os";
+import { z } from "zod";
+// ../agent/src/routing.ts
+/**
+* Which running copy of Parity an agent's call goes to (PAR-514). Several copies can run at once, each with its own
+* projects open: the person's app, a dev session, `pnpm perf`. Agents care about the project, not the copy, so every
+* call is sent to the copy that has its project open. The CLI decides, once, with these rules, and sends that copy the
+* exact tab it chose; the app matches a tab reference with the same `matchTab`. Nothing here touches files or the
+* network, so the app's renderer can use it too.
+*/
+/** How to reach one running copy: what it writes to its registry entry. A number an entry lacks reads as 0. */
+const copyEntry = z.object({
+	version: z.number().catch(0),
+	url: z.string(),
+	token: z.string(),
+	/** The app's main process, which names the copy and its entry. A service the app restarts is the same copy. */
+	app: z.number(),
+	/** When the copy started, in milliseconds since the epoch. A project open in two copies goes to the older one. */
+	startedAt: z.number().catch(0)
+});
+/** An entry's text. The file from before the registry names the app's main process `pid`. */
+const entryText = jsonText(copyEntry.extend({
+	app: z.number().optional().catch(void 0),
+	pid: z.number().optional().catch(void 0)
+}).transform(({ app, pid, ...entry }) => ({
+	...entry,
+	app: app ?? pid ?? 0
+})));
 /** Reads a registry entry's text, or nothing when it isn't one. A file from before the registry stands for its copy. */
 function readCopyEntry(text) {
-	if (text === void 0) return void 0;
-	let value;
-	try {
-		value = JSON.parse(text);
-	} catch {
-		return;
-	}
-	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-	const fields = new Map(Object.entries(value));
-	const [version, url, token, app, pid, startedAt] = [
-		"version",
-		"url",
-		"token",
-		"app",
-		"pid",
-		"startedAt"
-	].map((key) => fields.get(key));
-	if (typeof url !== "string" || typeof token !== "string") return void 0;
-	const number = (field) => typeof field === "number" ? field : void 0;
-	return {
-		version: number(version) ?? 0,
-		url,
-		token,
-		app: number(app) ?? number(pid) ?? 0,
-		startedAt: number(startedAt) ?? 0
-	};
+	return entryText.safeParse(text).data;
 }
 /**
 * A project folder as routing compares it: forward slashes, no trailing slash, and on Windows (a drive letter or a
@@ -160,15 +163,21 @@ function byAge(a, b) {
 	return a.entry.startedAt - b.entry.startedAt || a.entry.app - b.entry.app;
 }
 // ../agent/src/registry.ts
+/** The settings that place the registry. One that's blank counts as unset. */
+const registrySettings = z.object({
+	PARITY_AGENT_FILE: nonBlankString.optional().catch(void 0),
+	PARITY_AGENT_DIR: nonBlankString.optional().catch(void 0)
+});
 /** The registry these settings name: `PARITY_AGENT_FILE`, else `PARITY_AGENT_DIR`, else `~/.parity/agents`. */
 function agentRegistry(env, home) {
-	if (env.PARITY_AGENT_FILE) return {
+	const { PARITY_AGENT_FILE: file, PARITY_AGENT_DIR: folder } = registrySettings.parse(env);
+	if (file) return {
 		kind: "file",
-		path: env.PARITY_AGENT_FILE
+		path: file
 	};
 	return {
 		kind: "folder",
-		path: env.PARITY_AGENT_DIR || join(home, ".parity", "agents")
+		path: folder ?? join(home, ".parity", "agents")
 	};
 }
 /** The file before the registry, where an app from before it says how to reach it. */
@@ -221,105 +230,10 @@ function readText(path) {
 		return;
 	}
 }
-// ../core/src/errors.ts
-/**
-* Why an agent's call failed, as a stable code it can act on without reading the message. The CLI and MCP publish
-* these; the app throws them where it knows the cause.
-*/
-const errorCodes = [
-	"invalid_input",
-	"not_running",
-	"not_answering",
-	"unknown_tab",
-	"tab_not_ready",
-	"unknown_design",
-	"unknown_node",
-	"ambiguous_reference",
-	"unknown_state",
-	"unknown_mode",
-	"unknown_viewport",
-	"unknown_component",
-	"unknown_icon_set",
-	"unknown_edit_id",
-	"conflict",
-	"execution_failed",
-	"app_error"
-];
-/** An error with a stable code, the field it's about and what to use instead. */
-var CodedError = class extends Error {
-	details;
-	constructor(message, details) {
-		super(message);
-		this.name = "CodedError";
-		this.details = {
-			...details,
-			retryable: details.retryable ?? false
-		};
-	}
-};
-/** An unknown reference, naming the valid ones closest to what was asked for, up to `alternativeLimit`. */
-function unknownReference(code, message, reference, candidates, field) {
-	return new CodedError(message, {
-		code,
-		...field === void 0 ? {} : { field },
-		alternatives: closest(reference, candidates)
-	});
-}
-/**
-* Candidates sharing text with the reference first, ignoring case, then the rest by how few single-character edits
-* away they are, so a typo's intended id makes the cut; ties keep their own order. All of them when they fit.
-*/
-function closest(reference, candidates, limit = 20) {
-	const unique = [...new Set(candidates)];
-	if (unique.length <= limit) return unique;
-	const wanted = reference.toLowerCase();
-	const ranked = unique.map((candidate, index) => {
-		const lower = candidate.toLowerCase();
-		const near = wanted.length > 0 && (lower.includes(wanted) || wanted.includes(lower));
-		return {
-			candidate,
-			index,
-			near: near ? 0 : 1,
-			distance: near ? 0 : editDistance(wanted, lower)
-		};
-	});
-	ranked.sort((a, b) => a.near - b.near || a.distance - b.distance || a.index - b.index);
-	return ranked.slice(0, limit).map(({ candidate }) => candidate);
-}
-/** How many single-character insertions, deletions or substitutions turn one string into the other. */
-function editDistance(a, b) {
-	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-	for (let i = 1; i <= a.length; i++) {
-		const row = [i];
-		for (let j = 1; j <= b.length; j++) row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-		previous = row;
-	}
-	return previous[b.length];
-}
-/** A thrown value's details, when it carries them. */
-function errorDetails(error) {
-	return error instanceof CodedError ? error.details : void 0;
-}
-/** Details that came from another process, checked before they're trusted. Anything malformed reads as none. */
-function readErrorDetails(value) {
-	if (!value || typeof value !== "object") return void 0;
-	const code = "code" in value ? value.code : void 0;
-	const known = errorCodes.find((candidate) => candidate === code);
-	if (!known) return void 0;
-	const retryable = "retryable" in value && value.retryable === true;
-	const field = "field" in value && typeof value.field === "string" && value.field ? value.field : void 0;
-	const alternatives = "alternatives" in value && Array.isArray(value.alternatives) ? value.alternatives.filter((item) => typeof item === "string").slice(0, 20) : void 0;
-	return {
-		code: known,
-		retryable,
-		...field === void 0 ? {} : { field },
-		...alternatives === void 0 ? {} : { alternatives }
-	};
-}
 // src/caller.ts
 /** Declared caller names are displayed verbatim apart from surrounding whitespace. */
 function declaredName(value) {
-	return typeof value === "string" ? value.trim() || void 0 : void 0;
+	return nonBlankString.safeParse(value).data;
 }
 /** Reserve the session suffix inside the desktop boundary's 80-character caller-id limit. */
 function sessionCallerId(name, session) {
@@ -405,10 +319,13 @@ async function runningCopies() {
 			report
 		}] : [];
 	}))).flat();
-	if (entries.length > 0 && copies.length === 0) throw new CodedError(`Parity isn't answering at ${entries.map((entry) => entry.url).join(", ")}. Is the app still running?`, {
-		code: "not_answering",
-		retryable: true
-	});
+	if (entries.length > 0 && copies.length === 0) {
+		const where = entries.map((entry) => entry.url).join(", ");
+		throw new CodedError(`Parity isn't answering at ${where}. Is the app still running?`, {
+			code: "not_answering",
+			retryable: true
+		});
+	}
 	if (copies.length === 0) throw new CodedError(`Parity isn't running (nothing in ${registry.path}). Start the app, then try again.`, {
 		code: "not_running",
 		retryable: true
@@ -468,10 +385,45 @@ function describeExec(result) {
 	if (result.output.length > 0) lines.push("", "Output:", ...result.output);
 	const created = Object.entries(result.created);
 	if (created.length > 0) lines.push("", "Created:", ...created.map(([name, id]) => `  ${name} = ${id}`));
-	if (result.warnings.length > 0) lines.push("", "Warnings (fix these next):", ...result.warnings.map((warning) => `  ${warning}`));
+	lines.push(...describeWarnings(result));
+	if (result.discarded?.length) {
+		lines.push("", "Discarded by Replace (reapply what you still want to the new node):");
+		for (const { design, replaced, replacement, nodes } of result.discarded) {
+			lines.push(`  ${design}/${replaced}, now ${replacement}:`);
+			for (const node of nodes) {
+				const where = [
+					node.viewports && `viewports ${node.viewports.join(", ")}`,
+					node.states && `states ${node.states.join(", ")}`,
+					node.variants && `variants ${node.variants.join(", ")}`
+				].filter(Boolean);
+				lines.push(`    ${node.name ? `${node.name} (${node.id})` : node.id}: ${where.join("; ")}`);
+			}
+		}
+	}
 	if (result.screenshots.length > 0) lines.push("", "Screenshots:", ...result.screenshots.map((shot) => `  ${shot.design} / ${shot.state} / ${shot.mode}: ${shot.path}`));
 	return lines.join("\n");
 }
+const warningHeadings = {
+	error: "Render failures (these frames weren't checked):",
+	warning: "Warnings (fix these next):",
+	suggestion: "Suggestions:"
+};
+/**
+* The warnings under a heading for each severity, so a failed render doesn't read like a naming tip. The lines are
+* the app's, one per group in the groups' order; an app older than PAR-460 sends no groups, so they're all warnings.
+*/
+function describeWarnings(result) {
+	const lines = [];
+	for (const severity of [
+		"error",
+		"warning",
+		"suggestion"
+	]) {
+		const matching = result.warnings.filter((_, index) => (result.warningGroups?.[index]?.severity ?? "warning") === severity);
+		if (matching.length > 0) lines.push("", warningHeadings[severity], ...matching.map((warning) => `  ${warning}`));
+	}
+	return lines;
+}
 /** Where a tab's edits stand: the revision, what's applied and undoable, what's on disk, and what failed to write. */
 function describeStatus(result) {
 	const { tab, revision, unsaved, undo, redo, save, errors } = result;
@@ -563,6 +515,7 @@ function describeAccessibility(result) {
 				name: finding.name ?? "The design",
 				nodes: finding.node ? [finding.node] : [],
 				detail: finding.detail,
+				...fixLine(finding) ? { fix: fixLine(finding) } : {},
 				frames: []
 			};
 			layer.frames.push({
@@ -586,6 +539,7 @@ function describeAccessibility(result) {
 			const where = layer.frames.length === frames && frames > 1 ? "every frame" : frameList(layer.frames);
 			const ids = layer.nodes.length > 0 ? ` (${layer.nodes.join(", ")})` : "";
 			lines.push(`  ${layer.name}${ids}, in ${where}: ${layer.detail}`);
+			if (layer.fix) lines.push(`    ${layer.fix}`);
 		}
 		lines.push(`  How to fix it: ${helpUrl}`);
 	}
@@ -593,12 +547,19 @@ function describeAccessibility(result) {
 	lines.push("", "Automated checks find some issues, not all. Try the design with a keyboard and a screen reader too.");
 	return lines.join("\n");
 }
+/** A contrast failure's fix in a sentence, naming the style to set so it can be passed to execute. */
+function fixLine(finding) {
+	const fix = finding.contrast?.fix;
+	if (fix === "none") return "Fix: none of the project's color tokens pass on this background; change the background.";
+	return fix && `Fix: set style.foreground to "${fix.token}", which reaches ${fix.ratio}:1 in every frame checked.`;
+}
 /** A readable account of the layout problems in a design's frames, each once with the frames it's in. */
 function describeProblems(result) {
 	const { design, problems, frames } = result;
 	const checked = `${design.name} (${design.id}), ${frames === 1 ? "1 frame" : `${frames} frames`}`;
 	const grouped = /* @__PURE__ */ new Map();
-	for (const { problem, node, state, mode } of problems) {
+	for (const { problem, node: id, name, state, mode } of problems) {
+		const node = id && name ? `${name} (${id})` : id;
 		const key = `${node ?? ""}\n${problem}`;
 		const entry = grouped.get(key) ?? {
 			problem,
@@ -671,19 +632,47 @@ function describeComponents({ components, iconLibraries = [], leftOut = [], draw
 	}
 	return lines.join("\n").trimEnd();
 }
-/** A component's props, with each variant's options and default. */
+/** A component's props, with each variant's options and default, then what it needs around it and holds. */
 function describeProps(result) {
-	if (!result.known) return `${result.component}'s props haven't been read from its source yet. Try again in a moment.`;
-	const imported = result.import && result.import !== result.path ? `, imported from "${result.import}"` : "";
-	const lines = [`${result.component}, from ${result.path}${imported}:`];
-	for (const prop of result.props) {
-		const options = prop.options ? `: ${prop.options.map((option) => JSON.stringify(option)).join(", ")}` : "";
-		const fallback = prop.default === void 0 ? "" : `, default ${JSON.stringify(prop.default)}`;
-		lines.push(`  ${prop.name} (${prop.kind}${prop.required ? ", required" : ""})${options}${fallback}`);
+	const lines = [];
+	if (!result.known) lines.push(`${result.component}'s props haven't been read from its source yet. Try again in a moment.`);
+	else {
+		const imported = result.import && result.import !== result.path ? `, imported from "${result.import}"` : "";
+		lines.push(`${result.component}, from ${result.path}${imported}:`);
+		for (const prop of result.props) {
+			const options = prop.options ? `: ${prop.options.map((option) => JSON.stringify(option)).join(", ")}` : "";
+			const fallback = prop.default === void 0 ? "" : `, default ${JSON.stringify(prop.default)}`;
+			lines.push(`  ${prop.name} (${prop.kind}${prop.required ? ", required" : ""})${options}${fallback}`);
+		}
+		if (result.props.length === 0) lines.push("  No props of its own. --all lists the attributes it passes on.");
 	}
-	if (result.props.length === 0) lines.push("  No props of its own. --all lists the attributes it passes on.");
+	if (result.composition) lines.push("", ...describeComposition(result.composition));
 	return lines.join("\n");
 }
+const roles = {
+	provider: "a provider, which draws nothing and gives the parts inside it their context",
+	wrapper: "a wrapper, which other parts go inside",
+	component: "a component"
+};
+const exampleStatus = {
+	drawn: "drawn on the canvas",
+	failing: "failing on the canvas",
+	untried: "not drawn yet"
+};
+/** What a component needs around it, what it holds, its slots, and its example as JSON for `Insert`. */
+function describeComposition({ role, parents, holds, slots, example }) {
+	const lines = [`It's ${roles[role]}.`];
+	if (parents.status === "listed") {
+		const chain = parents.chain.map((parent) => parent.optional ? `${parent.component} (optional)` : parent.component);
+		lines.push(`Goes inside, outermost first: ${chain.join(" > ")}${parents.from ? ` (from its ${parents.from})` : ""}`);
+	} else if (parents.status === "none") lines.push("Needs nothing around it.");
+	else lines.push(`What it needs around it is unknown: ${parents.reason}`);
+	if (holds.length > 0) lines.push(`Holds: ${holds.join(", ")}`);
+	if (slots.length > 0) lines.push(`Slots: ${slots.map((slot) => `${slot.key} (${slot.kind})`).join(", ")}`);
+	const reason = example.reason ? `: ${example.reason}` : "";
+	lines.push(`Example for Insert, ${exampleStatus[example.status]}${reason}:`, `  ${JSON.stringify(example.node)}`);
+	return lines;
+}
 /** Frames as state and mode ids, naming a mode once when they share it: "default, error in desktop-light". */
 function frameList(frames) {
 	const modes = [...new Set(frames.map((frame) => frame.mode))];
@@ -721,4 +710,4 @@ function scriptPath(url) {
 		return url || "an unknown script";
 	}
 }
-export { errorDetails as _, describeExec as a, describeProps as c, registry as d, setCaller as f, errorCodes as g, closest as h, describeConsole as i, describeStatus as l, CodedError as m, describeAccessibility as n, describeModes as o, mcpCallerName as p, describeComponents as r, describeProblems as s, call as t, describeTokens as u, readErrorDetails as v, unknownReference as y };
+export { describeExec as a, describeProps as c, registry as d, setCaller as f, describeConsole as i, describeStatus as l, describeAccessibility as n, describeModes as o, mcpCallerName as p, describeComponents as r, describeProblems as s, call as t, describeTokens as u };

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import { z } from "zod";
 /**
  * Where running copies of Parity say how to reach them (PAR-514): one entry per copy, named by its main process, in
  * `~/.parity/agents`. Each copy writes and removes only its own. The app and the CLI both go through here, so the
@@ -63,15 +64,42 @@ interface Screenshot {
   state: string;
   mode: string;
 }
+/** What one `Replace` threw away: the patches keyed to the old node and what was inside it (PAR-455). */
+interface Discarded {
+  design: string;
+  replaced: string;
+  replacement: string;
+  nodes: {
+    id: string;
+    name?: string;
+    viewports?: string[];
+    states?: string[];
+    variants?: string[];
+  }[];
+}
+/**
+ * Findings with the same category and message, once, with every place they were found (PAR-460). The app's
+ * `warnings` are these as lines, in the same order.
+ */
+interface WarningGroup {
+  category: string;
+  severity: "error" | "warning" | "suggestion";
+  message: string;
+  count: number;
+  at: string[];
+}
 /** The canonical result. Structured output is this without the screenshots' image data. */
 interface ExecResponse {
   ok: boolean;
   applied: boolean;
   output: string[];
   warnings: string[];
+  warningGroups?: WarningGroup[];
   /** Set when the call failed, with the editId to retry a snippet by. */
   error?: OperationError;
   created: Record<string, string>;
+  /** Set when a Replace threw away responsive, state or variant patches. */
+  discarded?: Discarded[];
   screenshots: Screenshot[];
 }
 /**
@@ -225,6 +253,13 @@ export interface AccessibilityFinding {
   node?: string;
   name?: string;
   detail: string;
+  /** For a contrast failure: the token to color the layer's text with, or `"none"` when none of the project's pass. */
+  contrast?: {
+    fix?: {
+      token: string;
+      ratio: number;
+    } | "none";
+  };
 }
 export interface AccessibilityResponse {
   tab: {
@@ -253,15 +288,41 @@ export interface ProblemsResponse {
     id: string;
     name: string;
   };
-  problems: {
-    state: string;
-    mode: string;
-    problem: string;
-    node?: string;
-  }[];
+  problems: Problem[];
   frames: number;
   warnings: string[];
 }
+/** A box in a frame, in CSS pixels from its top left corner. */
+export interface FrameBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/**
+ * One problem in one frame. Layout problems (`frame-overflow`, `clipped`) name the node, what it overflows (the node
+ * that clips it, or the frame, which has none), both boxes, and how far past each edge it reaches.
+ */
+export interface Problem {
+  state: string;
+  mode: string;
+  kind?: "render-error" | "unknown-component" | "content-wider" | "frame-overflow" | "clipped";
+  problem: string;
+  node?: string;
+  name?: string;
+  box?: FrameBox;
+  container?: {
+    node?: string;
+    name?: string;
+    box: FrameBox;
+  };
+  overflow?: {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+  };
+}
 /** A readable account of the layout problems in a design's frames, each once with the frames it's in. */
 export declare function describeProblems(result: ProblemsResponse): string;
 export interface TokenInfo {
@@ -325,8 +386,38 @@ export interface PropsResponse {
     default?: string | number | boolean | null;
     required?: boolean;
   }[];
+  /** What it needs around it and holds inside it, read from its library's metadata (PAR-454). */
+  composition?: Composition;
+}
+/** A component's composition, as `@parity-app/editor`'s `componentComposition` reads it. */
+export interface Composition {
+  role: "provider" | "wrapper" | "component";
+  parents: {
+    status: "listed";
+    chain: {
+      component: string;
+      optional?: true;
+    }[];
+    from?: string;
+  } | {
+    status: "none";
+  } | {
+    status: "unknown";
+    reason: string;
+  };
+  holds: string[];
+  slots: {
+    name: string;
+    key: string;
+    kind: "children" | "element" | "render";
+  }[];
+  example: {
+    node: unknown;
+    status: "drawn" | "failing" | "untried";
+    reason?: string;
+  };
 }
-/** A component's props, with each variant's options and default. */
+/** A component's props, with each variant's options and default, then what it needs around it and holds. */
 export declare function describeProps(result: PropsResponse): string;
 export interface ConsoleEntry {
   level: "info" | "warning" | "error" | "debug";

package/dist/index.mjs

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

package/dist/schema-BpGSCLEu.mjs

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

package/dist/{src-y3hdgbK2.mjs → src-5CrSA_RX.mjs}

@@ -1,4 +1,4 @@
-import { p as parseLibraryManifest, u as libraryManifestExtension } from "./src-CYEKdXm_.mjs";
+import { p as parseLibraryManifest, u as libraryManifestExtension } from "./src-C4faIpux.mjs";
 import { createRequire } from "node:module";
 import { readFile, readdir } from "node:fs/promises";
 import { dirname, join } from "node:path";