@plitzi/sdk-mcp 0.38.6 → 0.38.8

package/dist/modules/mcp/tools/apply/index.js

@@ -2,7 +2,10 @@ import { dataFileUri, dataUri, functionFileUri, functionsUri } from "../../helpe
 import { changedResources, conflictMessage, detectConflicts, resolvedElements } from "./writeResult.js";
 import { environment, operations } from "../operations/index.js";
 import { draftBatch } from "../shared/draftBatch.js";
-import { defineTool } from "../shared/tool.js";
+import { effectsOf } from "../shared/effects.js";
+import { fullPage, lookAt, pageRef, viewport } from "../shared/look.js";
+import { AGAIN, REPEATED, batchKey, forgetRefused, noteRefused, timesRefused } from "../shared/repeats.js";
+import { defineTool, imageResult } from "../shared/tool.js";
 import { z } from "zod";
 import { generateCache } from "@plitzi/sdk-style/StyleHelper";
 //#region src/modules/mcp/tools/apply/index.ts
@@ -10,8 +13,18 @@ var applyShape = {
 	environment,
 	dryRun: z.boolean().optional().describe("Validate and apply in memory only, WITHOUT persisting. Returns the same result (changed versions + full element detail) so you can inspect the outcome and decide on more changes before committing for real."),
 	expectedResourceVersions: z.record(z.string(), z.string()).optional().describe("Resource URI → the stateVersion you read; guards against concurrent edits"),
-	operations
+	operations,
+	look: z.enum([
+		"html",
+		"image",
+		"accessibility",
+		"both"
+	]).optional().describe("Also render the page: with dryRun, as the batch would leave it (nothing saved); without, as it was saved. \"html\" the markup, \"image\" a PNG, \"accessibility\" the outline a screen reader reads (text, far cheaper than an image), \"both\" image and outline. Check, look and then save with the same operations — written once."),
+	pageRef,
+	viewport,
+	fullPage
 };
+var NOTHING_CHANGED = "Nothing changed: every operation left the space as it was.";
 var noWarnings = (warnings) => warnings.length > 0 ? warnings : void 0;
 /** Why the platform did not save the functions, as the batch's errors: each problem where it is, or the refusal. */
 var functionsErrors = (saved, env) => "problems" in saved ? saved.problems.map((problem) => ({
@@ -62,7 +75,9 @@ var apply = async (input, space, persisters) => {
 		errors: result.errors,
 		warnings: noWarnings(result.warnings)
 	};
-	const { draft, outcome, warnings, suggestions } = result;
+	const { draft, outcome, suggestions } = result;
+	const effects = effectsOf(space, draft);
+	const warnings = effects.length > 0 ? result.warnings : [NOTHING_CHANGED, ...result.warnings];
 	if (input.dryRun) return {
 		applied: false,
 		dryRun: true,
@@ -71,12 +86,13 @@ var apply = async (input, space, persisters) => {
 			updated: outcome.updated,
 			deleted: outcome.deleted
 		},
+		effects,
 		changed: changedResources(draft, env, outcome.staleResources),
 		elements: resolvedElements(draft, env, outcome.elementRefs),
 		warnings: noWarnings(warnings),
 		suggestions: noWarnings(suggestions)
 	};
-	let persisted = true;
+	const unsaved = [];
 	if (outcome.changedFunctions && draft.functions) {
 		if (persisters?.saveFunctions) {
 			const saved = await persisters.saveFunctions(draft.functions.files, space.functions?.version ?? "");
@@ -92,7 +108,7 @@ var apply = async (input, space, persisters) => {
 				errors: functionsErrors(saved, env),
 				warnings: noWarnings(warnings)
 			};
-		} else persisted = false;
+		} else unsaved.push("the functions");
 	}
 	if (outcome.changedData && draft.data) {
 		if (persisters?.saveData) {
@@ -109,56 +125,90 @@ var apply = async (input, space, persisters) => {
 				errors: dataErrors(saved, env),
 				warnings: noWarnings([...outcome.changedFunctions && persisters.saveFunctions ? ["The functions of this batch were saved; the data was not — apply the data again once fixed"] : [], ...warnings])
 			};
-		} else persisted = false;
+		} else unsaved.push("the data");
 	}
 	if (outcome.changedSchema) {
 		if (persisters?.schema) await persisters.schema(draft.schema);
-		else persisted = false;
+		else unsaved.push("the schema");
 	}
 	if (outcome.changedStyle) {
 		if (persisters?.style) {
 			draft.style.cache = generateCache(draft.style);
 			await persisters.style(draft.style);
-		} else persisted = false;
+		} else unsaved.push("the style");
 	}
 	for (const id of outcome.changedConnectors) {
 		const entry = draft.connectors.find((item) => item.id === id);
 		if (entry && persisters?.saveConnector) await persisters.saveConnector(entry);
-		else persisted = false;
+		else unsaved.push(`connector ${id}`);
 	}
 	for (const id of outcome.deletedConnectors) if (persisters?.deleteConnector) await persisters.deleteConnector(id);
