@plitzi/sdk-server 0.32.3 → 0.32.5

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

@@ -1,150 +1,22 @@
-import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
-import applyPreviewTool from "./space/schema/applyPreview.js";
-import getSpaceSettingsTool from "./space/schema/getSpaceSettings.js";
-import updateSpaceSettingsTool from "./space/schema/updateSpaceSettings.js";
-import cloneElementTool from "./space/schema/elements/cloneElement.js";
-import createElementTool from "./space/schema/elements/createElement.js";
-import deleteElementTool from "./space/schema/elements/deleteElement.js";
-import getElementTool from "./space/schema/elements/getElement.js";
-import getElementsTool from "./space/schema/elements/getElements.js";
-import listElementsTool from "./space/schema/elements/listElements.js";
-import moveElementTool from "./space/schema/elements/moveElement.js";
-import updateElementTool from "./space/schema/elements/updateElement.js";
-import createPageFolderTool from "./space/schema/pageFolders/createPageFolder.js";
-import deletePageFolderTool from "./space/schema/pageFolders/deletePageFolder.js";
-import getPageFolderTool from "./space/schema/pageFolders/getPageFolder.js";
-import getPageFoldersTool from "./space/schema/pageFolders/getPageFolders.js";
-import updatePageFolderTool from "./space/schema/pageFolders/updatePageFolder.js";
-import createPageTool from "./space/schema/pages/createPage.js";
-import deletePageTool from "./space/schema/pages/deletePage.js";
-import getPageTool from "./space/schema/pages/getPage.js";
-import getPageBySlugTool from "./space/schema/pages/getPageBySlug.js";
-import getPagesTool from "./space/schema/pages/getPages.js";
-import updatePageTool from "./space/schema/pages/updatePage.js";
-import createVariableTool from "./space/schema/variables/createVariable.js";
-import deleteVariableTool from "./space/schema/variables/deleteVariable.js";
-import getVariableTool from "./space/schema/variables/getVariable.js";
-import getVariablesTool from "./space/schema/variables/getVariables.js";
-import updateVariableTool from "./space/schema/variables/updateVariable.js";
-import createStyleSelectorTool from "./space/style/selectors/createStyleSelector.js";
-import deleteStyleSelectorTool from "./space/style/selectors/deleteStyleSelector.js";
-import getStyleSelectorsTool from "./space/style/selectors/getStyleSelectors.js";
-import updateStyleSelectorTool from "./space/style/selectors/updateStyleSelector.js";
-import createStyleVariableTool from "./space/style/variables/createStyleVariable.js";
-import deleteStyleVariableTool from "./space/style/variables/deleteStyleVariable.js";
-import getStyleVariableTool from "./space/style/variables/getStyleVariable.js";
-import getStyleVariablesTool from "./space/style/variables/getStyleVariables.js";
-import updateStyleVariableTool from "./space/style/variables/updateStyleVariable.js";
-import addResourceTool from "./resources/addResource.js";
-import getResourceTool from "./resources/getResource.js";
-import getResourcesTool from "./resources/getResources.js";
-import moveResourceTool from "./resources/moveResource.js";
-import removeResourceTool from "./resources/removeResource.js";
-import createSegmentTool from "./segment/createSegment.js";
-import deleteSegmentTool from "./segment/deleteSegment.js";
-import getSegmentTool from "./segment/getSegment.js";
-import getSegmentsTool from "./segment/getSegments.js";
-import updateSegmentTool from "./segment/updateSegment.js";
-import createSegmentElementTool from "./segment/schema/elements/createSegmentElement.js";
-import deleteSegmentElementTool from "./segment/schema/elements/deleteSegmentElement.js";
-import moveSegmentElementTool from "./segment/schema/elements/moveSegmentElement.js";
-import updateSegmentElementTool from "./segment/schema/elements/updateSegmentElement.js";
-import createSegmentVariableTool from "./segment/schema/variables/createSegmentVariable.js";
-import deleteSegmentVariableTool from "./segment/schema/variables/deleteSegmentVariable.js";
-import updateSegmentVariableTool from "./segment/schema/variables/updateSegmentVariable.js";
-import createSegmentStyleVariableTool from "./segment/style/variables/createSegmentStyleVariable.js";
-import deleteSegmentStyleVariableTool from "./segment/style/variables/deleteSegmentStyleVariable.js";
-import updateSegmentStyleVariableTool from "./segment/style/variables/updateSegmentStyleVariable.js";
-import addPluginTool from "./plugins/addPlugin.js";
-import listPluginsTool from "./plugins/listPlugins.js";
-import removePluginTool from "./plugins/removePlugin.js";
-import updatePluginTool from "./plugins/updatePlugin.js";
-import getCollectionsTool from "./collections/getCollections.js";
-import getCollectionTool from "./collections/getCollection.js";
-import createCollectionTool from "./collections/createCollection.js";
-import updateCollectionTool from "./collections/updateCollection.js";
-import deleteCollectionTool from "./collections/deleteCollection.js";
-import getCollectionRecordsTool from "./collections/getCollectionRecords.js";
-import getCollectionRecordTool from "./collections/getCollectionRecord.js";
-import createCollectionRecordTool from "./collections/createCollectionRecord.js";
-import updateCollectionRecordTool from "./collections/updateCollectionRecord.js";
-import deleteCollectionRecordTool from "./collections/deleteCollectionRecord.js";
-import listResourcesTool from "./docs/listResources.js";
-import readResourceTool from "./docs/readResource.js";
+import { operation } from "./operations/index.js";
+import { applyOperations } from "./apply/dispatch.js";
+import { validateOperations } from "./shared/validator.js";
+import { apply, applyShape, applyTool } from "./apply/index.js";
+import { previewTool } from "./preview.js";
+import { read, readShape, readTool } from "./read.js";
+import { screenshotTool } from "./screenshot.js";
+import { search, searchShape, searchTool } from "./search.js";
+import { validate, validateShape, validateTool } from "./validate.js";
 //#region src/modules/mcp/tools/index.ts
