@plitzi/sdk-server 0.32.24 → 0.33.0

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

@@ -1,184 +0,0 @@
-import { iconFontCss } from "../apps/render/styles.js";
-import { RENDER_APP_URI } from "../apps/render/index.js";
-import { emptySpace } from "../helpers/space.js";
-import { proxifyResources } from "../proxy/rewrite.js";
-import { operations } from "./operations/index.js";
-import { applyOperations } from "./apply/dispatch.js";
-import { expandOperations } from "./shared/expandOperations.js";
-import { defineTool } from "./shared/tool.js";
-import { validateOperations } from "./shared/validator/index.js";
-import { auditResources } from "./shared/validator/audit.js";
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
-import { generateCache } from "@plitzi/sdk-style/StyleHelper";
-//#region src/modules/mcp/tools/render.ts
-var HOST_PAGE_REF = "render";
-var seedSpace = () => {
-	const space = emptySpace();
-	space.schema.definition.name = "Widget";
-	space.schema.flat[HOST_PAGE_REF] = {
-		id: HOST_PAGE_REF,
-		idRef: HOST_PAGE_REF,
-		attributes: {
-			slug: "",
-			name: "Render",
-			default: true
-		},
-		definition: {
-			rootId: HOST_PAGE_REF,
-			label: "Page",
-			type: "page",
-			items: [],
-			styleSelectors: { base: "" }
-		}
-	};
-	space.schema.pages = [HOST_PAGE_REF];
-	return space;
-};
-var noWarnings = (warnings) => warnings.length > 0 ? warnings : void 0;
-var renderShape = {
-	operations,
-	patch: z.boolean().optional().describe("Set true to CHANGE a widget you already rendered instead of rebuilding it: send its `renderId` and ONLY the operations that differ (patchDefinition, patchElement, deleteElement, a new repeatElement…). The widget merges them into the batch it was built from and reports back what it applied. The refs it already has (card-1, blk-2-3) are the ones to address. If that widget cannot be recovered — a surface that renders none, a host that keeps no storage — the answer says so and you re-send the whole batch."),
-	renderId: z.string().optional().describe("Handle returned by a previous render. Required with patch:true; it names the widget being changed.")
-};
-var render = (input, options = {}) => {
-	const space = seedSpace();
-	const expansion = expandOperations(input.operations);
-	if (expansion.errors.length > 0) return {
-		rendered: false,
-		errors: expansion.errors
-	};
-	const ops = expansion.operations;
-	const validation = validateOperations(space, ops, "widget");
-	if (!validation.valid) return {
-		rendered: false,
-		errors: validation.errors,
-		warnings: noWarnings(validation.warnings)
-	};
-	const outcome = applyOperations(space, "main", ops);
-	if (outcome.errors.length > 0) return {
-		rendered: false,
-		errors: outcome.errors,
-		warnings: noWarnings(validation.warnings)
-	};
-	const integrity = validateSchema(space.schema);
-	if (!integrity.valid) return {
-		rendered: false,
-		errors: integrity.errors.map((error) => ({
-			path: error.elementId ? `schema.${error.elementId}` : "schema",
-			message: error.message,
-			hint: "The authored widget is structurally inconsistent (broken parent/child link or a cycle)."
-		})),
-		warnings: noWarnings(validation.warnings)
-	};
-	const audit = auditResources(space, ops);
-	const warnings = [...validation.warnings, ...audit.warnings];
-	if (audit.errors.length > 0) return {
-		rendered: false,
-		errors: audit.errors,
-		warnings: noWarnings(warnings)
-	};
-	if (options.proxy) warnings.push(...proxifyResources(space, options.proxy));
-	space.style.cache = generateCache(space.style);
-	return {
-		rendered: true,
-		operations: ops,
-		rootRef: HOST_PAGE_REF,
-		elementCount: Object.keys(space.schema.flat).length - 1,
-		offlineData: {
-			schema: space.schema,
-			style: space.style
-		},
-		warnings: noWarnings(warnings)
-	};
-};
-/** A patch is not rendered here — it CANNOT be: this server keeps nothing between calls (no session, no store,
-*  any replica answers any request), so the previous widget only exists on the host side. The delta therefore
-*  travels as a courier result: the model pays for the delta alone, the view recovers the batch that widget was
-*  built from (by renderId — see apps/render/heldBatch.ts), merges, and re-calls this same tool with the whole
-*  thing over the host bridge, never through the model's context, then reports back with ui/update-model-context.
-*
-*  The renderId is the explicit handle the MCP RC asks for in place of implicit session state: the model carries
-*  it, so a patch names the widget it means and any replica can serve it.
-*
-*  Validation is not skipped, only deferred: the re-call carries the full batch, so refs, integrity and the audit
-*  all run exactly as they do on a first render, and their errors reach the model through that report. */
-var toPatchResult = (ops, renderId) => {
-	if (ops.length === 0) return { content: [{
-		type: "text",
-		text: JSON.stringify({
-			patch: false,
-			error: "A patch carries no operations",
-			hint: "Send the operations that differ from the widget on screen, or drop `patch` to render a new one."
-		})
-	}] };
-	if (renderId === void 0) return { content: [{
-		type: "text",
-		text: JSON.stringify({
-			patch: false,
-			error: "A patch needs the renderId of the widget it changes",
-			hint: "Pass the renderId the render answered with, or drop `patch` to render a new widget."
-		})
-	}] };
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify({
-				patch: true,
-				renderId,
-				operations: ops.length,
-				note: "Handed to the widget; it will report what it applied. If nothing reports back, it could not be recovered — re-send the full batch without patch."
-			})
-		}],
-		structuredContent: {
-			patch: true,
-			renderId,
-			operations: ops
-		}
-	};
-};
-var newRenderId = () => `r${randomUUID().slice(0, 8)}`;
-var ICON_TYPE = "fontAwesome";
-var drawsIcons = (offlineData) => Object.values(offlineData.schema.flat).some((element) => element.definition.type === ICON_TYPE);
-var toRenderResult = (res, renderId) => {
-	if (!res.rendered) return { content: [{
-		type: "text",
-		text: JSON.stringify({
-			rendered: false,
-			errors: res.errors,
-			warnings: res.warnings
-		})
-	}] };
-	const summary = {
-		rendered: true,
-		renderId,
-		rootRef: res.rootRef,
-		elementCount: res.elementCount,
-		warnings: res.warnings
-	};
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify(summary)
-		}],
-		structuredContent: {
-			...summary,
-			offlineData: res.offlineData,
-			operations: res.operations,
-			...drawsIcons(res.offlineData) ? { iconCss: iconFontCss() } : {}
-		}
-	};
-};
-var renderTool = defineTool({
-	name: "plitzi_render",
-	title: "Render widget",
-	description: "Show the user a real, rendered UI widget instead of describing one — cards, hero sections, pricing tables, forms, menus, checklists, profiles, galleries. It runs the Plitzi SDK fully offline: no backend, account, or setup. Reach for it whenever a visual layout beats prose: the user asks you to design/build/show something, OR your answer is naturally visual (a recipe → a card, a comparison → a table, steps → a checklist). Prefer showing over telling.\n\nAuthor the widget as an ordered list of `operations` that build an element tree under the pre-seeded root page \"render\". Three rules:\n1. STRUCTURE — one upsertElement builds the whole tree: set pageRef:\"render\" and give element a nested `children` array. Each element is { ref (unique), type, subType?, props?, style?, children? }; children render in order. (To attach to something you already made, use a top-level parentRef:\"<existing ref>\" instead.)\n1b. REPEATS — the moment two siblings share a shape and differ only in data (list, steps, cards, table, timeline), do NOT copy-paste them: use repeatElement { pageRef, ref (wrapper), style, template, items }. The template is written once with {{item.field}} placeholders and rendered per row; refs come out numbered (\"step-1\", \"step-2\"…). A list INSIDE each row (days with their own steps) is the same op: give the wrapping node repeat:{ items:\"{{item.<list>}}\", template:… } and put the sub-rows in the row data.\n2. STYLE — declare ALL the classes in ONE upsertDefinitions { definitions: { \"<class>\": { desktop:{ …CSS in kebab-case… } }, … } }, then attach via the element style:{ base:[\"<class ref>\"] }. Lay containers out with flex/grid. Keep the call small: one class per look, not per property.\n2a. GRAPHICS — a logo, a sparkline, a badge, a decorative shape: draw it as an INLINE <svg> in a blockHtml element (props.content), keeping a viewBox with width/height \"100%\" so its class sizes it, and fill/stroke \"currentColor\" so it follows the host theme. Budget it: a handful of paths, drawn once and reused, never a data: URI and never a full illustration — a photo-real scene costs more than the whole widget, so use an https image, a flat colour or a gradient for that. Markup only: scripts and on* handlers are rejected.\n2b. LAYOUT — it renders in a side panel, so width is free and HEIGHT is scarce. Plain containers stack children vertically, which is the tall half-empty default to avoid: put peers (metrics, plans, options, image + text) in a wrapping row — display:flex, flex-direction:row, flex-wrap:wrap, children flex-grow:\"1\" + flex-basis:\"0%\" + min-width — or a grid with grid-template-columns:\"repeat(auto-fit, minmax(160px, 1fr))\". Keep padding 12-16px and gap 8-12px, and let the outer container fill the panel. Stack only what reads in order (heading over paragraph, forms, steps, prose). Nothing carries a minimum size, so an element with no content and no size takes none — give a spacer or a rail its own height/width — while heading/paragraph do keep the margins the browser gives them (zero them, space with the parent gap).\n2c. THEME — it is embedded in the host UI, which MAY BE DARK, so never hardcode a light palette. Take colours from the host variables with a light-dark() fallback — background-color:\"var(--color-background-secondary, light-dark(#ffffff, #1f2430))\", color:\"var(--color-text-primary, light-dark(#0f172a, #e8eaed))\", border-color:\"var(--color-border-primary, light-dark(#e2e8f0, #333a48))\" — and always set `color` wherever you set `background-color` (a brand accent states its own text colour too).\n3. CONTENT — visible copy goes in props.content (text, heading, paragraph, button); heading level is the element subType (\"h1\"..\"h6\"); image/video take props.src. Write real https URLs: everything the widget loads from outside (images, media, fonts, an apiContainer endpoint) is fetched for it by the render server, so redirects and hotlink rules are handled and there is nothing to configure. It must still point at the actual file — use a URL you have seen work, and when you have none, draw the block with a gradient or an inline SVG instead of guessing one. An unknown prop comes back as a warning naming the right one.\n\nCommon types: container, heading, paragraph, text, button, link, image, video, list, listItem, markdown (plitzi://render/types lists every built-in type with descriptions). Widgets can also be data-driven and interactive — an apiContainer fetches at runtime, upsertBinding wires data into elements, and upsertInteractionFlow makes them react to clicks (see the guide).\nREAD the resource plitzi://render/guide first — it has the element/prop table, the style model and a full worked example, and following it is the difference between a widget that renders and repeated failed calls.\nITERATING — to change a widget you already rendered, do NOT rebuild it: call again with patch:true, the `renderId` that render answered with, and ONLY the operations that differ (patchDefinition, patchElement, deleteElement…). The widget merges them and reports back what it applied; address rows by the refs you already know. Patch ONLY to modify that widget: a different subject or a different kind of widget is a fresh render, without patch — a patch is merged into the previous batch, so patching a new idea leaves you with both.\nReturns a compact summary including the renderId (the widget itself is shown to the user); on failure it returns teachable errors (path + hint) — read them and retry.",
-	inputShape: renderShape,
-	access: "read",
-	spaceless: true,
-	ui: { resourceUri: RENDER_APP_URI },
-	run: (input, ctx) => input.patch === true ? toPatchResult(input.operations, input.renderId) : toRenderResult(render(input, { proxy: ctx.proxy }), input.renderId ?? newRenderId())
-});
-//#endregion
-export { render, renderShape, renderTool };

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