-	else persisted = false;
+	else unsaved.push(`the removal of connector ${id}`);
 	for (const id of outcome.changedActions) {
 		const entry = draft.actions.find((item) => item.id === id);
 		if (entry && persisters?.saveAction) await persisters.saveAction(entry);
-		else persisted = false;
+		else unsaved.push(`action ${id}`);
 	}
 	for (const id of outcome.deletedActions) if (persisters?.deleteAction) await persisters.deleteAction(id);
-	else persisted = false;
+	else unsaved.push(`the removal of action ${id}`);
 	return {
 		applied: true,
-		persisted,
+		persisted: unsaved.length === 0,
 		summary: {
 			created: outcome.created,
 			updated: outcome.updated,
 			deleted: outcome.deleted
 		},
+		effects,
 		changed: changedResources(draft, env, outcome.staleResources),
 		elements: resolvedElements(draft, env, outcome.elementRefs),
-		warnings: noWarnings(warnings),
+		warnings: noWarnings([...unsaved.length > 0 ? [`NOT saved: ${unsaved.join(", ")} — this server has no store to save it in`] : [], ...warnings]),
 		suggestions: noWarnings(suggestions)
 	};
 };
 var applyTool = defineTool({
 	name: "plitzi_apply",
 	title: "Apply",
-	description: "Validate, apply and persist a batch of operations atomically. Returns the changed resources and their new versions, plus the full detail of every element it created or updated. Pass dryRun to apply in memory only (inspect the outcome without committing). Rejects the whole batch on any error or version conflict — INCLUDING a pre-existing malformation in any resource the batch touches (fix it in the same batch to unblock the save).",
+	description: "Validate, apply and persist a batch of operations atomically. Returns `effects` (what it changed, read off the space), the changed resources’ new versions and each created or updated element’s detail. Pass dryRun to apply in memory only (inspect the outcome without committing), and `look` to see the page as the batch leaves it. Rejects the whole batch on any error or version conflict — INCLUDING a pre-existing malformation in any resource the batch touches (fix it in the same batch to unblock the save).",
 	inputShape: applyShape,
+	carriesOperations: true,
 	access: "write",
-	run: (input, ctx) => apply({
-		...input,
-		environment: ctx.env
-	}, ctx.space, ctx.persisters)
+	run: async (input, ctx) => {
+		const key = batchKey(`${String(ctx.spaceId ?? "")}:${ctx.env}`, input.operations);
+		const before = timesRefused(key);
+		if (before >= 2) return REPEATED;
+		const result = await apply({
+			...input,
+			environment: ctx.env
+		}, ctx.space, ctx.persisters);
+		if (result.errors?.length) {
+			noteRefused(key);
+			return before === 1 ? {
+				...result,
+				again: AGAIN
+			} : result;
+		}
+		forgetRefused(key);
+		if (!input.look || !result.applied && !result.dryRun) return result;
+		const look = await lookAt(ctx, {
+			pageRef: input.pageRef,
+			operations: result.dryRun ? input.operations : void 0,
+			view: input.look,
+			viewport: input.viewport,
+			fullPage: input.fullPage
+		});
+		if ("refused" in look) return {
+			...result,
+			look: look.refused
+		};
+		return look.images.length > 0 ? imageResult(look.images, {
+			...result,
+			look: look.meta
+		}) : {
+			...result,
+			look: look.meta
+		};
+	}
 });
 //#endregion