-var tools_exports = /* @__PURE__ */ __exportAll({
-	addPluginTool: () => addPluginTool,
-	addResourceTool: () => addResourceTool,
-	applyPreviewTool: () => applyPreviewTool,
-	cloneElementTool: () => cloneElementTool,
-	createCollectionRecordTool: () => createCollectionRecordTool,
-	createCollectionTool: () => createCollectionTool,
-	createElementTool: () => createElementTool,
-	createPageFolderTool: () => createPageFolderTool,
-	createPageTool: () => createPageTool,
-	createSegmentElementTool: () => createSegmentElementTool,
-	createSegmentStyleVariableTool: () => createSegmentStyleVariableTool,
-	createSegmentTool: () => createSegmentTool,
-	createSegmentVariableTool: () => createSegmentVariableTool,
-	createStyleSelectorTool: () => createStyleSelectorTool,
-	createStyleVariableTool: () => createStyleVariableTool,
-	createVariableTool: () => createVariableTool,
-	deleteCollectionRecordTool: () => deleteCollectionRecordTool,
-	deleteCollectionTool: () => deleteCollectionTool,
-	deleteElementTool: () => deleteElementTool,
-	deletePageFolderTool: () => deletePageFolderTool,
-	deletePageTool: () => deletePageTool,
-	deleteSegmentElementTool: () => deleteSegmentElementTool,
-	deleteSegmentStyleVariableTool: () => deleteSegmentStyleVariableTool,
-	deleteSegmentTool: () => deleteSegmentTool,
-	deleteSegmentVariableTool: () => deleteSegmentVariableTool,
-	deleteStyleSelectorTool: () => deleteStyleSelectorTool,
-	deleteStyleVariableTool: () => deleteStyleVariableTool,
-	deleteVariableTool: () => deleteVariableTool,
-	getCollectionRecordTool: () => getCollectionRecordTool,
-	getCollectionRecordsTool: () => getCollectionRecordsTool,
-	getCollectionTool: () => getCollectionTool,
-	getCollectionsTool: () => getCollectionsTool,
-	getElementTool: () => getElementTool,
-	getElementsTool: () => getElementsTool,
-	getPageBySlugTool: () => getPageBySlugTool,
-	getPageFolderTool: () => getPageFolderTool,
-	getPageFoldersTool: () => getPageFoldersTool,
-	getPageTool: () => getPageTool,
-	getPagesTool: () => getPagesTool,
-	getResourceTool: () => getResourceTool,
-	getResourcesTool: () => getResourcesTool,
-	getSegmentTool: () => getSegmentTool,
-	getSegmentsTool: () => getSegmentsTool,
-	getSpaceSettingsTool: () => getSpaceSettingsTool,
-	getStyleSelectorsTool: () => getStyleSelectorsTool,
-	getStyleVariableTool: () => getStyleVariableTool,
-	getStyleVariablesTool: () => getStyleVariablesTool,
-	getVariableTool: () => getVariableTool,
-	getVariablesTool: () => getVariablesTool,
-	listElementsTool: () => listElementsTool,
-	listPluginsTool: () => listPluginsTool,
-	listResourcesTool: () => listResourcesTool,
-	moveElementTool: () => moveElementTool,
-	moveResourceTool: () => moveResourceTool,
-	moveSegmentElementTool: () => moveSegmentElementTool,
-	readResourceTool: () => readResourceTool,
-	removePluginTool: () => removePluginTool,
-	removeResourceTool: () => removeResourceTool,
-	updateCollectionRecordTool: () => updateCollectionRecordTool,
-	updateCollectionTool: () => updateCollectionTool,
-	updateElementTool: () => updateElementTool,
-	updatePageFolderTool: () => updatePageFolderTool,
-	updatePageTool: () => updatePageTool,
-	updatePluginTool: () => updatePluginTool,
-	updateSegmentElementTool: () => updateSegmentElementTool,
-	updateSegmentStyleVariableTool: () => updateSegmentStyleVariableTool,
-	updateSegmentTool: () => updateSegmentTool,
-	updateSegmentVariableTool: () => updateSegmentVariableTool,
-	updateSpaceSettingsTool: () => updateSpaceSettingsTool,
-	updateStyleSelectorTool: () => updateStyleSelectorTool,
-	updateStyleVariableTool: () => updateStyleVariableTool,
-	updateVariableTool: () => updateVariableTool
-});
+/** The MCP tool registry — the single source both hosts (the standalone server and the in-process AI bridge)
+*  register from. Adding a tool is: create its file with a ToolDef descriptor and append it here. */
+var tools = [
+	applyTool,
+	validateTool,
+	searchTool,
+	readTool,
+	previewTool,
+	screenshotTool
+];
 //#endregion