@@ -1,83 +0,0 @@
-import { operation } from "./operations/index.js";
-import { defineTool, imageResult } from "./shared/tool.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/screenshot.ts
-var VIEWPORTS = {
-	desktop: {
-		label: "desktop",
-		width: 1440,
-		height: 900
-	},
-	mobile: {
-		label: "mobile",
-		width: 390,
-		height: 844
-	}
-};
-var resolveViewports = (choice) => {
-	if (choice === "both") return [VIEWPORTS.desktop, VIEWPORTS.mobile];
-	if (choice === "mobile") return [VIEWPORTS.mobile];
-	return [VIEWPORTS.desktop];
-};
-var screenshotShape = {
-	pageRef: z.string().optional().describe("Page ref or id to capture; defaults to the space default page"),
-	operations: z.array(operation).max(100).optional().describe("Unsaved edits to apply before rendering, so you can screenshot a proposed change WITHOUT persisting it (same op vocabulary as plitzi_apply). Omit to capture the current saved state."),
-	viewport: z.enum([
-		"desktop",
-		"mobile",
-		"both"
-	]).optional().describe("Which viewport(s) to capture. \"both\" catches responsive issues (e.g. overflow at one width). Default desktop.")
-};
-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).",
-	inputShape: screenshotShape,
-	access: "read",
-	requires: "screenshot",
-	run: async (input, ctx) => {
-		if (!ctx.preview || ctx.spaceId === void 0) return {
-			error: "PREVIEW_UNAVAILABLE",
-			message: "Visual preview is not enabled on this server.",
-			hint: "Preview needs the SSR render service; it is unavailable in MCP-only mode."
-		};
-		const pv = await ctx.preview.render({
-			spaceId: ctx.spaceId,
-			env: ctx.env,
-			pageRef: input.pageRef,
-			operations: input.operations
-		});
-		if (!pv.ok) return pv;
-		const viewports = resolveViewports(input.viewport);
-		if (!ctx.screenshot) return {
-			warning: "SCREENSHOT_DISABLED",
-			message: "The screenshot service is not configured; returning the HTML preview instead.",
-			pageRef: input.pageRef ?? "default",
-			pagePath: pv.pagePath,
-			stateVersion: pv.stateVersion,
-			html: pv.html
-		};
-		const shot = await ctx.screenshot.capture({
-			pagePath: pv.pagePath,
-			token: pv.token,
-			viewports
-		});
-		if (!shot.ok) return {
-			warning: "SCREENSHOT_UNAVAILABLE",
-			message: `The screenshot service failed (${shot.message}); returning the HTML preview instead.`,
-			hint: "The dedicated browser service is down or unreachable. Inspect the HTML, or retry later.",
-			pageRef: input.pageRef ?? "default",
-			pagePath: pv.pagePath,
-			stateVersion: pv.stateVersion,
-			html: pv.html
-		};
-		return imageResult(shot.images, {
-			pageRef: input.pageRef ?? "default",
-			pagePath: pv.pagePath,
-			stateVersion: pv.stateVersion,
-			viewports: viewports.map((v) => v.label)
-		});
-	}
-});
-//#endregion
-export { screenshotShape, screenshotTool };

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