-export { apply, applyShape, applyTool };
+export { NOTHING_CHANGED, apply, applyShape, applyTool };

package/dist/modules/mcp/tools/describeOperation.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const describeOperationShape: {
+    type: z.ZodOptional<z.ZodString>;
+};
+/**
+ * One operation's schema, by its type — the low level asked for one piece at a time, so a connection does not have to
+ * load all of it to write one operation. A type that does not exist is answered with the closed list and the nearest
+ * name: an agent that guessed is told what there is, never left to guess again.
+ */
+export declare const describeOperation: (type: string | undefined) => Record<string, unknown>;
+export declare const describeOperationTool: import('.').ToolDef;

package/dist/modules/mcp/tools/describeOperation.js

@@ -0,0 +1,40 @@
+import { OPERATIONS_BY_TYPE } from "./operations/index.js";
+import { defineTool } from "./shared/tool.js";
+import { closest } from "@plitzi/sdk-authoring";
+import { z } from "zod";
+//#region src/modules/mcp/tools/describeOperation.ts
+var describeOperationShape = { type: z.string().optional().describe("The operation type, as in a batch: \"upsertElement\", \"patchDefinition\"… Left out, every type is listed.") };
+/**
+* One operation's schema, by its type — the low level asked for one piece at a time, so a connection does not have to
+* load all of it to write one operation. A type that does not exist is answered with the closed list and the nearest
+* name: an agent that guessed is told what there is, never left to guess again.
+*/
+var describeOperation = (type) => {
+	const types = [...OPERATIONS_BY_TYPE.keys()];
+	if (type === void 0) return { types };
+	const schema = OPERATIONS_BY_TYPE.get(type);
+	if (!schema) {
+		const nearest = closest(type, types);
+		return {
+			error: "UNKNOWN_OPERATION",
+			message: `There is no "${type}" operation${nearest ? ` — did you mean "${nearest}"?` : ""}`,
+			...nearest ? { describe: { type: nearest } } : {},
+			types
+		};
+	}
+	return {
+		type,
+		schema: z.toJSONSchema(schema)
+	};
+};
+var describeOperationTool = defineTool({
+	name: "plitzi_describe_operation",
+	title: "Describe an operation",
+	description: "The schema of one operation plitzi_apply or plitzi_render takes, by its type: every field, which are required, what each means. Without a type, every operation type there is.",
+	inputShape: describeOperationShape,
+	access: "read",
+	spaceless: true,
+	run: (input) => describeOperation(input.type)
+});
+//#endregion
+export { describeOperation, describeOperationShape, describeOperationTool };

package/dist/modules/mcp/tools/describeOperation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/mcp/tools/index.d.ts

@@ -1,12 +1,7 @@
 import { ToolDef } from './shared/tool';
 export { apply, applyShape } from './apply';
-export { validate, validateShape } from './validate';
 export { search, searchShape } from './search';
 export { read, readShape } from './read';