-export { addPluginTool, addResourceTool, applyPreviewTool, cloneElementTool, createCollectionRecordTool, createCollectionTool, createElementTool, createPageFolderTool, createPageTool, createSegmentElementTool, createSegmentStyleVariableTool, createSegmentTool, createSegmentVariableTool, createStyleSelectorTool, createStyleVariableTool, createVariableTool, deleteCollectionRecordTool, deleteCollectionTool, deleteElementTool, deletePageFolderTool, deletePageTool, deleteSegmentElementTool, deleteSegmentStyleVariableTool, deleteSegmentTool, deleteSegmentVariableTool, deleteStyleSelectorTool, deleteStyleVariableTool, deleteVariableTool, getCollectionRecordTool, getCollectionRecordsTool, getCollectionTool, getCollectionsTool, getElementTool, getElementsTool, getPageBySlugTool, getPageFolderTool, getPageFoldersTool, getPageTool, getPagesTool, getResourceTool, getResourcesTool, getSegmentTool, getSegmentsTool, getSpaceSettingsTool, getStyleSelectorsTool, getStyleVariableTool, getStyleVariablesTool, getVariableTool, getVariablesTool, listElementsTool, listPluginsTool, listResourcesTool, moveElementTool, moveResourceTool, moveSegmentElementTool, readResourceTool, removePluginTool, removeResourceTool, tools_exports, updateCollectionRecordTool, updateCollectionTool, updateElementTool, updatePageFolderTool, updatePageTool, updatePluginTool, updateSegmentElementTool, updateSegmentStyleVariableTool, updateSegmentTool, updateSegmentVariableTool, updateSpaceSettingsTool, updateStyleSelectorTool, updateStyleVariableTool, updateVariableTool };
+export { apply, applyOperations, applyShape, operation, read, readShape, search, searchShape, tools, validate, validateOperations, validateShape };

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