@@ -1,115 +0,0 @@
-import { computeVersion } from "../helpers/computeVersion.js";
-import { elementRefOf, getPageElements, isPageElement, nameOf, pageRefOf, pageRefOfElement } from "../helpers/space.js";
-import { elementUri, pageUri } from "../helpers/uris.js";
-import { definitionRefs, definitionToAI } from "./operations/style/translator.js";
-import { elementView, pageSkeletonToAI } from "./operations/schema/translator.js";
-import { defineTool } from "./shared/tool.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/search.ts
-var searchShape = {
-	query: z.string().describe("Case-insensitive match on label, type and attribute values"),
-	filters: z.object({
-		type: z.string().optional(),
-		pageRef: z.string().optional()
-	}).optional(),
-	include: z.literal("detail").optional().describe("Set to \"detail\" to inline each hit's full props/style so an edit needs no follow-up read"),
-	limit: z.number().int().min(1).max(100).optional().describe("Max element hits to return (default 50). Response echoes total and, if more remain, nextOffset."),
-	offset: z.number().int().min(0).optional().describe("Element hits to skip (default 0). Page by re-calling with offset = nextOffset until it is absent.")
-};
-var breadcrumb = (schema, el) => {
-	const chain = [];
-	let current = el;
-	const guard = /* @__PURE__ */ new Set();
-	while (current && !guard.has(current.id)) {
-		guard.add(current.id);
-		chain.push(nameOf(current));
-		current = current.definition.parentId ? schema.flat[current.definition.parentId] : void 0;
-	}
-	return chain.reverse();
-};
-var search = (input, space, env) => {
-	const query = input.query.toLowerCase();
-	const matched = [];
-	for (const el of Object.values(space.schema.flat)) {
-		if (isPageElement(space.schema, el)) continue;
-		if (input.filters?.type && el.definition.type !== input.filters.type) continue;
-		const pageRef = pageRefOfElement(space.schema, el);
-		if (input.filters?.pageRef && pageRef !== input.filters.pageRef) continue;
-		const matches = [];
-		if (el.definition.label.toLowerCase().includes(query)) matches.push(`label: ${el.definition.label}`);
-		if (el.definition.type.toLowerCase().includes(query)) matches.push(`type: ${el.definition.type}`);
-		for (const [key, value] of Object.entries(el.attributes)) if (String(value).toLowerCase().includes(query)) matches.push(`${key}: ${String(value).slice(0, 100)}`);
-		if (matches.length === 0) continue;
-		matched.push({
-			el,
-			pageRef,
-			ref: elementRefOf(el),
-			matches
-		});
-	}
-	const offset = input.offset ?? 0;
-	const limit = input.limit ?? 50;
-	const total = matched.length;
-	const nextOffset = offset + limit < total ? offset + limit : void 0;
-	const results = matched.slice(offset, offset + limit).map((hit) => {
-		const { detail, version } = elementView(space.schema, hit.el, space.style);
-		return {
-			pageRef: hit.pageRef,
-			ref: hit.ref,
-			uri: elementUri(env, hit.ref),
-			pageUri: pageUri(env, hit.pageRef),
-			stateVersion: version,
-			parentRef: detail.parentRef,
-			path: breadcrumb(space.schema, hit.el),
-			label: hit.el.definition.label,
-			type: hit.el.definition.type,
-			matches: hit.matches,
-			detail: input.include === "detail" ? detail : void 0
-		};
-	});
-	const definitions = [];
-	for (const ref of definitionRefs(space.style)) {
-		if (ref.toLowerCase().includes(query)) {
-			const def = definitionToAI(space.style, ref);
-			if (def) definitions.push(def);
-		}
-		if (definitions.length >= 50) break;
-	}
-	const pages = [];
-	for (const page of getPageElements(space.schema)) {
-		const label = nameOf(page);
-		const slug = typeof page.attributes.slug === "string" ? page.attributes.slug : "";
-		const matches = [];
-		if (label.toLowerCase().includes(query)) matches.push(`label: ${label}`);
-		if (slug && slug.toLowerCase().includes(query)) matches.push(`slug: ${slug}`);
-		if (matches.length === 0) continue;
-		const ref = pageRefOf(page);
-		pages.push({
-			ref,
-			uri: pageUri(env, ref),
-			stateVersion: computeVersion(pageSkeletonToAI(space.schema, page, space.style)),
-			label,
-			slug,
-			matches
-		});
-	}
-	return {
-		results,
-		total,
-		offset,
-		limit,
-		nextOffset,
-		definitions: definitions.length > 0 ? definitions : void 0,
-		pages: pages.length > 0 ? pages : void 0
-	};
-};
-var searchTool = defineTool({
-	name: "plitzi_search",
-	title: "Search",
-	description: "FIND elements when you know what you want but not its ref/uri (e.g. \"the hero button\"). Matches label, type or attribute value across all pages. Each hit returns the element uri, its stateVersion (edit with optimistic concurrency, no read needed) and its tree path. Pass include: \"detail\" to inline the full props/style of each hit plus resolvedStyle (the CSS of its classes). Also returns any style definitions matching the query (with full CSS) under `definitions`, and matching pages under `pages`. Element hits are paginated: it returns at most `limit` (default 50) starting at `offset`, plus `total` and — while more remain — `nextOffset` to fetch the next page.",
-	inputShape: searchShape,
-	access: "read",
-	run: (input, ctx) => search(input, ctx.space, ctx.env)
-});
-//#endregion
-export { search, searchShape, searchTool };

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