-export { previewShape } from './preview';
-export { render, renderShape } from './render';
-export { screenshotShape } from './screenshot';
-export { applyOperations } from './apply/dispatch';
 export { validateOperations } from './shared/validator';
 export { operation } from './operations';
 /** The MCP tool registry — the single source the server registers from. Adding a tool is: create its file with a
@@ -15,4 +10,4 @@ export declare const tools: ToolDef[];
 export type { ToolContext, ToolDef } from './shared/tool';
 export type { OpResult } from '../helpers';
 export type { DefinitionSlotInput, DefinitionSlotPatch, ElementInput, Operation, OperationType } from './operations';
-export type { ApplyInput, ChangedResource, Conflict, Persisters, WriteElement, WriteResponse, ValidateInput, ValidationResult, MutationOutcome, SearchHit, SearchInput, SearchResponse, SearchPageHit, ReadInput, ReadResponse, ReadHit } from '../types';
+export type { ApplyInput, ChangedResource, Conflict, Persisters, WriteElement, WriteResponse, ValidationResult, MutationOutcome, SearchHit, SearchInput, SearchResponse, SearchPageHit, ReadInput, ReadResponse, ReadHit } from '../types';

package/dist/modules/mcp/tools/index.js

@@ -1,26 +1,29 @@
 import { operation } from "./operations/index.js";
-import { validateOperations } from "./shared/validator/index.js";
-import { applyOperations } from "./apply/dispatch.js";
+import "./shared/validator/index.js";
 import { apply, applyShape, applyTool } from "./apply/index.js";
-import { previewTool } from "./preview.js";
+import { describeOperationTool } from "./describeOperation.js";
+import { addPageTool, bindAttributeTool, placeComponentTool, setAttributesTool, setClassesTool } from "./intents.js";
+import { lookTool } from "./look.js";
 import { read, readShape, readTool } from "./read.js";
 import { renderTool } from "./render.js";
-import { screenshotTool } from "./screenshot.js";
 import { search, searchShape, searchTool } from "./search.js";
 import { tryFunctionTool } from "./tryFunction.js";
-import { validate, validateShape, validateTool } from "./validate.js";
 //#region src/modules/mcp/tools/index.ts
 /** The MCP tool registry — the single source the server registers from. Adding a tool is: create its file with a
 *  ToolDef descriptor and append it here. */
 var tools = [
 	applyTool,
-	validateTool,
+	setAttributesTool,
+	setClassesTool,
+	bindAttributeTool,
+	placeComponentTool,
+	addPageTool,
 	searchTool,
+	describeOperationTool,
 	readTool,
 	renderTool,
-	previewTool,
-	screenshotTool,
+	lookTool,
 	tryFunctionTool
 ];
 //#endregion
-export { apply, applyOperations, applyShape, operation, read, readShape, search, searchShape, tools, validate, validateOperations, validateShape };
+export { apply, applyShape, operation, read, readShape, search, searchShape, tools };

package/dist/modules/mcp/tools/intents.d.ts

@@ -0,0 +1,5 @@
+export declare const setAttributesTool: import('.').ToolDef;
+export declare const setClassesTool: import('.').ToolDef;
+export declare const bindAttributeTool: import('.').ToolDef;
+export declare const placeComponentTool: import('.').ToolDef;
+export declare const addPageTool: import('.').ToolDef;

package/dist/modules/mcp/tools/intents.js

