@parity-app/cli 0.7.1 → 0.7.3

package/dist/bin.mjs

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
-import { c as closest, d as readErrorDetails, l as errorCodes, s as CodedError, u as errorDetails } from "./schema-DcQLoUPP.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-D5kbiMmn.mjs";
+import { c as CodedError, d as errorDetails, f as readErrorDetails, i as jsonText, l as closest, s as plainObject, t as checkData, u as errorCodes } from "./schema-CemdtCeF.mjs";
+import { _ as requests, a as describeExec, c as describeProps, f as setCaller, g as requestJsonSchema, h as replies, i as describeConsole, l as describeStatus, m as readRequest, n as describeAccessibility, o as describeModes, p as mcpCallerName, r as describeComponents, s as describeProblems, t as call, u as describeTokens, v as skillRequest } from "./client-BtxrNeIk.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";
+import { z } from "zod";
 import { createInterface } from "node:readline";
 // src/errors.ts
+/**
+* A failed call, the same in CLI `--json` and MCP `structuredContent`: a stable code to branch on, the message people
+* read, whether the same request can succeed when sent again, the input at fault, and what to use instead. What each
+* field means is in the CLI's README and the skill, too.
+*/
+const failure = z.object({
+	code: z.enum(errorCodes),
+	message: z.string(),
+	/** Whether sending the same request again, unchanged, can succeed: the app was starting, or edits collided. */
+	retryable: z.boolean(),
+	/** A JSON pointer to the input at fault, such as `/design` or `/edits/0/find`, in the operation's field names. */
+	path: z.string().optional(),
+	/** Valid ids to use instead of an unknown or ambiguous one, closest first, at most 20. */
+	alternatives: z.array(z.string()).optional(),
+	/** A failed snippet's id: retry it with `editId` and `edits` instead of sending it again. */
+	editId: z.string().optional()
+});
 /** A request field that isn't valid, rejected before anything reaches the app. */
 function invalidInput(field, message) {
 	return new CodedError(message, {
@@ -47,30 +65,12 @@ function renamePath(error, names) {
 		].join("/")
 	};
 }
-/** The error's schema. What each field means is in the CLI's README and the skill, to keep every tool's schema small. */
-const operationErrorSchema = {
-	type: "object",
-	properties: {
-		code: {
-			type: "string",
-			enum: [...errorCodes]
-		},
-		message: { type: "string" },
-		retryable: { type: "boolean" },
-		path: { type: "string" },
-		alternatives: {
-			type: "array",
-			items: { type: "string" }
-		},
-		editId: { type: "string" }
-	},
-	required: [
-		"code",
-		"message",
-		"retryable"
-	]
-};
 // src/execute.ts
+replies.exec.omit({
+	error: true,
+	details: true,
+	editId: true
+}).extend({ error: failure.optional() });
 /** The same request fields in both adapters' paths, before MCP renames label and code. */
 const executeFields = [
 	"tab",
@@ -84,11 +84,11 @@ function execResponse(reply, fields = executeFields) {
 	const { error, details, editId, ...rest } = reply;
 	if (reply.ok || error === void 0) return rest;
 	const coded = readErrorDetails(details);
-	const failure = operationError(coded ? new CodedError(error, coded) : new CodedError(error, { code: "execution_failed" }), fields);
+	const failed = operationError(coded ? new CodedError(error, coded) : new CodedError(error, { code: "execution_failed" }), fields);
 	return {
 		...rest,
 		error: {
-			...failure,
+			...failed,
 			...editId ? { editId } : {}
 		}
 	};
@@ -100,285 +100,58 @@ function structuredExec(result) {
 		screenshots: result.screenshots.map(({ png: _png, ...shot }) => shot)
 	};
 }
-const screenshotSchema = {
-	type: "object",
-	properties: {
-		path: {
-			type: "string",
-			description: "Where the PNG was saved."
-		},
-		design: { type: "string" },
-		state: { type: "string" },
-		mode: { type: "string" }
-	},
-	required: [
-		"path",
-		"design",
-		"state",
-		"mode"
-	]
-};
-const strings$1 = {
-	type: "array",
-	items: { type: "string" }
-};
-const discardedSchema = {
-	type: "array",
-	description: "Patches each Replace threw away with the node it swapped out. Present only when there were some; reapply what's still wanted to the replacement with Responsive, Update with a state, or UpdateState.",
-	items: {
-		type: "object",
-		properties: {
-			design: { type: "string" },
-			replaced: {
-				type: "string",
-				description: "The node Replace swapped out."
-			},
-			replacement: {
-				type: "string",
-				description: "The node that took its place."
-			},
-			nodes: {
-				type: "array",
-				items: {
-					type: "object",
-					properties: {
-						id: {
-							type: "string",
-							description: "The old node's id, or instance/inner path."
-						},
-						name: { type: "string" },
-						viewports: {
-							...strings$1,
-							description: "Viewport ids it had responsive patches for."
-						},
-						states: {
-							...strings$1,
-							description: "State ids it had patches in."
-						},
-						variants: {
-							...strings$1,
-							description: "Variant options it had patches in, as param=option."
-						}
-					},
-					required: ["id"]
-				}
-			}
-		},
-		required: [
-			"design",
-			"replaced",
-			"replacement",
-			"nodes"
-		]
-	}
-};
-const warningGroupsSchema = {
-	type: "array",
-	description: "The warnings as data, in the same order: each finding once, with how many places and which. Errors come first, then warnings, then suggestions.",
-	items: {
-		type: "object",
-		properties: {
-			category: {
-				type: "string",
-				description: "Stable: render_failed, unknown_component, unknown_component_design, unknown_prop, invalid_option, not_a_token, not_a_length_token, overlap, title_clearance, canvas_overlaps, kind_changed or unnamed_layout. overlap and title_clearance cover boards this call created, changed or moved: overlap when two boards collide, title_clearance when they're clear but one's title covers the other. canvas_overlaps counts the rest of the canvas's; call Overlaps() to check every board."
-			},
-			severity: {
-				type: "string",
-				enum: [
-					"error",
-					"warning",
-					"suggestion"
-				],
-				description: "error: a render failed, so a check or screenshot is missing. suggestion: worth doing, not wrong."
-			},
-			message: {
-				type: "string",
-				description: "What's wrong and what to do about it."
-			},
-			count: {
-				type: "integer",
-				minimum: 1,
-				description: "How many places it was found."
-			},
-			at: {
-				...strings$1,
-				description: "Every place: a node's design/node path, or a frame. Empty for a whole board."
-			}
-		},
-		required: [
-			"category",
-			"severity",
-			"message",
-			"count",
-			"at"
-		]
-	}
-};
-/** Execute's and screenshot's structured result. */
-const execOutputSchema = {
-	type: "object",
-	properties: {
-		ok: { type: "boolean" },
-		applied: {
-			type: "boolean",
-			description: "Changes landed on the canvas as one undoable step."
-		},
-		output: {
-			type: "array",
-			items: { type: "string" },
-			description: "Lines from Print."
-		},
-		warnings: {
-			...strings$1,
-			description: "One line per warning group, places first."
-		},
-		warningGroups: warningGroupsSchema,
-		created: {
-			type: "object",
-			additionalProperties: { type: "string" },
-			description: "Names of designs and nodes created, mapped to their ids."
-		},
-		discarded: discardedSchema,
-		screenshots: {
-			type: "array",
-			items: screenshotSchema
-		},
-		error: operationErrorSchema
-	},
-	required: [
-		"ok",
-		"applied",
-		"output",
-		"warnings",
-		"created",
-		"screenshots"
-	]
-};
-const defaultLabel = "Edit designs";
-/** What every call's tab field says, the same in the CLI's help, MCP tools and the skill (PAR-514). */
-const tabDescription = "Tab id, project root or name, or \"active\" for what the person is looking at. Defaults to the open project the current folder is in, else \"active\".";
-/** Canonical properties, also used by MCP discovery after renaming label and code. */
-const executeProperties = {
-	tab: {
-		type: "string",
-		minLength: 1,
-		description: tabDescription
-	},
-	label: {
-		type: "string",
-		minLength: 1,
-		default: defaultLabel,
-		description: "Shown while it runs. Prefer 3 to 8 words, e.g. \"Add pricing tiers\"."
-	},
-	code: {
-		type: "string",
-		minLength: 1,
-		description: "The snippet. Omit when retrying with editId."
-	},
-	editId: {
-		type: "string",
-		minLength: 1,
-		description: "The failed call's editId, to retry with edits."
-	},
-	edits: {
-		type: "array",
-		description: "Exact find and replace edits to the failed snippet, applied in order.",
-		items: {
-			type: "object",
-			additionalProperties: false,
-			properties: {
-				find: {
-					type: "string",
-					minLength: 1
-				},
-				replace: { type: "string" },
-				all: { type: "boolean" }
-			},
-			required: ["find", "replace"]
-		}
-	}
-};
-function optionalText(value, field) {
-	if (value === void 0) return void 0;
-	if (typeof value !== "string" || !value.trim()) throw invalidInput(field, `${field} must be a nonblank string`);
-	return value;
-}
-function edit(value, index) {
-	const at = `edits/${index}`;
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw invalidInput(at, "Each edit must be an object");
-	if (!("find" in value) || typeof value.find !== "string" || !value.find.length) throw invalidInput(`${at}/find`, "Each edit needs a nonempty find string");
-	if (!("replace" in value) || typeof value.replace !== "string") throw invalidInput(`${at}/replace`, "Each edit needs a replace string");
-	if ("all" in value && typeof value.all !== "boolean") throw invalidInput(`${at}/all`, "Edit all must be a boolean");
-	const unknown = Object.keys(value).find((key) => ![
-		"find",
-		"replace",
-		"all"
-	].includes(key));
-	if (unknown) throw invalidInput(`${at}/${unknown}`, "Unknown edit field");
-	return {
-		find: value.find,
-		replace: value.replace,
-		..."all" in value && typeof value.all === "boolean" ? { all: value.all } : {}
-	};
-}
-/** Validate once, before either transport sends a request to the desktop. Never rewrite snippet or patch text. */
+/** Checks the request once, before either transport sends it to the desktop. Snippet and patch text stay as written. */
 function executeRequest(input) {
-	const tab = optionalText(input.tab, "tab");
-	const label = optionalText(input.label, "label") ?? defaultLabel;
-	const code = optionalText(input.code, "code");
-	const editId = optionalText(input.editId, "editId");
-	if (!code && !editId) throw invalidInput("code", "Nothing to run: pass a snippet, or an editId with edits");
-	if (code !== void 0 && editId !== void 0) throw invalidInput("editId", "Pass a snippet or an editId, not both");
-	if (input.edits !== void 0 && !Array.isArray(input.edits)) throw invalidInput("edits", "edits must be an array");
-	if (input.edits !== void 0 && !editId) throw invalidInput("edits", "edits requires an editId");
-	const edits = Array.isArray(input.edits) ? input.edits.map(edit) : void 0;
-	return {
-		label,
-		...tab === void 0 ? {} : { tab },
-		...code === void 0 ? {} : { code },
-		...editId === void 0 ? {} : {
-			editId,
-			edits: edits ?? []
-		}
-	};
+	return readRequest(requests.exec, input);
 }
 /** Execution failures have the same meaning for CLI exits and MCP tool errors. */
 function executionFailed(result) {
 	return !result.ok;
 }
+/**
+* Discovery's schema: every field either kind of request takes, under the adapter's names, and which ones each kind
+* needs and refuses, from the two kinds' own schemas. Clients read one object, so the kinds become `oneOf` rules on it.
+*/
+function discoverySchema(names) {
+	const renamed = {
+		label: names.label,
+		code: names.code
+	};
+	const rename = (key) => renamed[key] ?? key;
+	const kinds = requests.exec.options.map((kind) => ({
+		json: requestJsonSchema(kind),
+		keys: Object.keys(kind.shape)
+	}));
+	const every = [...new Set(kinds.flatMap(({ keys }) => keys))];
+	return {
+		type: "object",
+		properties: Object.fromEntries(kinds.flatMap(({ json }) => Object.entries(json.properties ?? {})).map(([key, schema]) => [rename(key), schema])),
+		additionalProperties: false,
+		oneOf: kinds.map(({ json, keys }) => {
+			const refused = every.filter((key) => !keys.includes(key)).map((key) => ({ required: [rename(key)] }));
+			return {
+				required: (json.required ?? []).map(rename),
+				not: refused.length === 1 ? refused[0] : { anyOf: refused }
+			};
+		})
+	};
+}
 /** One handler for both adapters. Caller identity stays in the transport's connection context. */
 const executeOperation = {
 	failed: executionFailed,
 	fields: executeFields,
-	outputSchema: execOutputSchema,
 	structured: structuredExec,
 	/** Discovery uses the same contract, with just the two historical MCP field aliases. */
-	inputSchema(names = {
-		label: "label",
-		code: "code"
-	}) {
-		const { label, code, ...rest } = executeProperties;
-		return {
-			type: "object",
-			properties: {
-				...rest,
-				[names.label]: label,
-				[names.code]: code
-			},
-			oneOf: [{
-				required: [names.code],
-				not: { anyOf: [{ required: ["editId"] }, { required: ["edits"] }] }
-			}, {
-				required: ["editId"],
-				not: { required: [names.code] }
-			}]
-		};
-	},
+	inputSchema: discoverySchema,
 	async run(input, send) {
-		return execResponse(await send("exec", { ...executeRequest(input) }));
+		return execResponse(await send("exec", executeRequest(input), "tab", replies.exec));
 	}
 };
 // src/check.ts
+/** The registry's least share of placed parts each library must render, by library, in `in-app.json`. */
+const floorsFile = jsonText(z.record(z.string(), z.number()));
+/** The app's errors kept for a library, by part. */
+const appErrorsFile = jsonText(z.record(z.string(), z.string()));
 /**
 * `parity lib check <library>`: inserts every component of a registry library file into the running app, once on its
 * own and once the way the Assets panel inserts it, inside its parents with its sample, and reports the parts that fail
@@ -387,8 +160,8 @@ const executeOperation = {
 */
 async function runCheck(library, options) {
 	if (!library) throw new Error("parity lib check <library> [--tab t] [--mode m]");
-	const { componentNode, generateId, librarySource, withLibraryContext } = await import("./src-_5ETJOb0.mjs");
-	const { newestEntries, registryDir } = await import("./src-B5sEtTw_.mjs");
+	const { componentNode, generateId, librarySource, withLibraryContext } = await import("./src-ok4hEd7p.mjs");
+	const { newestEntries, registryDir } = await import("./src-Q382DbAK.mjs");
 	const entry = (await newestEntries()).find((item) => item.manifest.id === library);
 	if (!entry) throw new Error(`The registry has no library "${library}"`);
 	const list = entry.manifest.components?.list ?? {};
@@ -399,7 +172,8 @@ async function runCheck(library, options) {
 		declaration: ""
 	}]));
 	const mode = options.mode ?? "desktop-light";