@@ -1,44 +0,0 @@
-import { expandRepeat } from "../operations/schema/elements/repeatElement.js";
-//#region src/modules/mcp/tools/shared/expandOperations.ts
-/** Rewrites the sugar ops into the vocabulary the rest of the pipeline knows, BEFORE validation — today that is
-*  `repeatElement`, which stands for the `upsertElement` its template + rows expand to. Everything downstream
-*  (validator, dispatch, audit, versions) therefore stays unaware of it, and a row that renders a bad element is
-*  reported by the ordinary element checks.
-*
-*  One op in, one op out: the indices the agent sent are the indices every error path names, so `operations[3]`
-*  still means the fourth operation it wrote. */
-var expandOperations = (ops) => {
-	if (!ops.some((op) => op.type === "repeatElement")) return {
-		operations: ops,
-		errors: []
-	};
-	const operations = [];
-	const errors = [];
-	for (const [index, op] of ops.entries()) {
-		if (op.type !== "repeatElement") {
-			operations.push(op);
-			continue;
-		}
-		const expanded = expandRepeat(op);
-		if (!expanded.element) {
-			errors.push(...expanded.errors.map((error) => ({
-				...error,
-				path: `operations[${index}].${error.path}`
-			})));
-			continue;
-		}
-		operations.push({
-			type: "upsertElement",
-			pageRef: op.pageRef,
-			element: expanded.element,
-			...op.parentRef === void 0 ? {} : { parentRef: op.parentRef },
-			...op.position === void 0 ? {} : { position: op.position }
-		});
-	}
-	return {
-		operations,
-		errors
-	};
-};
-//#endregion
-export { expandOperations };

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