@@ -0,0 +1,201 @@
+import { findElementByRef } from "../helpers/space.js";
+import { scalar } from "./operations/schema/shared.js";
+import { defineTool } from "./shared/tool.js";
+import { apply } from "./apply/index.js";
+import { closest } from "@plitzi/sdk-authoring";
+import { z } from "zod";
+//#region src/modules/mcp/tools/intents.ts
+/** The element a ref names, with the page or layout it is on — or the nearest ref there is. */
+var locate = (ctx, ref) => {
+	const element = findElementByRef(ctx.space.schema, ref);
+	if (element) return {
+		element,
+		root: element.definition.rootId,
+		classes: element.definition.styleSelectors.base.split(/\s+/).filter(Boolean)
+	};
+	const nearest = closest(ref, Object.keys(ctx.space.schema.flat));
+	return {
+		done: false,
+		errors: [{
+			path: "ref",
+			message: `There is no element "${ref}"${nearest ? ` — did you mean "${nearest}"?` : ""}`,
+			hint: "plitzi_search finds an element by its words, type or class"
+		}]
+	};
+};
+/** The attributes of an element a binding computes, with the source each reads. */
+var boundOf = (element) => new Map((element.definition.bindings?.attributes ?? []).map((binding) => [binding.to, binding.source]));
+/**
+* The batch applied, answered with what it did. `notes` are what the agent believed that was already so — a class it
+* wears, an attribute it did not have — said beside the effects, never dropped because nothing came of them.
+*/
+var run = async (ctx, operations, page, notes = []) => {
+	const result = await apply({
+		operations,
+		environment: ctx.env
+	}, ctx.space, ctx.persisters);
+	const warnings = [...notes, ...result.warnings ?? []];
+	if (!result.applied) return {
+		done: false,
+		errors: result.errors ?? (result.conflict ? [result.conflict] : []),
+		...warnings.length > 0 ? { warnings } : {}
+	};
+	return {
+		done: true,
+		saved: result.persisted !== false,
+		effects: result.effects ?? [],
+		...warnings.length > 0 ? { warnings } : {},
+		next: `plitzi_look { pageRef: "${page}" } to see it`
+	};
+};
+var setAttributesTool = defineTool({
+	name: "plitzi_set_attributes",
+	title: "Set an element’s attributes",
+	description: "Set or remove attributes of one element — its words (`content`), a link’s `href`, an image’s `src` and `alt`, a field’s `label`… — by its ref. plitzi://explain/{type} lists what a type takes.",
+	inputShape: {
+		ref: z.string().describe("The element, by its ref"),
+		set: z.record(z.string(), scalar).optional().describe("Attributes to write: { \"content\": \"Start free\" }"),
+		unset: z.array(z.string()).optional().describe("Attributes to remove")
+	},
+	access: "write",
+	run: async (input, ctx) => {
+		const at = locate(ctx, input.ref);
+		if ("done" in at) return at;
+		const set = input.set ?? {};
+		const unset = input.unset ?? [];
+		const bound = boundOf(at.element);
+		const covered = [...Object.keys(set), ...unset].filter((key) => bound.has(key));
+		if (covered.length > 0) return {
+			done: false,
+			errors: covered.map((key) => ({
+				path: key,
+				message: `${key} of ${input.ref} is bound to ${String(bound.get(key))}: the page shows what the binding computes, not a value written here`,
+				hint: "plitzi_bind_attribute changes what it reads; to write a value instead, plitzi_apply deleteBinding first"
+			}))
+		};
+		const { attributes } = at.element;
+		const notes = [...Object.entries(set).filter(([key, value]) => attributes[key] === value).map(([key, value]) => `${key} was already ${JSON.stringify(value)}`), ...unset.filter((key) => !(key in attributes)).map((key) => `${key} was not set`)];
+		const props = {
+			...set,
+			...Object.fromEntries(unset.map((key) => [key, null]))
+		};
+		return run(ctx, [{
+			type: "patchElement",
+			pageRef: at.root,
+			ref: input.ref,
+			props
+		}], at.root, notes);
+	}
+});
+var setClassesTool = defineTool({
+	name: "plitzi_set_classes",
+	title: "Add or remove an element’s classes",
+	description: "Add classes to one element, or take them off; the ones it wears and you do not name stay. A class is a definition of the space (plitzi://definitions/{env}).",
+	inputShape: {
+		ref: z.string().describe("The element, by its ref"),
+		add: z.array(z.string()).optional().describe("Classes it should also wear, by name"),
+		remove: z.array(z.string()).optional().describe("Classes it should no longer wear, by name")
+	},
+	access: "write",
+	run: async (input, ctx) => {
+		const at = locate(ctx, input.ref);
+		if ("done" in at) return at;
+		const absent = (input.remove ?? []).filter((name) => !at.classes.includes(name));
+		if (absent.length > 0) return {
+			done: false,
+			errors: absent.map((name) => {
+				const nearest = closest(name, at.classes);
+				return {
+					path: "remove",
+					message: `${input.ref} does not wear "${name}"${nearest ? ` — did you mean "${nearest}"?` : ""}; it wears ${at.classes.join(", ") || "no class"}`
+				};
+			})
+		};
+		const notes = (input.add ?? []).filter((name) => at.classes.includes(name)).map((name) => `${input.ref} already wore ${name}`);
+		const removed = new Set(input.remove ?? []);
+		const base = [...at.classes.filter((name) => !removed.has(name)), ...(input.add ?? []).filter((name) => !at.classes.includes(name))];
+		return run(ctx, [{
+			type: "patchElement",
+			pageRef: at.root,
+			ref: input.ref,
+			style: { base }
+		}], at.root, notes);
+	}
+});
+var bindAttributeTool = defineTool({
+	name: "plitzi_bind_attribute",
+	title: "Bind an element to data",
+	description: "Feed one attribute of an element from a data source — a list’s `items` from `apiContainer_products.data`, a heading’s `content` from a field. Sources: plitzi://data-sources/{env}.",
+	inputShape: {
+		ref: z.string().describe("The element, by its ref"),
+		to: z.string().describe("The attribute it feeds: \"items\", \"content\"…"),
+		source: z.string().describe("The source path, spelled in full: \"apiContainer_products.data\"")
+	},
+	access: "write",
+	run: async (input, ctx) => {
+		const at = locate(ctx, input.ref);
+		if ("done" in at) return at;
+		const was = boundOf(at.element).get(input.to);
+		return run(ctx, [{
+			type: "upsertBinding",
+			pageRef: at.root,
+			ref: input.ref,
+			category: "attributes",
+			binding: {
+				to: input.to,
+				source: input.source
+			}
+		}], at.root, was === void 0 ? [] : [`${input.ref}.${input.to} was bound to ${was}: replaced`]);
+	}
+});
+var placeComponentTool = defineTool({
+	name: "plitzi_place_component",
+	title: "Place a component",
+	description: "Place an instance of one of the space’s components inside an element, handing it its props. plitzi://schema/{env}/components lists them and what each takes.",
+	inputShape: {
+		component: z.string().describe("The component, by its ref"),
+		ref: z.string().describe("A ref for the new instance"),
+		into: z.string().describe("The element it goes inside, by its ref"),
+		props: z.record(z.string(), scalar).optional().describe("What it hands the component: { \"title\": \"Lamp\" }")
+	},
+	access: "write",
+	run: async (input, ctx) => {
+		const at = locate(ctx, input.into);
+		if ("done" in at) return at;
+		return run(ctx, [{
+			type: "upsertElement",
+			pageRef: at.root,
+			parentRef: input.into,
+			element: {
+				ref: input.ref,
+				type: "reference",
+				props: {
+					referenceType: "component",
+					referenceId: input.component,
+					...input.props
+				}
+			}
+		}], at.root);
+	}
+});
+var addPageTool = defineTool({
+	name: "plitzi_add_page",
+	title: "Add a page",
+	description: "A new page at a slug, inside a layout when the space has one for it (plitzi://schema/{env}/pages).",
+	inputShape: {
+		ref: z.string().describe("Its ref: \"pricing\""),
+		slug: z.string().describe("Its path, relative and without a leading slash: \"pricing\", \"posts/:postId\""),
+		label: z.string().optional().describe("Its name in the builder"),
+		layout: z.string().optional().describe("The layout it renders inside, by its ref")
+	},
+	access: "write",
+	run: async (input, ctx) => run(ctx, [{
+		type: "upsertPage",
+		ref: input.ref,
+		slug: input.slug,
+		...input.label ? { label: input.label } : {},
+		...input.layout ? { layout: input.layout } : {}
+	}], input.ref)
+});
+//#endregion
+export { addPageTool, bindAttributeTool, placeComponentTool, setAttributesTool, setClassesTool };