@@ -0,0 +1,30 @@
+import { elementOps } from "./schema/operations.js";
+import { styleOps } from "./style/operations.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/index.ts
+var operation = z.discriminatedUnion("type", [
+	elementOps.upsertElement,
+	elementOps.patchElement,
+	elementOps.deleteElement,
+	elementOps.moveElement,
+	elementOps.upsertPage,
+	elementOps.deletePage,
+	elementOps.upsertFolder,
+	elementOps.deleteFolder,
+	elementOps.upsertVariable,
+	elementOps.deleteVariable,
+	styleOps.upsertDefinition,
+	styleOps.patchDefinition,
+	styleOps.deleteDefinition,
+	styleOps.upsertGlobalStyle,
+	styleOps.patchGlobalStyle,
+	styleOps.deleteGlobalStyle,
+	styleOps.upsertStyleVariable,
+	styleOps.deleteStyleVariable
+]);
+var STYLE_OP_TYPES = new Set(Object.keys(styleOps));
+var isStyleOp = (type) => STYLE_OP_TYPES.has(type);
+var environment = z.string().optional().describe("Environment; default main");
+var operations = z.array(operation).max(100).describe("Operations applied atomically, in order (max 100)");
+//#endregion
+export { environment, isStyleOp, operation, operations };

package/dist/modules/mcp/tools/operations/schema/deleteElement.js

@@ -0,0 +1,25 @@
+import { descendantIds, findPageByRef, resolveRef } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { pageUri, removeFromParent } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/deleteElement.ts
+var deleteElementOp = z.object({
+	type: z.literal("deleteElement"),
+	pageRef: z.string().describe("Page ref or id"),
+	ref: z.string().describe("Ref or id of the element to delete")
+}).describe("Delete an element and all of its descendants from a page.");
+var deleteElement = (space, env, op) => {
+	const page = findPageByRef(space.schema, op.pageRef);
+	if (!page) return fail("pageRef", `Page "${op.pageRef}" not found`, "Read the pages resource for valid refs");
+	const el = resolveRef(space.schema, page, op.ref);
+	if (!el || el.id === page.id) return fail("ref", `Element "${op.ref}" not found in page "${op.pageRef}"`, "Read the page resource for valid refs");
+	for (const id of [...descendantIds(space.schema, el.id), el.id]) Reflect.deleteProperty(space.schema.flat, id);
+	removeFromParent(space, el.id);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [pageUri(env, op.pageRef)]
+	};
+};
+//#endregion
+export { deleteElement, deleteElementOp };

package/dist/modules/mcp/tools/operations/schema/deleteFolder.js

@@ -0,0 +1,30 @@
+import { findFolderByRef, isPageElement, pageFoldersOf, sortFolders } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { folderUri, foldersUri, pagesUri } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/deleteFolder.ts
+var deleteFolderOp = z.object({
+	type: z.literal("deleteFolder"),
+	ref: z.string()
+}).describe("Delete a folder; its child folders and pages move up to its parent (or the root)");
+var deleteFolder = (space, env, op) => {
+	const folders = pageFoldersOf(space.schema);
+	const folder = findFolderByRef(space.schema, op.ref);
+	if (!folder) return fail("ref", `Folder "${op.ref}" not found`, "Read plitzi://folders for valid refs");
+	const newParent = folder.parentId;
+	for (const child of folders) if (child.parentId === folder.id) if (newParent === void 0) Reflect.deleteProperty(child, "parentId");
+	else child.parentId = newParent;
+	for (const el of Object.values(space.schema.flat)) if (isPageElement(space.schema, el) && el.attributes.folder === folder.id) el.attributes.folder = newParent ?? "";
+	space.schema.pageFolders = sortFolders(folders.filter((f) => f.id !== folder.id));
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [
+			folderUri(env, folder.id),
+			foldersUri(env),
+			pagesUri(env)
+		]
+	};
+};
+//#endregion
+export { deleteFolder, deleteFolderOp };

package/dist/modules/mcp/tools/operations/schema/deletePage.js