@@ -1,33 +0,0 @@
-import { z } from "zod";
-//#region src/modules/mcp/tools/shared/tool.ts
-/** Build the MCP CallToolResult for an image-returning tool: a text meta block followed by one image block per
-*  PNG, so a vision-capable agent (or MCP client) sees the render directly. */
-var imageResult = (images, meta) => ({ content: [{
-	type: "text",
-	text: JSON.stringify(meta)
-}, ...images.map((img) => ({
-	type: "image",
-	data: img.data,
-	mimeType: img.mimeType
-}))] });
-/** Author a tool: give it its metadata, its input shape and a typed `run`. The returned descriptor parses the
-*  raw args against the shape before handing them to `run`, so `run` is fully typed and no cast is needed.
-*  Adding a tool is: call defineTool in its own file and append it to the `tools` registry. */
-var defineTool = (spec) => {
-	const { runPublic } = spec;
-	const parse = (args) => z.object(spec.inputShape).parse(args);
-	return {
-		name: spec.name,
-		title: spec.title,
-		description: spec.description,
-		inputShape: spec.inputShape,
-		access: spec.access,
-		requires: spec.requires,
-		spaceless: spec.spaceless,
-		ui: spec.ui,
-		execute: (args, ctx) => spec.run(parse(args), ctx),
-		...runPublic ? { executePublic: (args, env) => runPublic(parse(args), env) } : {}
-	};
-};
-//#endregion
-export { defineTool, imageResult };

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

