@parity-app/cli 0.6.1 → 0.6.3

package/dist/bin.mjs

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

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

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

package/dist/index.mjs

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

package/dist/schema-CiVy9tZT.mjs

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

package/dist/src-AKjejfTT.mjs

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

package/dist/src-B40wy5fK.mjs

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