@plitzi/sdk-mcp 0.37.2 → 0.37.3

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

@@ -1,5 +1,6 @@
 import { operation } from "./operations/index.js";
 import { defineTool, imageResult } from "./shared/tool.js";
+import { unnamedControls } from "../accessibilityOutline.js";
 import { z } from "zod";
 //#region src/modules/mcp/tools/screenshot.ts
 var VIEWPORTS = {
@@ -27,12 +28,29 @@ var screenshotShape = {
 		"mobile",
 		"both"
 	]).optional().describe("Which viewport(s) to capture. \"both\" catches responsive issues (e.g. overflow at one width). Default desktop."),
-	fullPage: z.boolean().optional().describe("Capture the full scrollable page instead of only the visible viewport. Default false.")
+	fullPage: z.boolean().optional().describe("Capture the full scrollable page instead of only the visible viewport. Default false."),
+	view: z.enum([
+		"image",
+		"accessibility",
+		"both"
+	]).optional().describe("What to bring back. \"image\" (default) is the picture. \"accessibility\" is the page as a screen reader and a browser agent (Claude in Chrome) read it — its accessibility tree as an outline of roles and names — with every control and picture that has no name listed; text only, far cheaper than an image. \"both\" is both.")
+};
+var VIEWS = {
+	image: ["image"],
+	accessibility: ["accessibility"],
+	both: ["image", "accessibility"]
 };