@@ -1,124 +0,0 @@
-import { elementRefOf, findElementByRef } from "../../../helpers/space.js";
-import { definitionToAI, globalStyleToAI, idStyleToAI } from "../../operations/style/translator.js";
-import { checkBindingSourceScope, checkBindingTarget, checkBindingTransformers } from "./bindings.js";
-import { checkSlotCss } from "./css.js";
-import { checkVariantApplication } from "./elements.js";
-import { checkInteractionNode } from "./interactions.js";
-import { buildValidationCtx } from "./index.js";
-//#region src/modules/mcp/tools/shared/validator/audit.ts
-var harvest = (ctx, into, label, run) => {
-	const sub = {
-		...ctx,
-		errors: [],
-		warnings: [],
-		warned: /* @__PURE__ */ new Set()
-	};
-	run(sub);
-	for (const e of sub.errors) into.errors.push({
-		path: e.path,
-		message: `Pre-existing malformation in ${label}: ${e.message}`,
-		hint: `${e.hint ? `${e.hint} ` : ""}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.`,
-		...e.validValues ? { validValues: e.validValues } : {}
-	});
-	for (const w of sub.warnings) {
-		const message = `Pre-existing issue in ${label} (not caused by your change, but worth fixing too): ${w}`;
-		if (!into.warnings.includes(message)) into.warnings.push(message);
-	}
-};
-var toNode = (id, node) => ({
-	id,
-	title: node.title,
-	nodeType: node.type,
-	action: node.action,
-	params: node.params,
-	enabled: node.enabled,
-	when: node.when,
-	elementId: node.elementId ?? void 0,
-	preview: node.preview
-});
-var auditElement = (space, sub, el) => {
-	const hostRef = elementRefOf(el);
-	const base = `element "${hostRef}"`;
-	for (const [category, list] of Object.entries(el.definition.bindings ?? {})) for (const binding of list) {
-		const path = `${base}.bindings.${category}[to=${binding.to}]`;
-		checkBindingTransformers(binding.transformers, `${path}.transformers`, sub);
-		checkBindingSourceScope(space, sub, hostRef, binding.source, `${path}.source`);
-		checkBindingTarget(hostRef, category, binding.to, path, sub);
-	}
-	for (const [id, node] of Object.entries(el.definition.interactions ?? {})) checkInteractionNode(toNode(id, node), `${base}.interactions.${id}`, sub, hostRef);
-	checkVariantApplication(el.definition.initialState, `${base}.initialState`, sub);
-};
-var auditDefinitionCss = (sub, label, def) => {
-	const { ref: _ref, slots, ...slot } = def;
-	checkSlotCss(slot, label, sub);
-	for (const [name, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${label}.slots.${name}`, sub);
-};
-var collectTouched = (ops) => {
-	const touched = {
-		elementRefs: /* @__PURE__ */ new Set(),
-		definitions: /* @__PURE__ */ new Set(),
-		globalStyles: /* @__PURE__ */ new Set(),
-		idStyles: /* @__PURE__ */ new Set()
-	};
-	for (const op of ops) switch (op.type) {
-		case "upsertElement":
-			touched.elementRefs.add(op.element.ref);
-			break;
-		case "patchElement":
-		case "moveElement":
-		case "upsertBinding":
-		case "patchBinding":
-		case "deleteBinding":
-		case "upsertInteractionFlow":
-		case "patchInteractionNode":
-		case "deleteInteraction":
-			touched.elementRefs.add(op.ref);
-			break;
-		case "upsertDefinition":
-		case "patchDefinition":
-			touched.definitions.add(op.ref);
-			break;
-		case "upsertDefinitions":
-			for (const ref of Object.keys(op.definitions)) touched.definitions.add(ref);
-			break;
-		case "upsertGlobalStyle":
-		case "patchGlobalStyle":
-			touched.globalStyles.add(op.componentType);
-			break;
-		case "upsertIdStyle":
-		case "patchIdStyle": touched.idStyles.add(op.targetId);
-	}
-	return touched;
-};
-var auditResources = (space, ops) => {
-	const ctx = buildValidationCtx(space, ops);
-	const result = {
-		valid: true,
-		errors: [],
-		warnings: []
-	};
-	const touched = collectTouched(ops);
-	const seenElements = /* @__PURE__ */ new Set();
-	for (const ref of touched.elementRefs) {
-		const el = findElementByRef(space.schema, ref);
-		if (!el || seenElements.has(el.id)) continue;
-		seenElements.add(el.id);
-		harvest(ctx, result, `element "${elementRefOf(el)}"`, (sub) => auditElement(space, sub, el));
-	}
-	for (const ref of touched.definitions) {
-		const def = definitionToAI(space.style, ref);
-		if (def) harvest(ctx, result, `definition "${ref}"`, (sub) => auditDefinitionCss(sub, `definition "${ref}"`, def));
-	}
-	for (const componentType of touched.globalStyles) {
-		const def = globalStyleToAI(space.style, componentType);
-		if (def) harvest(ctx, result, `global style "${componentType}"`, (sub) => auditDefinitionCss(sub, `global style "${componentType}"`, def));
-	}
-	for (const targetId of touched.idStyles) {
-		const def = idStyleToAI(space.style, targetId);
-		if (def) harvest(ctx, result, `id style "#${targetId}"`, (sub) => auditDefinitionCss(sub, `id style "#${targetId}"`, def));
-	}
-	result.valid = result.errors.length === 0;
-	return result;
-};
-//#endregion
-export { auditResources };

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

@@ -1,39 +0,0 @@
-import { slugRouteParams } from "../../../helpers/space.js";
-//#region src/modules/mcp/tools/shared/validator/batch.ts
-var batchDeclaredVars = (ops) => {
-	const names = [];
-	for (const op of ops) if (op.type === "upsertVariable") names.push(op.name);
-	else if (op.type === "upsertPage" && typeof op.slug === "string") names.push(...slugRouteParams(op.slug));
-	return names;
-};
-var batchDeclaredPages = (ops) => {
-	const refs = /* @__PURE__ */ new Set();
-	for (const op of ops) if (op.type === "upsertPage") refs.add(op.ref);
-	return refs;
-};
-var batchDeclaredFolders = (ops) => {
-	const refs = /* @__PURE__ */ new Set();
-	for (const op of ops) if (op.type === "upsertFolder") refs.add(op.ref);
-	return refs;
-};
-var variantNamesOf = (source) => {
-	const names = new Set(Object.keys(source.variants ?? {}));
-	for (const slot of Object.values(source.slots ?? {})) for (const name of Object.keys(slot.variants ?? {})) names.add(name);
-	return names;
-};
-var batchDeclaredVariants = (ops) => {
-	const map = /* @__PURE__ */ new Map();
-	const record = (ref, names) => {
-		if (names.size > 0) map.set(ref, /* @__PURE__ */ new Set([...map.get(ref) ?? [], ...names]));
-	};
-	for (const op of ops) {
-		if (op.type === "upsertDefinitions") {
-			for (const [ref, definition] of Object.entries(op.definitions)) record(ref, variantNamesOf(definition));
-			continue;
-		}
-		if (op.type === "upsertDefinition" || op.type === "patchDefinition") record(op.ref, variantNamesOf(op));
-	}
-	return map;
-};
-//#endregion
-export { batchDeclaredFolders, batchDeclaredPages, batchDeclaredVariants, batchDeclaredVars };