-	const exec = async (label, code) => {
+	/** Runs one of these snippets and reads the JSON it prints, once `printed` has checked it. */
+	const exec = async (label, code, printed) => {
 		const result = await executeOperation.run({
 			tab: options.tab,
 			label,
@@ -408,11 +182,13 @@ async function runCheck(library, options) {
 		if (executeOperation.failed(result)) throw new Error(result.error?.message ?? `${label} failed`);
 		const line = result.output.find((item) => item.startsWith("{") || item.startsWith("["));
 		if (!line) throw new Error(`${label} printed nothing`);
-		return line;
+		const checked = checkData(jsonText(printed), line);
+		if (checked.success) return checked.data;
+		throw new Error(`This CLI can't read what "${label}" printed (${checked.problem.pointer}: ${checked.problem.message})`);
 	};
-	const infos = JSON.parse(await exec(`Read ${library}'s props`, `const ids = ${JSON.stringify(names.map(id))}
+	const infos = await exec(`Read ${library}'s props`, `const ids = ${JSON.stringify(names.map(id))}
 const known = new Set(Components())
-Print(JSON.stringify(Object.fromEntries(ids.filter((id) => known.has(id)).map((id) => [id, Props(id, { all: true })]))))`));
+Print(JSON.stringify(Object.fromEntries(ids.filter((id) => known.has(id)).map((id) => [id, Props(id, { all: true })]))))`, z.record(z.string(), replies.props));
 	if (names.filter((name) => !infos[id(name)]).length === names.length) throw new Error(`The tab's project doesn't have ${library} installed`);
 	const taken = /* @__PURE__ */ new Set();
 	const alone = names.map((name) => {
@@ -426,18 +202,18 @@ Print(JSON.stringify(Object.fromEntries(ids.filter((id) => known.has(id)).map((i
 	});
 	const inside = names.filter((name) => list[name].parents?.length || list[name].sample).map((name) => withLibraryContext(componentNode(id(name), infos[id(name)], taken), sources, [], taken));
 	const failing = async (design, nodes) => {
-		const line = await exec(`Check ${design}`, `for (const design of Designs().filter((d) => d.name === ${JSON.stringify(design)})) DeleteDesign(design.id)
+		return failures(await exec(`Check ${design}`, `for (const design of Designs().filter((d) => d.name === ${JSON.stringify(design)})) DeleteDesign(design.id)
 const spot = FindEmptySpace({ width: 1280, height: 2000 })
 const id = CreateDesign({ name: ${JSON.stringify(design)}, x: spot.x, y: spot.y })
 const grid = Insert(id, { type: "layout", name: "Grid", style: { direction: "row", wrap: true, gap: 4, padding: 4 }, children: [] })
 for (const node of ${JSON.stringify(nodes)}) Insert(grid, node)
-Print(JSON.stringify(await Problems(id, { mode: ${JSON.stringify(mode)} })))`);
-		return failures(JSON.parse(line), library);
+Print(JSON.stringify(await Problems(id, { mode: ${JSON.stringify(mode)} })))`, replies.problems.shape.problems), library);
 	};
 	const failAlone = await failing(`${library} alone`, alone);
 	const failInside = await failing(`${library} inside`, inside);
 	const report = score(library, mode, names.length, failAlone, failInside, list);
-	report.floor = JSON.parse(await readFile(join(registryDir(), "..", "in-app.json"), "utf8"))[library];
+	const floors = join(registryDir(), "..", "in-app.json");
+	report.floor = registryFile(floors, await readFile(floors, "utf8"), floorsFile)[library];
 	if (options.record) {
 		const kept = await recordAppErrors(registryDir(), library, report);
 		console.error(`Kept ${kept} errors from the app for ${library}; run parity lib with --registry to use them.`);
@@ -452,7 +228,15 @@ function appErrorsPath(registry, library) {
 }
 /** The app's errors kept for a library, by part, or none. */
 async function readAppErrors(registry, library) {
-	return readFile(appErrorsPath(registry, library), "utf8").then((text) => JSON.parse(text), () => void 0);
+	const path = appErrorsPath(registry, library);
+	const text = await readFile(path, "utf8").catch(() => void 0);
+	return text === void 0 ? void 0 : registryFile(path, text, appErrorsFile);
+}
+/** One of the registry's own JSON files once `schema` has checked it, or an error naming the file and what's wrong. */
+function registryFile(path, text, schema) {
+	const checked = checkData(schema, text);
+	if (checked.success) return checked.data;
+	throw new TypeError(`${path}: ${checked.problem.pointer || "/"}: ${checked.problem.message}`);
 }
 /**
 * Adds the parts that failed in the app to those kept before, with their own errors rather than a parent's: one kept
@@ -511,8 +295,8 @@ function describeCheck(report) {
 * because it reads the project's files and its own copy of TypeScript.
 */
 async function runLib(packageName, options) {
-	const { appManifestPath, generateLibrary, manifestText, mergeManifest, reviseLibrary } = await import("./src-DM51TWZ6.mjs");
-	const { covers, registryDir, registryEntries } = await import("./src-B5sEtTw_.mjs");
+	const { appManifestPath, generateLibrary, manifestText, mergeManifest, reviseLibrary } = await import("./src-Bf12xdm5.mjs");
+	const { covers, registryDir, registryEntries } = await import("./src-Q382DbAK.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)) {
@@ -523,7 +307,7 @@ async function runLib(packageName, options) {
 		console.error(`Installing ${spec.name} ${version} on its own…`);
 		root = await installedVersion(spec.name, version);
 	}
-	const { parseLibraryEdits } = await import("./src-DM51TWZ6.mjs");
+	const { parseLibraryEdits } = await import("./src-Bf12xdm5.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;
@@ -548,7 +332,7 @@ async function runLib(packageName, options) {
 	else target = await appManifestPath(root);
 	const existing = target ? await readFile(target, "utf8").then((text) => JSON.parse(text), () => void 0) : void 0;
 	if (!options.range) {
-		const read = generated.manifest.package;
+		const read = packageVersions.safeParse(generated.manifest.package).data;
 		const range = read && keptRange(existing, read, (versions) => covers({ package: versions }, read.version));
 		if (range) generated.manifest.package = {
 			...read,
@@ -580,13 +364,21 @@ async function runLib(packageName, options) {
 	}, null, 2));
 	else console.log(`Wrote ${relative(process.cwd(), target) || target}\n${describeReport(report)}`);
 }
+/** The package a library file describes: the version read, and the range of versions the file covers. */
+const packageVersions = z.looseObject({
+	name: z.string(),
+	version: z.string(),
+	range: z.string()
+});
+/** The range a file being written over has, which it keeps while that still covers the version read. */
+const writtenRange = z.looseObject({ package: z.looseObject({ range: z.string() }) });
 /**
 * The range a file being written over keeps: its own, while it still covers the version just read, so a range widened
 * by hand (Lucide's, from 0.400) survives regenerating. Undefined when the new range stands.
 */
 function keptRange(existing, read, covers) {
-	const range = existing?.package?.range;
-	if (typeof range !== "string" || range === read.range) return void 0;
+	const range = writtenRange.safeParse(existing).data?.package.range;
+	if (range === void 0 || range === read.range) return void 0;
 	return covers({
 		...read,
 		range
@@ -674,140 +466,20 @@ function describeReport(report) {
 	return lines.join("\n");
 }
 // src/operations.ts
-function text$1(description, required = false, fallback) {
-	return {
-		schema: {
-			type: "string",
-			minLength: 1,
-			pattern: "\\S",
-			description,
-			...fallback === void 0 ? {} : { default: fallback }
-		},
-		required,
-		read(value, name) {
-			if (value === void 0 && !required) return fallback;
-			if (typeof value !== "string" || !value.trim()) throw invalidInput(name, `${name} must be a nonblank string`);
-			return value;
-		}
-	};
-}
-function boolean(description) {
-	return {
-		schema: {
-			type: "boolean",
-			default: false,
-			description
-		},
-		read(value, name) {
-			if (value === void 0) return false;
-			if (typeof value !== "boolean") throw invalidInput(name, `${name} must be a boolean`);
-			return value;
-		}
-	};
-}
-function selector(description, fallback) {
-	const item = {
-		type: "string",
-		minLength: 1,
-		pattern: "\\S"
-	};
-	return {
-		schema: {
-			oneOf: [item, {
-				type: "array",
-				minItems: 1,
-				items: item
-			}],
-			description,
-			...fallback ? { default: fallback } : {}
-		},
-		read(value, name) {
-			if (value === void 0) return fallback;
-			if (typeof value === "string" && value.trim()) return value;
-			if (Array.isArray(value) && value.length && value.every((item) => typeof item === "string" && item.trim())) return value.length === 1 ? value[0] : value;
-			throw invalidInput(name, `${name} must be a nonblank string or a nonempty list of nonblank strings`);
-		}
-	};
-}
-/** How many items a list read returns at most: a default that keeps a reply small, and a ceiling. */
-function limit(description, fallback, most) {
-	return {
-		schema: {
-			type: "integer",
-			minimum: 1,
-			maximum: most,
-			default: fallback,
-			description
-		},
-		read(value, name) {
-			if (value === void 0) return fallback;
-			if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > most) throw invalidInput(name, `${name} must be a whole number from 1 to ${most}`);
-			return value;
-		}
-	};
-}
-const tab = text$1(tabDescription);
-const design = text$1("Design id or name.", true);
-const scale = {
-	schema: {
-		type: "number",
-		minimum: .25,
-		maximum: 3,
-		default: 1,
-		description: "Pixel density."
-	},
-	read(value) {
-		if (value === void 0) return 1;
-		if (typeof value !== "number" || !Number.isFinite(value) || value < .25 || value > 3) throw invalidInput("scale", "scale must be a finite number from 0.25 to 3");
-		return value;
-	}
-};
-const rootText = text$1("Absolute project folder path.", true);
-const absoluteRoot = /^(?:\/|[A-Za-z]:[\\/]|\\\\)/;
-const root$1 = {
-	...rootText,
-	schema: {
-		...rootText.schema,
-		pattern: absoluteRoot.source
-	},
-	read(value) {
-		const path = rootText.read(value, "root");
-		if (typeof path !== "string" || !absoluteRoot.test(path)) throw invalidInput("root", "root must be an absolute project folder path");
-		return path;
-	}
-};
-function fieldsContract(fields) {
-	return {
-		inputSchema: {
-			type: "object",
-			additionalProperties: false,
-			properties: Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, field.schema])),
-			required: Object.entries(fields).filter(([, field]) => field.required).map(([key]) => key)
-		},
-		request(input) {
-			if (!input || typeof input !== "object" || Array.isArray(input)) throw invalidInput(void 0, "Operation input must be an object");
-			for (const key of Object.keys(input)) if (!Object.hasOwn(fields, key)) throw invalidInput(key, `Unknown input field ${key}`);
-			const result = {};
-			for (const [key, field] of Object.entries(fields)) {
-				const value = field.read(input[key], key);
-				if (value !== void 0) result[key] = value;
-			}
-			return result;
-		}
-	};
-}
-/** An operation whose canonical result is built from the app's reply, given the validated request. */
-function mapped(method, fields, outputSchema, result, options = {}) {
-	const contract = fieldsContract(fields);
+/**
+* An operation whose canonical result is built from the app's checked answer, given the checked request. A request's
+* error points at the field, since an operation's fields are flat.
+*/
+function mapped(method, input, reply, result, options = {}) {
+	const fields = Object.keys(input.shape);
 	const routing = routingFor(fields);
 	return {
-		inputSchema: contract.inputSchema,
-		outputSchema,
-		fields: Object.keys(fields),
+		inputSchema: requestJsonSchema(input),
+		fields,
 		routing,
-		async run(input, send) {
-			const request = contract.request(input);
-			return result(await send(method, request, routing), request);
+		async run(given, send) {
+			const request = readRequest(input, given, 1);
+			return result(await send(method, request, routing, reply), request);
 		},
 		failed: options.failed ?? (() => false),
 		structured: options.structured ?? ((value) => Object.fromEntries(Object.entries(value)))
@@ -815,13 +487,13 @@ function mapped(method, fields, outputSchema, result, options = {}) {
 }
 /** Which copy a call goes to, from its fields: see `Operation.routing`. */
 function routingFor(fields) {
-	if ("tab" in fields) return "tab";
-	if ("root" in fields) return "open";
+	if (fields.includes("tab")) return "tab";
+	if (fields.includes("root")) return "open";
 	return "copies";
 }
-/** An operation whose canonical result is the app's reply. */
-function operation(method, fields, outputSchema, options = {}) {
-	return mapped(method, fields, outputSchema, (reply) => reply, options);
+/** An operation whose canonical result is the app's answer. */
+function operation(method, input, reply, options = {}) {
+	return mapped(method, input, reply, (answer) => answer, options);
 }
 /** The first `count` items, with how many there were, so a reply says when it left some out. */
 function bounded(items, count, keep = "first") {
@@ -832,660 +504,56 @@ function bounded(items, count, keep = "first") {
 		truncated: kept.length < items.length
 	};
 }
-const string = { type: "string" };
-const strings = {
-	type: "array",
-	items: string
-};
-const integer = { type: "integer" };
-const boolean_ = { type: "boolean" };
-function object(properties, optional = []) {
-	return {
-		type: "object",
-		properties,
-		required: Object.keys(properties).filter((key) => !optional.includes(key))
-	};
-}
-const ref = object({
-	id: string,
-	name: string
-});
-const tabSchema = object({
-	id: string,
-	name: string,
-	root: string,
-	active: boolean_,
-	status: {
-		type: "string",
-		enum: [
-			"loading",
-			"ready",
-			"error"
-		]
-	},
-	error: string,
-	designs: {
-		...integer,
-		description: "How many designs the project has."
-	}
-}, ["error"]);
-const frameSchema = {
-	state: string,
-	mode: string
-};
-const number = { type: "number" };
-const boxSchema = object({
-	x: number,
-	y: number,
-	width: number,
-	height: number
-});
-const designSchema = object({
-	id: string,
-	name: string,
-	kind: string,
-	file: string,
-	x: { type: "number" },
-	y: { type: "number" },
-	width: { type: "number" },
-	height: { type: "number" },
-	states: {
-		type: "array",
-		items: ref
-	},
-	showing: object({
-		state: string,
-		mode: string,
-		beside: strings
-	}),
-	nodes: integer
-}, ["width", "height"]);
-const stateSchema = object({
-	tab: tabSchema,
-	selection: object({
-		design: string,
-		node: string,
-		mode: string
-	}, [
-		"design",
-		"node",
-		"mode"
-	]),
-	designs: {
-		type: "array",
-		items: designSchema
-	},
-	overlaps: {
-		type: "array",
-		description: "Every pair of boards on the canvas that's too close, as execute's Overlaps() lists them. A pair with titleOnly doesn't collide: the lower board's title covers the upper one.",
-		items: object({
-			designs: strings,
-			names: strings,
-			width: {
-				...number,
-				description: "How far they share, title band included."
-			},
-			height: number,
-			titleOnly: {
-				...boolean_,
-				description: "Only the lower board's title covers the other; the boards are clear."
-			},
-			estimated: {
-				...boolean_,
-				description: "One isn't drawn yet, so its size is estimated from its frames. Absent: both measured."
-			}
-		}, [
-			"width",
-			"height",
-			"titleOnly",
-			"estimated"
-		])
-	},
-	modes: {
-		type: "array",
-		description: "The project's modes, primary first.",
-		items: object({
-			id: string,
-			name: string,
-			width: { type: "number" },
-			primary: {
-				...boolean_,
-				description: "The project's first mode: every design's main frame unless it picks another. Only one is."
-			}
-		})
-	},
-	components: strings,
-	tokens: object({
-		count: integer,
-		semantic: strings,
-		themeCategories: strings
-	}),
-	viewport: { type: "object" },
-	detection: { type: "object" }
-}, ["viewport", "detection"]);
 const truncation = {
-	total: {
-		...integer,
-		description: "How many there were before the limit."
-	},
-	truncated: {
-		...boolean_,
-		description: "Some were left out; narrow the read or raise limit."
-	}
+	total: z.int().describe("How many there were before the limit."),
+	truncated: z.boolean().describe("Some were left out; narrow the read or raise limit.")
 };
-const tokensSchema = object({
-	tokens: {
-		type: "array",
-		items: object({
-			name: string,
-			category: string,
-			source: string,
-			values: {
-				type: "object",
-				additionalProperties: string,
-				description: "Value per theme."
-			}
-		})
-	},
+z.looseObject({ tabs: replies.tabs });
+replies.console.extend({
+	entries: replies.console.shape.entries.describe("The newest entries, up to the limit, oldest first."),
 	...truncation
 });
-const consoleSchema = object({
-	tab: ref,
-	entries: {
-		type: "array",
-		items: object({
-			level: {
-				type: "string",
-				enum: [
-					"info",
-					"warning",
-					"error",
-					"debug"
-				]
-			},
-			text: string,
-			source: string,
-			line: integer,
-			where: {
-				type: "string",
-				enum: ["canvas", "offscreen"]
-			},
-			count: integer,
-			first: { type: "number" },
-			last: { type: "number" }
-		})
-	},
+z.looseObject({
+	tokens: replies.tokens,
 	...truncation
 });
-const problemsSchema = object({
-	tab: ref,
-	design: ref,
-	problems: {
-		type: "array",
-		items: object({
-			...frameSchema,
-			kind: {
-				type: "string",
-				enum: [
-					"render-error",
-					"unknown-component",
-					"content-wider",
-					"frame-overflow",
-					"clipped"
-				]
-			},
-			problem: string,
-			node: string,
-			name: string,
-			box: boxSchema,
-			container: object({
-				node: string,
-				name: string,
-				box: boxSchema
-			}, ["node", "name"]),
-			overflow: object({
-				left: number,
-				right: number,
-				top: number,
-				bottom: number
-			}, [
-				"left",
-				"right",
-				"top",
-				"bottom"
-			])
-		}, [
-			"kind",
-			"node",
-			"name",
-			"box",
-			"container",
-			"overflow"
-		])
-	},
-	frames: integer,
-	warnings: strings
-});
-const accessibilitySchema = object({
-	tab: ref,
-	design: ref,
-	findings: {
-		type: "array",
-		items: object({
-			...frameSchema,
-			rule: string,
-			impact: {
-				type: "string",
-				enum: [
-					"critical",
-					"serious",
-					"moderate",
-					"minor"
-				]
-			},
-			help: string,
-			helpUrl: string,
-			node: string,
-			name: string,
-			detail: string
-		}, ["node", "name"])
-	},
-	frames: integer,
-	warnings: strings
-});
-const componentsSchema = object({
-	components: strings,
-	iconLibraries: strings,
-	leftOut: {
-		type: "array",
-		items: object({
-			name: string,
-			path: string,
-			reason: string,
-			undecided: boolean_
-		}, ["undecided"])
-	},
-	drawn: integer,
-	failing: {
-		type: "array",
-		items: object({
-			id: string,
-			problem: {
-				type: "string",
-				enum: [
-					"provider",
-					"server",
-					"async",
-					"error"
-				]
-			},
-			reason: string
-		})
-	},
-	corrections: { type: "object" }
-}, [
-	"iconLibraries",
-	"leftOut",
-	"drawn",
-	"failing",
-	"corrections"
-]);
-const propsSchema = object({
-	component: string,
-	path: string,
-	import: string,
-	known: boolean_,
-	props: {
-		type: "array",
-		items: object({
-			name: string,
-			kind: string,
-			group: string,
-			options: {
-				type: "array",
-				items: { type: [
-					"string",
-					"number",
-					"boolean"
-				] }
-			},
-			default: { type: [
-				"string",
-				"number",
-				"boolean",
-				"null"
-			] },
-			required: boolean_
-		}, [
-			"group",
-			"options",
-			"default",
-			"required"
-		])
-	},
-	composition: object({
-		role: {
-			type: "string",
-			enum: [
-				"provider",
-				"wrapper",
-				"component"
-			],
-			description: "provider draws nothing and gives parts inside it context; wrapper draws and holds other parts."
-		},
-		parents: object({
-			status: {
-				type: "string",
-				enum: [
-					"listed",
-					"none",
-					"unknown"
-				],
-				description: "listed: insert it inside chain; none: it needs nothing; unknown: nothing says, see reason."
-			},
-			chain: {
-				type: "array",
-				description: "Outermost first.",
-				items: object({
-					component: string,
-					optional: boolean_
-				}, ["optional"])
-			},
-			from: {
-				...string,
-				description: "What said so, such as the library's examples or the error it throws."
-			},
-			reason: string
-		}, [
-			"chain",
-			"from",
-			"reason"
-		]),
-		holds: {
-			...strings,
-			description: "Parts that go directly inside it."
-		},
-		slots: {
-			type: "array",
-			items: object({
-				name: string,
-				key: string,
-				kind: {
-					type: "string",
-					enum: [
-						"children",
-						"element",
-						"render"
-					]
-				}
-			})
-		},
-		example: object({
-			node: {
-				type: "object",
-				description: "A node Insert takes as it is: the component inside its parents."
-			},
-			status: {
-				type: "string",
-				enum: [
-					"drawn",
-					"failing",
-					"untried"
-				],
-				description: "Whether the component has drawn on the canvas."
-			},
-			reason: string
-		}, ["reason"])
-	})
-}, [
-	"path",
-	"import",
-	"composition"
-]);
-const viewportSchema = object({
-	id: string,
-	name: string,
-	width: { type: "number" },
-	height: { type: "number" },
-	device: string
-}, ["device"]);
-const frameReportSchema = object({
-	mode: string,
-	width: { type: "number" },
-	height: {
-		type: "number",
-		description: "Fixed frame height, which clips; absent when it grows."
-	},
-	window: object({
-		width: { type: "number" },
-		height: { type: "number" }
-	})
-}, ["height"]);
-const modesSchema = object({
-	tab: ref,
-	variables: {
-		type: "array",
-		items: object({
-			id: string,
-			name: string,
-			kind: {
-				type: "string",
-				enum: [
-					"viewport",
-					"theme",
-					"locale",
-					"custom"
-				]
-			},
-			options: {
-				type: "array",
-				items: { type: "object" }
-			}
-		})
-	},
-	viewports: {
-		type: "array",
-		items: viewportSchema,
-		description: "Viewport ids, which Responsive and a node's responsive patches take. Not mode ids."
-	},
-	modes: {
-		type: "array",
-		description: "Mode ids, which renders (screenshot, problems, accessibility) and a design's modes take.",
-		items: object({
-			id: string,
-			name: string,
-			primary: boolean_,
-			viewport: string,
-			width: { type: "number" },
-			height: { type: "number" },
-			values: {
-				type: "object",
-				additionalProperties: string
-			},
-			classNames: strings,
-			attributes: {
-				type: "object",
-				additionalProperties: string
-			}
-		})
-	},
-	designs: {
-		type: "array",
-		items: object({
-			id: string,
-			name: string,
-			state: string,
-			states: strings,
-			main: string,
-			beside: strings,
-			frames: {
-				type: "array",
-				items: frameReportSchema
-			}
-		}, ["frames"])
-	}
-});
-const historySide = object({
-	count: integer,
-	labels: {
-		...strings,
-		description: "With summary: newest first, up to limit."
-	}
-}, ["labels"]);
-const statusSchema = object({
-	tab: ref,
-	revision: {
-		type: "string",
-		description: "Opaque; the same only while nothing in the tab has changed. Compare it with state's revision."
-	},
-	dirty: {
-		...boolean_,
-		description: "Something applied (and undoable) isn't on disk yet."
-	},
-	autosave: {
-		...boolean_,
-		description: "Changes save themselves; otherwise they wait for the person's Save."
-	},
-	unsaved: {
-		type: "array",
-		items: object({
-			path: string,
-			kind: {
-				type: "string",
-				enum: ["document", "stylesheet"]
-			},
-			designs: object({
-				added: strings,
-				changed: strings,
-				removed: strings
-			}),
-			modes: boolean_,
-			tokens: strings,
-			more: integer
-		}, [
-			"designs",
-			"modes",
-			"tokens",
-			"more"
-		])
-	},
-	tokenEdits: {
-		...integer,
-		description: "Token values waiting for Save to write them to the stylesheet."
-	},
-	save: object({
-		status: {
-			type: "string",
-			enum: [
-				"saved",
-				"unsaved",
-				"saving",
-				"failed"
-			]
-		},
-		error: string
-	}, ["error"]),
-	errors: {
-		type: "array",
-		items: object({
-			path: string,
-			error: string
-		})
-	},
-	undo: historySide,
-	redo: historySide
-}, []);
-const checks = {
-	tab,
-	design,
-	state: selector("State id, list of ids, or \"all\".", "all"),
-	mode: selector("Mode id, list of ids, \"shown\" or \"all\".", "shown")
-};
 const operations = {
-	tabs: mapped("tabs", {}, object({ tabs: {
-		type: "array",
-		items: tabSchema
-	} }), (tabs) => ({ tabs })),
-	state: operation("state", { tab }, stateSchema),
-	status: operation("status", {
-		tab,
-		summary: boolean("Add each unsaved file's designs and token values, and the undo and redo labels."),
-		limit: limit("Most ids or labels in each list of the summary.", 10, 100)
-	}, statusSchema),
-	modes: operation("modes", {
-		tab,
-		design: text$1("Design id or name. With it, just that design, with each of its frames' sizes.")
-	}, modesSchema),
-	open: operation("open", { root: root$1 }, tabSchema),
-	screenshot: mapped("screenshot", {
-		tab,
-		design,
-		scale,
-		state: selector("State id, list of ids, or \"all\". Defaults to the state the design shows."),
-		mode: selector("Mode id, list of ids, \"shown\" or \"all\". Defaults to the primary mode.")
-	}, execOutputSchema, (reply) => execResponse(reply, [
-		"tab",
-		"design",
-		"scale",
-		"state",
-		"mode"
-	]), {
+	tabs: mapped("tabs", requests.tabs, replies.tabs, (tabs) => ({ tabs })),
+	state: operation("state", requests.state, replies.state),
+	status: operation("status", requests.status, replies.status),
+	modes: operation("modes", requests.modes, replies.modes),
+	open: operation("open", requests.open, replies.open),
+	screenshot: mapped("screenshot", requests.screenshot, replies.screenshot, (reply) => execResponse(reply, Object.keys(requests.screenshot.shape)), {
 		failed: executionFailed,
 		structured: structuredExec
 	}),
-	problems: operation("problems", checks, problemsSchema, { failed: (result) => result.problems.length > 0 }),
-	accessibility: operation("accessibility", checks, accessibilitySchema, { failed: (result) => result.findings.length > 0 }),
-	console: mapped("console", {
-		tab,
-		clear: boolean("Empty the console after reading, including entries beyond limit."),
-		limit: limit("Most entries to return, newest kept.", 50, 1e3)
-	}, consoleSchema, ({ tab: from, entries }, request) => {
-		const { items, total, truncated } = bounded(entries, Number(request.limit), "last");
+	problems: operation("problems", requests.problems, replies.problems, { failed: (result) => result.problems.length > 0 }),
+	accessibility: operation("accessibility", requests.accessibility, replies.accessibility, { failed: (result) => result.findings.length > 0 }),
+	console: mapped("console", requests.console, replies.console, ({ tab, entries }, request) => {
+		const { items, total, truncated } = bounded(entries, request.limit, "last");
 		return {
-			tab: from,
+			tab,
 			entries: items,
 			total,
 			truncated
 		};
 	}),
-	tokens: mapped("tokens", {
-		tab,
-		category: text$1("Token category."),
-		source: text$1("Token source, such as semantic or theme."),
-		search: {
-			schema: {
-				type: "string",
-				description: "Token name search."
-			},
-			read(value) {
-				if (value !== void 0 && typeof value !== "string") throw invalidInput("search", "search must be a string");
-				return value;
-			}
-		},
-		limit: limit("Most tokens to return.", 100, 1e3)
-	}, tokensSchema, (tokens, request) => {
-		const { items, total, truncated } = bounded(tokens, Number(request.limit));
+	tokens: mapped("tokens", requests.tokens, replies.tokens, (tokens, request) => {
+		const { items, total, truncated } = bounded(tokens, request.limit);
 		return {
 			tokens: items,
 			total,
 			truncated
 		};
 	}),
-	components: operation("components", { tab }, componentsSchema),
-	props: operation("props", {
-		tab,
-		component: text$1("Component id or name.", true),
-		all: boolean("Include passed-through attributes.")
-	}, propsSchema)
+	components: operation("components", requests.components, replies.components),
+	props: operation("props", requests.props, replies.props)
 };
-const skill = fieldsContract({ path: text$1("Skill file to read.", false, "SKILL.md") });
 const skillOperation = {
-	inputSchema: skill.inputSchema,
-	fields: ["path"],
+	inputSchema: requestJsonSchema(skillRequest),
+	fields: Object.keys(skillRequest.shape),
 	async run(input, read) {
-		const { path } = skill.request(input);
-		if (typeof path !== "string") throw invalidInput("path", "path must be a nonblank string");
-		return read(path);
+		return read(readRequest(skillRequest, input, 1).path);
 	}
 };
 // src/skills.ts
@@ -1516,7 +584,7 @@ async function list(directory = root) {
 *
 * Tools publish no outputSchema (PAR-510). Claude Code never shows one to the model, Codex's code mode puts it in the
 * model's context, and with them tools/list was 33 KB rather than 11. structuredContent needs no schema; the contracts
-* keep theirs for CLI --json and the tests.
+* keep theirs, which the CLI checks the app's answers with.
 */
 function operationTool(name, description, operation, format) {
 	return {
@@ -1541,6 +609,17 @@ const executeNames = {
 	label: "description",
 	code: "input"
 };
+/** MCP's execute arguments under the contract's names: description is label and input is code. */
+function contractNames(input) {
+	const fields = plainObject.safeParse(input).data;
+	if (!fields) return input;
+	const { description: label, input: code, ...rest } = fields;
+	return {
+		...rest,
+		...label === void 0 ? {} : { label },
+		...code === void 0 ? {} : { code }
+	};
+}
 const tools = [
 	operationTool("get_tabs", "List the projects open in Parity, one per tab. The active tab is the one the person is looking at.", operations.tabs, json),
 	operationTool("get_app_state", "Get a tab's state: its designs (ids, states, modes shown, where their boards are and how big), boards that overlap or crowd each other's titles, the selection, project modes, components and tokens, and what Parity detected in the project (each tool's version, where it's installed and its config, the package manager, and a note naming versions Parity doesn't test). Call it first, and again after the person may have changed things. Keep boards apart: Overlaps() and FindEmptySpace() in execute help place them.", operations.state, json),
@@ -1553,13 +632,7 @@ const tools = [
 		fields: executeOperation.fields,
 		names: executeNames,
 		async run(input) {
-			const result = await executeOperation.run({
-				tab: input.tab,
-				label: input.description,
-				code: input.input,
-				editId: input.editId,
-				edits: input.edits
-			}, call);
+			const result = await executeOperation.run(contractNames(input), call);
 			const structured = executeOperation.structured(result);
 			return {
 				content: [text(describeExec(result)), ...result.screenshots.map((shot) => image(shot.png))],
@@ -1588,16 +661,36 @@ const tools = [
 	}
 ];
 const instructions = "Parity renders a project's real components on a canvas. Designs are trees of the project's own components, layouts and text, styled only with its tokens, with states (like stories) and modes (viewport, theme, locale). Read the skill (read_skill) before designing, start with get_app_state, change designs with execute, check every state and mode with screenshot and find_problems, check accessibility with check_accessibility, and read what the components log with get_console.";
+/**
+* One JSON-RPC message from the client, as far as the server reads it. `params` stays open, since each method reads
+* its own. A message without an id is a notification, which gets no reply.
+*/
+const message = z.looseObject({
+	id: z.union([z.string(), z.number()]).optional(),
+	method: z.string(),
+	params: z.looseObject({}).optional()
+});
+/** The client's side of `initialize`: who it is, for the canvas, and the protocol version it speaks. */
+const initializeParams = z.looseObject({
+	protocolVersion: z.string().optional().catch(void 0),
+	clientInfo: z.looseObject({
+		name: z.unknown().optional(),
+		title: z.unknown().optional()
+	}).optional().catch(void 0)
+});
+/** `tools/call`'s params: which tool, and its arguments, which the tool's own schema checks. */
+const toolCall = z.looseObject({
+	name: z.string(),
+	arguments: z.unknown()
+});
 /** Serves Parity's tools over MCP on stdin and stdout. */
 function serveMcp() {
 	const lines = createInterface({ input: process.stdin });
-	const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+	const send = (reply) => process.stdout.write(`${JSON.stringify(reply)}\n`);
 	lines.on("line", (line) => {
 		if (!line.trim()) return;
-		let message;
-		try {
-			message = JSON.parse(line);
-		} catch {
+		const json = jsonText(z.unknown()).safeParse(line);
+		if (!json.success) {
 			send({
 				jsonrpc: "2.0",
 				id: null,
@@ -1608,22 +701,37 @@ function serveMcp() {
 			});
 			return;
 		}
-		respond(message).then((reply) => {
-			if (message.id !== void 0 && reply) send({
+		const read = checkData(message, json.data);
+		if (!read.success) {
+			const id = z.union([z.string(), z.number()]).safeParse(plainObject.safeParse(json.data).data?.id).data ?? null;
+			const { pointer, message: problem } = read.problem;
+			send({
 				jsonrpc: "2.0",
-				id: message.id,
+				id,
+				error: {
+					code: -32600,
+					message: `Invalid request: ${pointer || "/"}: ${problem}`
+				}
+			});
+			return;
+		}
+		const request = read.data;
+		respond(request.method, request.params).then((reply) => {
+			if (request.id !== void 0 && reply) send({
+				jsonrpc: "2.0",
+				id: request.id,
 				...reply
 			});
 		});
 	});
 }
-async function respond(message) {
-	switch (message.method) {
+async function respond(method, params = {}) {
+	switch (method) {
 		case "initialize": {
-			const name = mcpCallerName(message.params?.clientInfo);
-			setCaller(name, true);
+			const { clientInfo, protocolVersion } = initializeParams.parse(params);
+			setCaller(mcpCallerName(clientInfo), true);
 			return { result: {
-				protocolVersion: message.params?.protocolVersion ?? "2025-06-18",
+				protocolVersion: protocolVersion ?? "2025-06-18",
 				capabilities: { tools: {} },
 				serverInfo: {
 					name: "parity",
@@ -1639,13 +747,21 @@ async function respond(message) {
 			inputSchema
 		})) } };
 		case "tools/call": {
-			const tool = tools.find((candidate) => candidate.name === message.params?.name);
+			const called = checkData(toolCall, params);
+			if (!called.success) {
+				const { pointer, message: problem } = called.problem;
+				return { error: {
+					code: -32602,
+					message: `Invalid params: ${pointer}: ${problem}`
+				} };
+			}
+			const tool = tools.find((candidate) => candidate.name === called.data.name);
 			if (!tool) return { error: {
 				code: -32602,
-				message: `Unknown tool ${String(message.params?.name)}`
+				message: `Unknown tool ${called.data.name}`
 			} };
 			try {
-				return { result: await tool.run(message.params?.arguments ?? {}) };
+				return { result: await tool.run(called.data.arguments ?? {}) };
 			} catch (error) {
 				const failure = renamePath(operationError(error, tool.fields), tool.names ?? {});
 				return { result: {
@@ -1655,9 +771,9 @@ async function respond(message) {
 				} };
 			}
 		}
-		default: return message.method?.startsWith("notifications/") ? void 0 : { error: {
+		default: return method.startsWith("notifications/") ? void 0 : { error: {
 			code: -32601,
-			message: `Unknown method ${message.method}`
+			message: `Unknown method ${method}`
 		} };
 	}
 }