@@ -0,0 +1,22 @@
+import { descendantIds, findPageByRef } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { pageUri, pagesUri } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/deletePage.ts
+var deletePageOp = z.object({
+	type: z.literal("deletePage"),
+	ref: z.string().describe("Page ref or id")
+}).describe("Delete a page and every element on it.");
+var deletePage = (space, env, op) => {
+	const page = findPageByRef(space.schema, op.ref);
+	if (!page) return fail("ref", `Page "${op.ref}" not found`, "Read the pages resource for valid refs");
+	for (const id of [...descendantIds(space.schema, page.id), page.id]) Reflect.deleteProperty(space.schema.flat, id);
+	space.schema.pages = space.schema.pages.filter((id) => id !== page.id);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [pageUri(env, op.ref), pagesUri(env)]
+	};
+};
+//#endregion
+export { deletePage, deletePageOp };

package/dist/modules/mcp/tools/operations/schema/deleteVariable.js

@@ -0,0 +1,18 @@
+import { empty } from "../../../helpers/opResult.js";
+import { schemaVarsUri } from "./write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/deleteVariable.ts
+var deleteVariableOp = z.object({
+	type: z.literal("deleteVariable"),
+	name: z.string().describe("Name of the schema variable to delete")
+}).describe("Delete a space-level schema variable by name.");
+var deleteVariable = (space, env, op) => {
+	space.schema.variables = space.schema.variables.filter((v) => v.name !== op.name);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [schemaVarsUri(env)]
+	};
+};
+//#endregion
+export { deleteVariable, deleteVariableOp };

package/dist/modules/mcp/tools/operations/schema/moveElement.js

@@ -0,0 +1,39 @@
+import { findPageByRef, resolveRef } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { pageUri, placeChild, removeFromParent } from "./write.js";
+import { position } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/moveElement.ts
+var moveElementOp = z.object({
+	type: z.literal("moveElement"),
+	pageRef: z.string().describe("Page ref or id"),
+	ref: z.string().describe("Ref or id of the element to move"),
+	toParentRef: z.string().describe("Ref or id of the anchor the element moves relative to (see position)"),
+	position
+}).describe("Move an existing element to a new parent, or reorder it — its placement is set by position.");
+var moveElement = (space, env, op) => {
+	const page = findPageByRef(space.schema, op.pageRef);
+	if (!page) return fail("pageRef", `Page "${op.pageRef}" not found`, "Read the pages resource for valid refs");
+	const el = resolveRef(space.schema, page, op.ref);
+	const anchor = resolveRef(space.schema, page, op.toParentRef);
+	if (!el || el.id === page.id) return fail("ref", `Element "${op.ref}" not found`, "Read the page resource for valid refs");
+	if (!anchor) return fail("toParentRef", `Target "${op.toParentRef}" not found`, "Read the page resource for valid refs");
+	removeFromParent(space, el.id);
+	let parent = anchor;
+	let index;
+	if (op.position === "before" || op.position === "after") {
+		parent = anchor.definition.parentId ? space.schema.flat[anchor.definition.parentId] ?? page : page;
+		const at = (parent.definition.items ?? []).indexOf(anchor.id);
+		index = at < 0 ? void 0 : op.position === "after" ? at + 1 : at;
+	}
+	el.definition.parentId = parent.id;
+	placeChild(parent, el.id, index);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [pageUri(env, op.pageRef)],
+		elementRefs: [op.ref]
+	};
+};
+//#endregion
+export { moveElement, moveElementOp };

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

@@ -0,0 +1,25 @@
+import { deleteElementOp } from "./deleteElement.js";
+import { deleteFolderOp } from "./deleteFolder.js";
+import { deletePageOp } from "./deletePage.js";
+import { deleteVariableOp } from "./deleteVariable.js";
+import { moveElementOp } from "./moveElement.js";
+import { patchElementOp } from "./patchElement.js";
+import { upsertElementOp } from "./upsertElement.js";
+import { upsertFolderOp } from "./upsertFolder.js";
+import { upsertPageOp } from "./upsertPage.js";
+import { upsertVariableOp } from "./upsertVariable.js";
+//#region src/modules/mcp/tools/operations/schema/operations.ts
+var elementOps = {
+	upsertElement: upsertElementOp,
+	patchElement: patchElementOp,
+	deleteElement: deleteElementOp,
+	moveElement: moveElementOp,
+	upsertPage: upsertPageOp,
+	deletePage: deletePageOp,
+	upsertFolder: upsertFolderOp,
+	deleteFolder: deleteFolderOp,
+	upsertVariable: upsertVariableOp,
+	deleteVariable: deleteVariableOp
+};
+//#endregion
+export { elementOps };