+/** Each viewport's outline, with what in it has no name — the part an agent acts on. */
+var readingOf = (outlines) => outlines.map(({ label, outline }) => ({
+	viewport: label,
+	outline,
+	unnamed: unnamedControls(outline)
+}));
+var ACCESSIBILITY_HINT = "Every entry in `unnamed` is a control or picture announced by its role alone (\"button\") — nobody using a screen reader, and no browser agent, can tell what it does. Name it — a button: `title` or words inside; a link: `label`; a field: `label` (with `hideLabel` to keep it out of sight); an image: `alt`, or `decorative: true`; an icon that means something alone: `label`. `line` is where it sits in the outline.";
 var screenshotTool = defineTool({
 	name: "plitzi_screenshot",
 	title: "Screenshot",
-	description: "Render a page to a real PNG image so you can SEE the visual result of your edits — overflow, misalignment and broken layout that data alone never reveals. Pass unsaved `operations` to screenshot a proposed change before committing, and viewport \"both\" to compare desktop and mobile. Returns the image(s).",
+	description: "Render a page to a real PNG image so you can SEE the visual result of your edits — overflow, misalignment and broken layout that data alone never reveals. Pass unsaved `operations` to screenshot a proposed change before committing, and viewport \"both\" to compare desktop and mobile. `view: \"accessibility\"` reads the page as a screen reader and a browser agent do instead, and lists every control with no name. Returns the image(s).",
 	inputShape: screenshotShape,
 	access: "read",
 	requires: "screenshot",
@@ -54,9 +72,10 @@ var screenshotTool = defineTool({
 		});
 		if (!pv.ok) return pv;
 		const viewports = resolveViewports(input.viewport);
+		const view = input.view ?? "image";
 		if (!ctx.screenshot) return {
 			warning: "SCREENSHOT_DISABLED",
-			message: "The screenshot service is not configured; returning the HTML preview instead.",
+			message: view === "image" ? "The screenshot service is not configured; returning the HTML preview instead." : "No browser is configured, so the accessibility tree cannot be read; returning the HTML preview instead. Its roles and names are in the markup: every button, link and field needs words, every image an `alt`.",
 			pageRef: input.pageRef ?? "default",
 			pagePath: pv.pagePath,
 			stateVersion: pv.stateVersion,
@@ -66,7 +85,8 @@ var screenshotTool = defineTool({
 			pagePath: pv.pagePath,
 			token: pv.token,
 			viewports,
-			fullPage: input.fullPage
+			fullPage: input.fullPage,
+			views: VIEWS[view]
 		});
 		if (!shot.ok) {
 			const fallback = await ctx.preview.render(draft);
@@ -80,11 +100,26 @@ var screenshotTool = defineTool({
 				html: fallback.ok ? fallback.html : ""
 			};
 		}
-		return imageResult(shot.images, {
+		const meta = {
 			pageRef: input.pageRef ?? "default",
 			pagePath: pv.pagePath,
 			stateVersion: pv.stateVersion,
 			viewports: viewports.map((v) => v.label)
+		};
+		const accessibility = view === "image" ? {} : shot.accessibility ? {
+			accessibility: readingOf(shot.accessibility),
+			hint: ACCESSIBILITY_HINT
+		} : {
+			warning: "ACCESSIBILITY_UNSUPPORTED",
+			message: "The browser service answered without the accessibility tree — it predates the accessibility view. The image, if asked for, is still here."
+		};
+		if (view === "accessibility") return {
+			...meta,
+			...accessibility
+		};
+		return imageResult(shot.images, {
+			...meta,
+			...accessibility
 		});
 	}
 });

package/dist/modules/mcp/tools/shared/draftBatch.d.ts

@@ -0,0 +1,25 @@
+import { ValidationMode } from './validator/context';
+import { Space } from '../../helpers';
+import { Env, MutationOutcome, ValidationError } from '../../types';
+import { Operation } from '../operations';
+export type DraftResult = {
+    ok: false;
+    errors: ValidationError[];
+    warnings: string[];
+} | {
+    ok: true;
+    ops: Operation[];
+    draft: Space;
+    outcome: MutationOutcome;
+    warnings: string[];
+};
+/**
+ * A batch run on a copy of the space and read back — the one way every tool that takes operations handles them, so
+ * `plitzi_validate` answers exactly what `plitzi_apply` would, and `plitzi_render` holds a widget to the same rules.
+ *
+ * In order: the sugar ops expanded; what was already wrong with the elements the batch touches fixed where it has one
+ * reading (`fixTouched`, each fix said in `warnings`); each op checked against the input it takes; the batch applied to
+ * the copy; and the copy read by `lintDraft` — structure and meaning, the same reading every other writer gets. The
+ * first stage to refuse ends it; the space handed in is never touched.
+ */
+export declare const draftBatch: (space: Space, env: Env, operations: Operation[], mode?: ValidationMode) => DraftResult;

package/dist/modules/mcp/tools/shared/draftBatch.js

@@ -0,0 +1,58 @@
+import { cloneSpace } from "../../helpers/space.js";
+import { expandOperations } from "./expandOperations.js";
+import { fixTouched, lintDraft } from "./lintDraft.js";
+import { validateOperations } from "./validator/index.js";
+import { applyOperations } from "../apply/dispatch.js";
+//#region src/modules/mcp/tools/shared/draftBatch.ts
+/**
+* A batch run on a copy of the space and read back — the one way every tool that takes operations handles them, so
+* `plitzi_validate` answers exactly what `plitzi_apply` would, and `plitzi_render` holds a widget to the same rules.
+*
+* In order: the sugar ops expanded; what was already wrong with the elements the batch touches fixed where it has one
+* reading (`fixTouched`, each fix said in `warnings`); each op checked against the input it takes; the batch applied to
+* the copy; and the copy read by `lintDraft` — structure and meaning, the same reading every other writer gets. The
+* first stage to refuse ends it; the space handed in is never touched.
+*/
+var draftBatch = (space, env, operations, mode = "space") => {
+	const expansion = expandOperations(operations);
+	if (expansion.errors.length > 0) return {
+		ok: false,
+		errors: expansion.errors,
+		warnings: []
+	};
+	const ops = expansion.operations;
+	const prepared = fixTouched(space, ops);
+	const validation = validateOperations(prepared.space, ops, mode);
+	if (!validation.valid) return {
+		ok: false,
+		errors: validation.errors,
+		warnings: [...prepared.fixed, ...validation.warnings]
+	};
+	const draft = cloneSpace(prepared.space);
+	const outcome = applyOperations(draft, env, ops);
+	if (outcome.errors.length > 0) return {
+		ok: false,
+		errors: outcome.errors,
+		warnings: [...prepared.fixed, ...validation.warnings]
+	};
+	const reading = lintDraft(draft, ops, prepared.space);
+	const warnings = [
+		...prepared.fixed,
+		...validation.warnings,
+		...reading.warnings
+	];
+	if (reading.errors.length > 0) return {
+		ok: false,
+		errors: reading.errors,
+		warnings
+	};
+	return {
+		ok: true,
+		ops,
+		draft,
+		outcome,
+		warnings
+	};
+};
+//#endregion
+export { draftBatch };

package/dist/modules/mcp/tools/shared/draftBatch.test.d.ts

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

package/dist/modules/mcp/tools/shared/lintDraft.d.ts

@@ -0,0 +1,30 @@
+import { Space } from '../../helpers';
+import { ValidationResult } from '../../types';
+import { Operation } from '../operations';
+/**
+ * The space as the batch should meet it: what was already wrong with the elements it is about to change, fixed where
+ * the problem has one reading — a typo of an attribute, a URL left in page mode, a flag written as text.
+ *
+ * On the space BEFORE the batch, and only on the elements it touches. Fixing the result instead would "fix" the
+ * batch's own mistakes — drop the attribute an agent just misspelt, and with it what it meant to say — where those
+ * must be refused with the reason. Every fix is said in the answer, so nothing changes that the agent is not told of.
+ * What has no single reading is left, and still blocks the batch as pre-existing.
+ */
+export declare const fixTouched: (space: Space, ops: Operation[]) => {
+    space: Space;
+    fixed: string[];
+};
+/**
+ * The resulting space, read by the same checks every other door uses — `authorSpace`, the server's publish gate, the
+ * builder's problems panel — and held to what this batch did.
+ *
+ * - A structural error the batch introduced blocks it wherever it landed: a delete can orphan an element the batch
+ *   never named, and a broken tree is never left for later.
+ * - Everything found in an element the batch touches blocks it, structural or not. One already there is labelled
+ *   pre-existing, so the agent never takes it for its own change — and fixes it in the same batch.
+ * - Elements the batch never touches are not held against it.
+ *
+ * The space as it was is read only when the draft has something to say about: telling an old issue from a new one is
+ * the one thing that reading is for, and most batches leave nothing to tell.
+ */
+export declare const lintDraft: (draft: Space, ops: Operation[], before?: Space) => ValidationResult;

package/dist/modules/mcp/tools/shared/lintDraft.js

@@ -0,0 +1,142 @@
+import { findElementByRef, findPageByRef } from "../../helpers/space.js";
+import { elementSourceTypes, fixSpace, lintSpace } from "@plitzi/sdk-authoring";
+import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
+import { styleWithoutTag } from "@plitzi/sdk-schema/helpers/styleWithoutTag";
+//#region src/modules/mcp/tools/shared/lintDraft.ts
+/** The elements a batch touches, by the ref each op names — what the lint of the result is held to. */
+var touchedRefs = (ops) => {
+	const refs = /* @__PURE__ */ new Set();
+	for (const op of ops) switch (op.type) {
+		case "upsertElement":
+			refs.add(op.element.ref);
+			break;
+		case "patchElement":
+		case "moveElement":
+		case "upsertBinding":
+		case "patchBinding":
+		case "deleteBinding":
+		case "upsertInteractionFlow":
+		case "patchInteractionNode":
+		case "deleteInteraction": refs.add(op.ref);
+	}
+	return refs;
+};
+/** Those refs as the ids they name in `space` — a ref for an element the batch creates names nothing yet. */
+var touchedIds = (space, ops) => new Set([...touchedRefs(ops)].flatMap((ref) => {
+	const element = findElementByRef(space.schema, ref) ?? findPageByRef(space.schema, ref);
+	return element ? [element.id] : [];
+}));
+/** The deployment's own plugins are types too; without them every one of them reads as a typo. */
+var catalogsOf = (space) => ({ pluginTypes: Object.entries(space.catalog ?? {}).filter(([, entry]) => entry.custom).map(([type]) => type) });
+/**
+* The space as the batch should meet it: what was already wrong with the elements it is about to change, fixed where
+* the problem has one reading — a typo of an attribute, a URL left in page mode, a flag written as text.
+*
+* On the space BEFORE the batch, and only on the elements it touches. Fixing the result instead would "fix" the
+* batch's own mistakes — drop the attribute an agent just misspelt, and with it what it meant to say — where those
+* must be refused with the reason. Every fix is said in the answer, so nothing changes that the agent is not told of.
+* What has no single reading is left, and still blocks the batch as pre-existing.
+*/
+var fixTouched = (space, ops) => {
+	const ids = touchedIds(space, ops);
+	if (ids.size === 0) return {
+		space,
+		fixed: []
+	};
+	const { schema, applied } = fixSpace({
+		schema: space.schema,
+		style: space.style
+	}, catalogsOf(space), void 0, ids);
+	if (applied.length === 0) return {
+		space,
+		fixed: []
+	};
+	return {
+		space: {
+			...space,
+			schema
+		},
+		fixed: applied.map((fix) => `Fixed a pre-existing problem in element "${fix.elementId ?? ""}" while changing it: ${fix.message}`)
+	};
+};
+/** One reading of a space: its structure — with the source catalogue, so a binding onto nothing is caught — and its meaning. */
+var readingOf = (space) => {
+	const structure = validateSchema(space.schema, { sourceTypes: elementSourceTypes });
+	const meaning = lintSpace({
+		schema: space.schema,
+		style: space.style
+	}, catalogsOf(space));
+	return {
+		structure,
+		meaning,
+		all: [
+			...structure.errors,
+			...meaning.errors,
+			...meaning.warnings
+		]
+	};
+};
+var keyOf = (issue) => JSON.stringify([
+	issue.code,
+	issue.elementId ?? "",
+	issue.message
+]);
+var kindOf = (issue) => JSON.stringify([issue.code, issue.elementId ?? ""]);
+var countByKind = (issues) => {
+	const counts = /* @__PURE__ */ new Map();
+	issues.forEach((issue) => counts.set(kindOf(issue), (counts.get(kindOf(issue)) ?? 0) + 1));
+	return counts;
+};
+/**
+* Which of the draft's issues the space already had.
+*
+* The same message is the same issue. But a message also says where the element is and what it might have meant — a
+* page renamed, a closer name added to the space — so it can change while the issue does not. A kind of issue on an
+* element (its code there) the draft has no more of than the space had is the same issue in other words; one more of
+* it than before is the batch's.
+*/
+var preExistingIn = (before, draft) => {
+	const messages = new Set(before.map(keyOf));
+	const had = countByKind(before);
+	const has = countByKind(draft);
+	return (issue) => messages.has(keyOf(issue)) || (has.get(kindOf(issue)) ?? 0) <= (had.get(kindOf(issue)) ?? 0);
+};
+/**
+* The resulting space, read by the same checks every other door uses — `authorSpace`, the server's publish gate, the
+* builder's problems panel — and held to what this batch did.
+*
+* - A structural error the batch introduced blocks it wherever it landed: a delete can orphan an element the batch
+*   never named, and a broken tree is never left for later.
+* - Everything found in an element the batch touches blocks it, structural or not. One already there is labelled
+*   pre-existing, so the agent never takes it for its own change — and fixes it in the same batch.
+* - Elements the batch never touches are not held against it.
+*
+* The space as it was is read only when the draft has something to say about: telling an old issue from a new one is
+* the one thing that reading is for, and most batches leave nothing to tell.
+*/
+var lintDraft = (draft, ops, before) => {
+	const touched = touchedIds(draft, ops);
+	const { structure, meaning, all } = readingOf(draft);
+	const onTouched = (issue) => issue.elementId !== void 0 && touched.has(issue.elementId);
+	const candidates = [...structure.errors, ...meaning.errors.filter(onTouched)];
+	const touchedWarnings = [...structure.warnings, ...meaning.warnings].filter(onTouched);
+	const preExisting = before && (candidates.length > 0 || touchedWarnings.length > 0) ? preExistingIn(readingOf(before).all, all) : () => false;
+	const toError = (issue) => ({
+		path: issue.elementId ? `element "${issue.elementId}"` : "schema",
+		message: preExisting(issue) ? `Pre-existing malformation in element "${issue.elementId ?? ""}": ${issue.message}` : issue.message,
+		hint: preExisting(issue) ? "This issue already exists in the space (NOT caused by your change), but the save is blocked until you fix it too, in this same batch." : ""
+	});
+	const errors = candidates.filter((issue) => onTouched(issue) || !preExisting(issue)).map(toError);
+	const warnings = touchedWarnings.map((issue) => preExisting(issue) ? `Pre-existing issue in element "${issue.elementId ?? ""}": ${issue.message}` : issue.message);
+	for (const id of touched) {
+		const tagless = styleWithoutTag(draft.schema.flat[id], draft.style);
+		if (tagless) warnings.push(`element "${id}" ${tagless}`);
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+};
+//#endregion
+export { fixTouched, lintDraft };

package/dist/modules/mcp/tools/shared/lintDraft.test.d.ts

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

package/dist/modules/mcp/tools/shared/tool.d.ts

@@ -4,6 +4,7 @@ import { ResourceProxy } from '../../proxy';
 import { PreviewClient, ScreenshotClient, ScreenshotImage, Env, Persisters } from '../../types';
 import { McpUiToolMeta } from '@modelcontextprotocol/ext-apps';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { ActionRunReport } from '@plitzi/sdk-shared';
 /** Everything a tool needs at call time: the loaded space, the target environment, and the persisters (only the
  *  write tools use them). Built by whoever hosts the tools — the standalone MCP server or the in-process AI
  *  engine — so a tool's behavior never touches spaceId resolution or adapters directly. `spaceId`, `preview` and
@@ -19,6 +20,9 @@ export interface ToolContext {
      *  plitzi_render uses it: a widget renders inside the host's sandbox, where an undeclared origin cannot be
      *  reached at all. */
     proxy?: ResourceProxy;
+    /** Runs one task of the space's functions in the sandbox, for the person behind the connection — when the host
+     *  wired it. Only plitzi_try_function uses it. */
+    tryFunction?: (task: string, params: Record<string, unknown>) => Promise<ActionRunReport>;
 }
 /** A capability a tool depends on; the host skips registering a tool whose capability it did not wire (so
  *  plitzi_screenshot simply does not appear when no browser service is configured). */

package/dist/modules/mcp/tools/shared/validator/bindings.d.ts

@@ -1,6 +1,2 @@
 import { ValidationCtx } from './context';
-import { Space } from '../../../helpers';
-import { BindingTransformer } from '@plitzi/sdk-shared';
 export declare const checkBindingTarget: (ref: string, category: string | undefined, to: string, path: string, ctx: ValidationCtx) => void;
-export declare const checkBindingSourceScope: (space: Space, ctx: ValidationCtx, elementRef: string, source: string, path: string) => void;
-export declare const checkBindingTransformers: (transformers: BindingTransformer[] | undefined, path: string, ctx: ValidationCtx) => void;

package/dist/modules/mcp/tools/shared/validator/bindings.js

@@ -1,20 +1,5 @@
-import { getTransformer, suggestTransformer } from "../../../catalogs/index.js";
-import { descendantIds, findElementByRef } from "../../../helpers/space.js";
 import { warnOnce } from "./context.js";
-import getSourceName from "@plitzi/sdk-shared/dataSource/helpers/getSourceName";
 //#region src/modules/mcp/tools/shared/validator/bindings.ts
-var providerOfSource = (space, source) => {
-	const head = source.split(".")[0];
-	const sep = head.indexOf("_");
-	if (sep < 0) return;
-	const elementId = head.slice(sep + 1);
-	const el = findElementByRef(space.schema, elementId);
-	if (!el || getSourceName(el.definition.type, el.id) !== head) return;
-	return {
-		ref: el.id,
-		id: el.id
-	};
-};
 var checkBindingTarget = (ref, category, to, path, ctx) => {
 	if (category !== "attributes" && category !== "initialState") return;
 	const type = ctx.elementType(ref);
@@ -22,49 +7,5 @@ var checkBindingTarget = (ref, category, to, path, ctx) => {
 	if (!targets || targets.size === 0 || targets.has(to)) return;
 	warnOnce(ctx, `Binding target "${to}" at ${path} is not among the "${category}" targets the type "${type}" declares (${[...targets].sort().join(", ")}). Verify against plitzi://data-sources; it may still be valid.`);
 };
-var checkBindingSourceScope = (space, ctx, elementRef, source, path) => {
-	const provider = providerOfSource(space, source);
-	if (!provider) return;
-	const bound = findElementByRef(space.schema, elementRef);
-	if (!bound) return;
-	if (bound.id !== provider.id && descendantIds(space.schema, provider.id).includes(bound.id)) return;
-	ctx.errors.push({
-		path,
-		message: `Binding source "${source}" is provided by element "${provider.ref}", but "${elementRef}" is not inside its subtree`,
-		hint: `An element source is scoped to its DESCENDANTS only, so this binding resolves to nothing at runtime (the source is not available outside "${provider.ref}"). Move "${elementRef}" under "${provider.ref}", or bind to a source that is in scope (e.g. a global module source like state/space/navigation).`
-	});
-};
-var checkBindingTransformers = (transformers, path, ctx) => {
-	transformers?.forEach((transformer, i) => {
-		if (transformer.enabled === false) return;
-		const base = `${path}[${i}]`;
-		const spec = getTransformer(transformer.action);
-		if (!spec) {
-			const suggestion = suggestTransformer(transformer.action);
-			ctx.errors.push({
-				path: `${base}.action`,
-				message: `Unknown transformer action "${transformer.action}"`,
-				hint: `The runtime skips an unknown transformer and passes the value through unchanged.${suggestion ? ` Did you mean "${suggestion}"?` : ""} See the transformers list in plitzi://data-sources.`
-			});
-			return;
-		}
-		const params = transformer.params;
-		const unknown = Object.keys(params).filter((key) => !(key in spec.params));
-		if (spec.strictParams && unknown.length > 0) warnOnce(ctx, `Transformer "${transformer.action}" at ${base} got unknown param(s) ${unknown.map((k) => `"${k}"`).join(", ")} — the runtime ignores them. Valid params: ${Object.keys(spec.params).join(", ") || "(none)"}.`);
-		for (const [key, param] of Object.entries(spec.params)) {
-			if (param.required && !(key in params)) ctx.errors.push({
-				path: `${base}.params.${key}`,
-				message: `Transformer "${transformer.action}" is missing required param "${key}"`,
-				hint: param.description
-			});
-			if (param.type === "select" && param.options && key in params && !param.options.includes(String(params[key]))) ctx.errors.push({
-				path: `${base}.params.${key}`,
-				message: `Transformer "${transformer.action}" param "${key}" is "${params[key]}", not one of its options`,
-				hint: `Use one of: ${param.options.join(", ")}.`,
-				validValues: param.options
-			});
-		}
-	});
-};
 //#endregion
-export { checkBindingSourceScope, checkBindingTarget, checkBindingTransformers };
+export { checkBindingTarget };

package/dist/modules/mcp/tools/shared/validator/elements.js

@@ -1,23 +1,13 @@
 import { definitionVariantNames } from "../../operations/style/translator.js";
-import { RAW_CODE_TYPES, checkVarRefs, warnOnce } from "./context.js";
+import { RAW_CODE_TYPES, warnOnce } from "./context.js";
 import { checkIdRef } from "./refs.js";
 //#region src/modules/mcp/tools/shared/validator/elements.ts
 var checkTypeProps = (type, props, path, ctx) => {
-	if (!props || RAW_CODE_TYPES.has(type)) return;
 	const meta = ctx.typeMeta.get(type);
+	if (!props || RAW_CODE_TYPES.has(type) || meta?.custom === false) return;
 	const known = meta && meta.attributes.size > 0 ? meta.attributes : ctx.typeProps.get(type);
 	if (!known || known.size === 0) return;
-	const strict = meta?.custom === false;
-	for (const key of Object.keys(props)) {
-		if (key === "subType" || known.has(key)) continue;
-		if (strict) ctx.errors.push({
-			path,
-			message: `Type "${type}" has no attribute "${key}"`,
-			hint: `Valid attributes: ${[...known].sort().join(", ")}`,
-			validValues: [...known].sort()
-		});
-		else warnOnce(ctx, `Type "${type}" has no observed prop "${key}" at ${path} (known: ${[...known].sort().join(", ")}). It may still be valid — verify against plitzi://types.`);
-	}
+	for (const key of Object.keys(props)) if (key !== "subType" && !known.has(key)) warnOnce(ctx, `Type "${type}" has no observed prop "${key}" at ${path} (known: ${[...known].sort().join(", ")}). It may still be valid — verify against plitzi://types.`);
 };
 var checkVariantApplication = (initialState, path, ctx) => {
 	for (const [cls, selectors] of Object.entries(initialState?.styleVariant ?? {})) {
@@ -43,8 +33,6 @@ var checkRawMarkup = (type, props, path, ctx) => {
 };
 var checkElementProps = (element, path, ctx) => {
 	checkRawMarkup(element.type, element.props, path, ctx);
-	if (!element.props || RAW_CODE_TYPES.has(element.type)) return;
-	for (const [key, value] of Object.entries(element.props)) if (typeof value === "string") checkVarRefs(value, `${path}.props.${key}`, ctx);
 	checkTypeProps(element.type, element.props, path, ctx);
 };
 var checkElementInput = (element, path, ctx, seen) => {

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

@@ -1,8 +1,5 @@
-import { ValidationCtx, ValidationMode } from './context';
+import { ValidationMode } from './context';
 import { Space } from '../../../helpers';
 import { ValidationResult } from '../../../types';
 import { Operation } from '../../operations';
-/** The shared validation context, derived from a space (+ the batch's ops, for batch-declared names). Extracted so
- *  the post-apply resource audit (auditResources) can run the same checks against the resulting draft. */
-export declare const buildValidationCtx: (space: Space, ops: Operation[], mode?: ValidationMode) => ValidationCtx;
 export declare const validateOperations: (space: Space, ops: Operation[], mode?: ValidationMode) => ValidationResult;

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

@@ -4,8 +4,8 @@ import { elementTypeNames } from "../../../catalogs/index.js";
 import { findElementByRef, findFolderByRef, findPageByRef, findRootByRef, folderAncestorIds, getLayoutElements, getPageElements, pageFoldersOf, resolveRef, routeParamNames } from "../../../helpers/space.js";
 import { MAX_OPS } from "../../operations/index.js";
 import { batchDeclaredElements, batchDeclaredFolders, batchDeclaredPages, batchDeclaredVariants, batchDeclaredVars } from "./batch.js";
-import { checkObservedName, checkVarRefs, warnOnce } from "./context.js";
-import { checkBindingSourceScope, checkBindingTarget, checkBindingTransformers } from "./bindings.js";
+import { checkObservedName, warnOnce } from "./context.js";
+import { checkBindingTarget } from "./bindings.js";
 import { batchDeclaredConnectors, checkConnectorOp, checkProviderElement } from "./connectors.js";
 import { checkSlotCss } from "./css.js";
 import { checkRef } from "./refs.js";
@@ -38,8 +38,7 @@ var buildTypeMeta = (catalog) => {
 	}
 	return meta;
 };
-/** The shared validation context, derived from a space (+ the batch's ops, for batch-declared names). Extracted so
-*  the post-apply resource audit (auditResources) can run the same checks against the resulting draft. */
+/** The shared validation context, derived from a space (+ the batch's ops, for batch-declared names). */
 var buildValidationCtx = (space, ops, mode = "space") => {
 	const registry = buildTypeRegistry(space.schema, space.catalog);
 	const batchElements = batchDeclaredElements(ops);
@@ -103,12 +102,9 @@ var validateOperations = (space, ops, mode = "space") => {
 				checkRef(op.ref, `${base}.ref`, ctx);
 				const page = findRootByRef(space.schema, op.pageRef);
 				const target = page ? resolveRef(space.schema, page, op.ref) : void 0;
-				if (op.props) {
-					for (const [key, value] of Object.entries(op.props)) if (typeof value === "string") checkVarRefs(value, `${base}.props.${key}`, ctx);
-					if (target && target.id !== page?.id) {
-						checkRawMarkup(target.definition.type, op.props, base, ctx);
-						checkTypeProps(target.definition.type, op.props, base, ctx);
-					}
+				if (op.props && target && target.id !== page?.id) {
+					checkRawMarkup(target.definition.type, op.props, base, ctx);
+					checkTypeProps(target.definition.type, op.props, base, ctx);
 				}
 				checkVariantApplication(op.initialState, `${base}.initialState`, ctx);
 				if (target && target.definition.type === PROVIDER_TYPE) checkProviderElement(space, ctx, op.ref, op.runtime ?? target.definition.runtime, {
@@ -202,26 +198,17 @@ var validateOperations = (space, ops, mode = "space") => {
 				checkRef(op.ref, `${base}.ref`, ctx);
 				checkObservedName(op.binding.source, ctx.observedSources, "Data source", "plitzi://data-sources", `${base}.binding.source`, ctx);
 				checkBindingTarget(op.ref, op.category, op.binding.to, `${base}.binding.to`, ctx);
-				checkBindingSourceScope(space, ctx, op.ref, op.binding.source, `${base}.binding.source`);
-				checkBindingTransformers(op.binding.transformers, `${base}.binding.transformers`, ctx);
 				break;
 			case "patchBinding":
 				checkRef(op.ref, `${base}.ref`, ctx);
 				checkObservedName(op.source, ctx.observedSources, "Data source", "plitzi://data-sources", `${base}.source`, ctx);
 				checkBindingTarget(op.ref, op.category, op.to, `${base}.to`, ctx);
-				if (op.source !== void 0) checkBindingSourceScope(space, ctx, op.ref, op.source, `${base}.source`);
-				checkBindingTransformers(op.transformers, `${base}.transformers`, ctx);
 				break;
 			case "deleteBinding":
 				checkRef(op.ref, `${base}.ref`, ctx);
 				break;
 			case "upsertInteractionFlow":
 				checkRef(op.ref, `${base}.ref`, ctx);
-				if (op.nodes[0] && op.nodes[0].nodeType !== "trigger") ctx.errors.push({
-					path: `${base}.nodes[0].nodeType`,
-					message: "The first node of a flow must be a trigger",
-					hint: "Put the trigger first; the callbacks/utilities that run after it follow in order"
-				});
 				{
 					const named = /* @__PURE__ */ new Set();
 					op.nodes.forEach((node, n) => {
@@ -269,6 +256,24 @@ var validateOperations = (space, ops, mode = "space") => {
 			case "patchConnector":
 				checkRef(op.ref, `${base}.ref`, ctx);
 				break;
+			case "patchSettings":
+				["transientState", "paintedState"].forEach((setting) => {
+					(op[setting] ?? []).forEach((key, index) => {
+						if (key.trim() === "" || key.includes(".")) ctx.errors.push({
+							path: `${base}.${setting}[${index}]`,
+							message: `"${key}" is not a top-level state key: no dots, not empty`,
+							hint: `Name the key setState writes — "${key.split(".")[0] || "tourStep"}" covers everything under it`
+						});
+					});
+				});
+				(op.paintedState ?? []).forEach((key, index) => {
+					if (op.transientState?.includes(key)) ctx.errors.push({
+						path: `${base}.paintedState[${index}]`,
+						message: `"${key}" is in both paintedState and transientState`,
+						hint: "A painted key is kept so the server can draw with it; a transient one never is — remove it from one"
+					});
+				});
+				break;
 			case "deleteInteraction":
 				checkRef(op.ref, `${base}.ref`, ctx);
 				if (Boolean(op.flowId) === Boolean(op.nodeId)) ctx.errors.push({
@@ -285,4 +290,4 @@ var validateOperations = (space, ops, mode = "space") => {
 	};
 };
 //#endregion
-export { buildValidationCtx, validateOperations };
+export { validateOperations };