package/dist/modules/mcp/tools/look.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const lookShape: {
+    pageRef: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodEnum<{
+        image: "image";
+        accessibility: "accessibility";
+        html: "html";
+        both: "both";
+    }>>;
+    viewport: z.ZodOptional<z.ZodEnum<{
+        desktop: "desktop";
+        mobile: "mobile";
+        both: "both";
+    }>>;
+    fullPage: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const lookTool: import('.').ToolDef;

package/dist/modules/mcp/tools/look.js

@@ -0,0 +1,32 @@
+import { fullPage, lookAt, pageRef, viewport } from "./shared/look.js";
+import { defineTool, imageResult } from "./shared/tool.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/look.ts
+var lookShape = {
+	pageRef,
+	view: z.enum([
+		"accessibility",
+		"html",
+		"image",
+		"both"
+	]).optional().describe("How to see it. \"accessibility\" (default): the page as a screen reader and a browser agent read it — an outline of roles and names, every control with no name listed; text, and cheap. \"html\": the markup. \"image\": a PNG, for what only a picture shows — overflow, misalignment. \"both\": image and outline."),
+	viewport,
+	fullPage
+};
+var lookTool = defineTool({
+	name: "plitzi_look",
+	title: "Look at a page",
+	description: "See a saved page: its accessibility outline (default, text), its HTML, or a PNG. To see a change before saving it, plitzi_apply with `dryRun` and `look` instead.",
+	inputShape: lookShape,
+	access: "read",
+	run: async (input, ctx) => {
+		const look = await lookAt(ctx, {
+			...input,
+			view: input.view ?? "accessibility"
+		});
+		if ("refused" in look) return look.refused;
+		return look.images.length > 0 ? imageResult(look.images, look.meta) : look.meta;
+	}
+});
+//#endregion
+export { lookShape, lookTool };

package/dist/modules/mcp/tools/operations/closed.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+/** A part of an operation (`an element`), closed: its fields as `shape` declares them, and no other. */
+export declare const closedObject: <Shape extends z.ZodRawShape>(owner: string, shape: Shape, listed: string) => z.ZodObject<{ -readonly [P in keyof Shape]: Shape[P]; }, z.core.$strict>;
+/** An operation's type, as its schema states it. */
+export declare const typeOf: (operation: z.ZodObject) => string;
+/** An operation, closed: its fields as declared, its description kept. */
+export declare const closed: <Shape extends z.ZodRawShape>(operation: z.ZodObject<Shape>) => z.ZodObject<{ -readonly [P in keyof Shape]: Shape[P]; }, z.core.$strict>;

package/dist/modules/mcp/tools/operations/closed.js

@@ -0,0 +1,29 @@
+import { closest } from "@plitzi/sdk-authoring";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/closed.ts
+/**
+* Objects of the write vocabulary that refuse a field they do not have. One left out of a schema used to be dropped as
+* the batch was read — `prop` for `props` applied nothing and answered success, the one mistake an agent cannot see.
+* Refused instead, with the field meant and where every field is listed.
+*/
+/** What a field `owner` does not have is answered with: the nearest one it does, and where every one is listed. */
+var unknownFields = (owner, written, fields, listed) => {
+	return `${owner} has no field ${written.map((key) => {
+		const nearest = closest(key, fields);
+		return nearest ? `"${key}" (did you mean "${nearest}"?)` : `"${key}"`;
+	}).join(", ")}: ${listed} lists its fields`;
+};
+/** A part of an operation (`an element`), closed: its fields as `shape` declares them, and no other. */
+var closedObject = (owner, shape, listed) => {
+	const fields = Object.keys(shape);
+	return z.strictObject(shape, { error: (issue) => issue.code === "unrecognized_keys" ? unknownFields(owner, issue.keys, fields, listed) : void 0 });
+};
+/** An operation's type, as its schema states it. */
+var typeOf = (operation) => operation.shape.type instanceof z.ZodLiteral ? String(operation.shape.type.value) : "";
+/** An operation, closed: its fields as declared, its description kept. */
+var closed = (operation) => {
+	const type = typeOf(operation);
+	return closedObject(type, operation.shape, `plitzi_describe_operation { type: "${type}" }`).describe(operation.description ?? "");
+};
+//#endregion
+export { closed, closedObject, typeOf };