package/dist/modules/mcp/tools/operations/schema/patchElement.js

@@ -0,0 +1,46 @@
+import { findPageByRef, resolveRef } from "../../../helpers/space.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { pageUri } from "./write.js";
+import { styleRefs } from "./shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/patchElement.ts
+var patchElementOp = z.object({
+	type: z.literal("patchElement"),
+	pageRef: z.string().describe("Page ref or id"),
+	ref: z.string().describe("Existing element ref or id"),
+	label: z.string().optional(),
+	subType: z.string().optional(),
+	props: z.record(z.string(), z.unknown()).optional().describe("Merged onto existing props: listed keys change, null unsets a key, others are preserved"),
+	style: styleRefs.optional().describe("Merged onto existing style: base replaces base, listed slots replace slots")
+}).describe("Partially update an EXISTING element: only the fields you pass change (props/style are merged, not replaced). Never creates — fails if ref does not resolve. Use upsertElement to create or fully replace.");
+var patchElement = (space, env, op) => {
+	const page = findPageByRef(space.schema, op.pageRef);
+	if (!page) return fail("pageRef", `Page "${op.pageRef}" not found`, "Read plitzi://schema/" + env + "/pages for valid refs");
+	const el = resolveRef(space.schema, page, op.ref);
+	if (!el || el.id === page.id) return fail("ref", `Element "${op.ref}" not found in page "${op.pageRef}"`, "patchElement only updates an existing element; use upsertElement to create one");
+	if (op.label !== void 0) el.definition.label = op.label;
+	if (op.subType !== void 0) el.attributes = {
+		...el.attributes,
+		subType: op.subType
+	};
+	if (op.props !== void 0) {
+		const merged = { ...el.attributes };
+		for (const [key, value] of Object.entries(op.props)) if (value === null) Reflect.deleteProperty(merged, key);
+		else merged[key] = value;
+		el.attributes = merged;
+	}
+	if (op.style !== void 0) {
+		const selectors = { ...el.definition.styleSelectors };
+		if (op.style.base !== void 0) selectors.base = op.style.base.join(" ");
+		for (const [slot, classes] of Object.entries(op.style.slots ?? {})) selectors[slot] = classes.join(" ");
+		el.definition.styleSelectors = selectors;
+	}
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [pageUri(env, op.pageRef)],
+		elementRefs: [op.ref]
+	};
+};
+//#endregion
+export { patchElement, patchElementOp };

package/dist/modules/mcp/tools/operations/schema/registry.js

@@ -0,0 +1,55 @@
+import { cssProperties } from "../style/cssCatalog.js";
+//#region src/modules/mcp/tools/operations/schema/registry.ts
+var EXAMPLE_MAX_LENGTH = 80;
+var isCompactExample = (value) => {
+	if (typeof value === "string") return value.length <= EXAMPLE_MAX_LENGTH;
+	return typeof value === "number" || typeof value === "boolean";
+};
+var NOTE = "Element types and their props/slots are observed from the elements that already exist in this space — they are ground truth, never inferred. Props list the attribute keys seen on each type with example values. Slots are the styleSelectors keys seen on each type (target them via element.style.slots). CSS in definitions must use the kebab-case keys in cssProperties. Reference schema variables in props via {{name}} and style variables in CSS via var(--name).";
+var buildTypeRegistry = (schema) => {
+	const types = {};
+	for (const el of Object.values(schema.flat)) {
+		const typeName = el.definition.type;
+		const info = types[typeName] ??= {
+			count: 0,
+			subTypes: [],
+			slots: [],
+			props: {}
+		};
+		info.count += 1;
+		const subType = el.attributes.subType;
+		if (typeof subType === "string" && !info.subTypes.includes(subType)) info.subTypes.push(subType);
+		for (const slot of Object.keys(el.definition.styleSelectors)) if (!info.slots.includes(slot)) info.slots.push(slot);
+		for (const [key, value] of Object.entries(el.attributes)) {
+			if (key === "subType") continue;
+			const prop = info.props[key] ??= {
+				valueTypes: [],
+				examples: []
+			};
+			const valueType = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+			if (!prop.valueTypes.includes(valueType)) prop.valueTypes.push(valueType);
+			if (prop.examples.length < 3 && isCompactExample(value) && value !== "" && !prop.examples.includes(value)) prop.examples.push(value);
+		}
+	}
+	for (const info of Object.values(types)) {
+		info.subTypes.sort();
+		info.slots.sort();
+	}
+	return {
+		note: NOTE,
+		cssProperties,
+		styleVariableCategories: [
+			"color",
+			"spacing",
+			"shadow",
+			"custom"
+		],
+		templateSyntax: {
+			schemaVariable: "{{name}}",
+			styleVariable: "var(--name)"
+		},
+		types
+	};
+};
+//#endregion
+export { buildTypeRegistry };

package/dist/modules/mcp/tools/operations/schema/shared.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/shared.ts
+var styleRefs = z.object({
+	base: z.array(z.string()).optional(),
+	slots: z.record(z.string(), z.array(z.string())).optional()
+});
+var elementInput = z.lazy(() => z.object({
+	ref: z.string().describe("Semantic id you choose, or an existing element ref/id"),
+	type: z.string().describe("Type from plitzi://types"),
+	label: z.string().optional(),
+	subType: z.string().optional(),
+	props: z.record(z.string(), z.unknown()).optional().describe("Full replacement on update"),
+	style: styleRefs.optional().describe("Definition refs per slot; style the element by attaching a definition"),
+	children: z.array(elementInput).optional()
+}));
+var position = z.enum([
+	"inside",
+	"before",
+	"after"
+]).describe("Placement relative to the anchor: \"inside\" nests it as a child (default), \"before\"/\"after\" as a sibling");
+var scalar = z.union([
+	z.string(),
+	z.number(),
+	z.boolean()
+]);
+//#endregion
+export { elementInput, position, scalar, styleRefs };

package/dist/modules/mcp/tools/operations/schema/translator.js

@@ -0,0 +1,148 @@
+import { descendantCount, descendantIds, elementById, elementRefOf, getPageElements, isPageElement, orderedChildren, pageFoldersOf, pageRefOf, pageRefOfElement, slugRouteParams } from "../../../helpers/space.js";
+import { definitionToAI, globalStylesForType } from "../style/translator.js";
+//#region src/modules/mcp/tools/operations/schema/translator.ts
+var splitClasses = (value) => value ? value.split(/\s+/).filter(Boolean) : [];
+var strOr = (value) => typeof value === "string" ? value : void 0;
+var nameOf = (page) => strOr(page.attributes.name) ?? page.definition.label;
+var propsOf = (el) => {
+	const { subType, ...rest } = el.attributes;
+	return Object.keys(rest).length > 0 ? rest : void 0;
+};
+var slotClasses = (selectors) => {
+	const slots = {};
+	for (const [slot, classes] of Object.entries(selectors)) if (slot !== "base") slots[slot] = splitClasses(classes);
+	return slots;
+};
+var pageSummariesToAI = (schema) => getPageElements(schema).map((page) => ({
+	ref: pageRefOf(page),
+	label: nameOf(page),
+	slug: strOr(page.attributes.slug) ?? "",
+	default: page.attributes.default === true,
+	folder: strOr(page.attributes.folder) || void 0,
+	elementCount: descendantCount(schema, page.id)
+}));
+var folderToAI = (folder) => ({
+	ref: folder.id,
+	name: folder.name,
+	slug: folder.slug,
+	parentId: folder.parentId
+});
+var foldersToAI = (schema) => pageFoldersOf(schema).map(folderToAI);
+var folderRefToAI = (schema, ref) => {
+	const folder = pageFoldersOf(schema).find((f) => f.id === ref);
+	return folder ? folderToAI(folder) : void 0;
+};
+var skeletonNode = (schema, el) => {
+	const children = orderedChildren(schema, el);
+	const base = splitClasses(el.definition.styleSelectors.base);
+	const slots = slotClasses(el.definition.styleSelectors);
+	return {
+		ref: elementRefOf(el),
+		type: el.definition.type,
+		label: el.definition.label,
+		subType: strOr(el.attributes.subType),
+		base: base.length > 0 ? base : void 0,
+		slots: Object.keys(slots).length > 0 ? slots : void 0,
+		childCount: children.length,
+		children: children.length > 0 ? children.map((child) => skeletonNode(schema, child)) : void 0
+	};
+};
+var pageSkeletonToAI = (schema, pageEl) => {
+	const slug = strOr(pageEl.attributes.slug) ?? "";
+	return {
+		ref: pageRefOf(pageEl),
+		label: nameOf(pageEl),
+		slug,
+		default: pageEl.attributes.default === true,
+		routeParams: slugRouteParams(slug),
+		tree: orderedChildren(schema, pageEl).map((child) => skeletonNode(schema, child))
+	};
+};
+var elementClassRefs = (el) => {
+	const refs = splitClasses(el.definition.styleSelectors.base);
+	for (const classes of Object.values(slotClasses(el.definition.styleSelectors))) refs.push(...classes);
+	return refs;
+};
+var pageStylesToAI = (schema, style, pageEl) => {
+	const classRefs = /* @__PURE__ */ new Set();
+	const types = /* @__PURE__ */ new Set();
+	const collect = (el) => {
+		for (const ref of elementClassRefs(el)) classRefs.add(ref);
+		types.add(el.definition.type);
+	};
+	collect(pageEl);
+	for (const id of descendantIds(schema, pageEl.id)) {
+		const el = elementById(schema, id);
+		if (el) collect(el);
+	}
+	const definitions = [];
+	for (const ref of Array.from(classRefs).sort()) {
+		const def = definitionToAI(style, ref);
+		if (def) definitions.push(def);
+	}
+	const globalStyles = [];
+	const seenGlobals = /* @__PURE__ */ new Set();
+	for (const type of Array.from(types).sort()) for (const global of globalStylesForType(style, type)) if (!seenGlobals.has(global.ref)) {
+		seenGlobals.add(global.ref);
+		globalStyles.push(global);
+	}
+	return {
+		ref: pageRefOf(pageEl),
+		definitions,
+		globalStyles
+	};
+};
+var resolveDefinitions = (style, base, slots) => {
+	const refs = new Set(base);
+	for (const classes of Object.values(slots)) for (const cls of classes) refs.add(cls);
+	const resolved = {};
+	for (const ref of refs) {
+		const def = definitionToAI(style, ref);
+		if (def) resolved[ref] = def;
+	}
+	return Object.keys(resolved).length > 0 ? resolved : void 0;
+};
+var elementDetailToAI = (schema, el, style) => {
+	const children = orderedChildren(schema, el);
+	const parent = el.definition.parentId ? schema.flat[el.definition.parentId] : void 0;
+	const base = splitClasses(el.definition.styleSelectors.base);
+	const slots = slotClasses(el.definition.styleSelectors);
+	const detail = {
+		ref: elementRefOf(el),
+		type: el.definition.type,
+		subType: strOr(el.attributes.subType),
+		label: el.definition.label,
+		pageRef: pageRefOfElement(schema, el),
+		parentRef: parent ? isPageElement(schema, parent) ? pageRefOf(parent) : elementRefOf(parent) : void 0,
+		props: propsOf(el),
+		style: {
+			base,
+			slots
+		},
+		childRefs: children.length > 0 ? children.map(elementRefOf) : void 0
+	};
+	if (style) {
+		const resolvedStyle = resolveDefinitions(style, base, slots);
+		if (resolvedStyle) detail.resolvedStyle = resolvedStyle;
+		const globalStyles = globalStylesForType(style, el.definition.type);
+		if (globalStyles.length > 0) detail.globalStyles = globalStyles;
+	}
+	return detail;
+};
+var schemaVariablesToAI = (schema, includeSubValues = true) => {
+	const data = {};
+	for (const variable of schema.variables) data[variable.name] = {
+		name: variable.name,
+		reference: `{{${variable.name}}}`,
+		category: variable.category,
+		type: variable.type,
+		value: variable.value,
+		subValues: includeSubValues ? variable.subValues.map((sv) => ({
+			when: sv.when,
+			value: sv.value
+		})) : void 0
+	};
+	return data;
+};
+//#endregion
+export { elementDetailToAI, folderRefToAI, foldersToAI, pageSkeletonToAI, pageStylesToAI, pageSummariesToAI, schemaVariablesToAI };