@plitzi/sdk-server 0.32.5 → 0.32.6

package/dist/src/modules/mcp/types/aiSchema.d.ts

@@ -20,11 +20,14 @@ export interface AIPageSummary {
     label: string;
     slug: string;
     default: boolean;
+    /** Whether the page is served by the published SDK runtime. A disabled page (`false`) is not routable/accessible
+     *  to end users, but stays fully editable here. Defaults to true. */
+    enabled: boolean;
     /** The ref of the folder this page lives in (a PageFolder id), or undefined for a root-level page. */
     folder?: string;
     elementCount: number;
 }
-/** A page folder in the sidebar tree. `ref` is the folder's id (there is no separate aiRef); pages reference it
+/** A page folder in the sidebar tree. `ref` is the folder's id (there is no separate idRef); pages reference it
  *  by that id via their `folder`, and nested folders via `parentId`. */
 export interface AIFolder {
     ref: string;
@@ -37,6 +40,9 @@ export interface AISkeletonNode {
     type: string;
     label: string;
     subType?: string;
+    /** This element's version — identical to the stateVersion a direct element read or search hit returns for it. Diff
+     *  it against a version you already hold to re-read (plitzi_read) only the nodes that actually changed. */
+    stateVersion?: string;
     /** The class refs this node attaches on its base selector — names only, no CSS. Lets an agent map element →
      *  class straight from the page skeleton, without a per-element read just to learn which class it uses. */
     base?: string[];
@@ -50,6 +56,9 @@ export interface AIPageSkeleton {
     label: string;
     slug: string;
     default: boolean;
+    /** Whether the page is served by the published SDK runtime. A disabled page (`false`) is not routable/accessible
+     *  to end users, but stays fully editable here. Defaults to true. */
+    enabled: boolean;
     /** Route params bound by the slug (e.g. ":spaceId" → ["spaceId"]). Valid as {{name}} references on this page,
      *  alongside the space-level plitzi://schema-variables. */
     routeParams: string[];
@@ -63,6 +72,53 @@ export interface AIPageStyles {
     definitions: AIDefinition[];
     globalStyles: AIGlobalStyle[];
 }
+/** Which variant each attached class/selector currently uses on this element (element.definition.initialState
+ *  .styleVariant). Outer key = class ref, inner key = selector (`base` or a slot), value = variant name(s). */
+export type AIStyleVariantSelection = Record<string, Record<string, string | string[]>>;
+/** The element's initial (default) state overrides. `styleVariant` picks which variant of its classes is active;
+ *  `visibility` hides/shows it initially. Kept minimal — the two fields agents actually set. */
+export interface AIInitialState {
+    styleVariant?: AIStyleVariantSelection;
+    visibility?: boolean;
+}
+/** One data binding: connect a data `source` to the element field named by `to` (a prop, a style value, or an
+ *  initial-state key, per its category). `transformers` reshape the value; `when` gates the binding. */
+export interface AIBinding {
+    id: string;
+    to: string;
+    source: string;
+    transformers?: Array<{
+        action: string;
+        params: Record<string, string>;
+        enabled?: boolean;
+    }>;
+    when?: unknown;
+    enabled?: boolean;
+}
+/** Data bindings on an element, grouped by what they feed: element props (`attributes`), style values (`style`),
+ *  or initial-state keys (`initialState`). */
+export type AIBindings = Partial<Record<'attributes' | 'style' | 'initialState', AIBinding[]>>;
+export type AIInteractionNodeType = 'trigger' | 'globalCallback' | 'callback' | 'utility';
+/** One step of an interaction flow, projected from the stored doubly-linked node. Order is conveyed by the
+ *  position in `AIInteractionFlow.nodes`; the stored beforeNode/afterNode/flowId links are computed on write. */
+export interface AIInteractionNode {
+    id: string;
+    title: string;
+    nodeType: AIInteractionNodeType;
+    action: string;
+    params?: Record<string, unknown>;
+    enabled?: boolean;
+    when?: unknown;
+    /** Source element the callback targets (globalCallback/utility). Defaults to this element on write. */
+    elementId?: string;
+    preview?: Record<string, unknown>;
+}
+/** One interaction flow on an element: a trigger (first node) followed by the callbacks/utilities it runs, in
+ *  order. `flowId` equals the trigger node id. */
+export interface AIInteractionFlow {
+    flowId: string;
+    nodes: AIInteractionNode[];
+}
 export interface AIElementDetail {
     ref: string;
     type: string;
@@ -81,6 +137,18 @@ export interface AIElementDetail {
     /** Global (type 'element') styles that also affect this element because they target its type — every element of
      *  the type inherits them. Read-only here (not editable as definitions); shown so the effective CSS is complete. */
     globalStyles?: AIGlobalStyle[];
+    /** Id rule (type 'id') targeting this element by its DOM `id` attribute (`#id`). Present only when the element
+     *  carries an `id` that a rule matches. Edit it with the id-style tools (never as a definition). */
+    idStyle?: AIIdStyle;
+    /** Variant names each attached class exposes (deduped across its selectors), so the agent knows a class HAS a
+     *  variant (e.g. a button class with "primary") before applying it via `initialState.styleVariant`. */
+    availableVariants?: Record<string, string[]>;
+    /** Which variant/visibility this element applies today (element.definition.initialState). */
+    initialState?: AIInitialState;
+    /** Data bindings on this element, grouped by category. */
+    bindings?: AIBindings;
+    /** Interaction flows on this element (event → ordered callbacks). */
+    interactions?: AIInteractionFlow[];
     childRefs?: string[];
 }
 /** A global element style (a type 'element' StyleItem): its CSS applies to every element whose type equals
@@ -88,6 +156,12 @@ export interface AIElementDetail {
 export interface AIGlobalStyle extends AIDefinition {
     appliesToType: string;
 }
+/** An id rule (a type 'id' StyleItem): its CSS targets the single element whose DOM `id` equals `targetId`
+ *  (the CSS equivalent of `#id { … }`). Style one element by giving it an `id` attribute and writing this rule;
+ *  prefer a class definition when the styling could be reused. */
+export interface AIIdStyle extends AIDefinition {
+    targetId: string;
+}
 export interface AIDefinitionSlot extends DisplayModeCss {
     states?: Record<string, DisplayModeCss>;
     variants?: Record<string, DisplayModeCss>;
@@ -118,6 +192,24 @@ export interface AISchemaVariable {
         value: string | number | boolean;
     }>;
 }
+/** Space-level settings: the arbitrary global CSS (`customCss`), state persistence, and the user/auth provider
+ *  configuration. Every field is optional — a patch changes only the keys it sends. */
+export interface AISettings {
+    customCss?: string;
+    keepState?: boolean;
+    stateStorage?: 'localStorage' | 'sessionStorage';
+    userProvider?: 'auth0' | 'basic' | 'custom' | '';
+    auth0Domain?: string;
+    auth0ClientId?: string;
+    tokenStorage?: 'localStorage' | 'sessionStorage' | '';
+    loginUrl?: string;
+    userUrl?: string;
+    refreshUrl?: string;
+    logoutUrl?: string;
+    detailsPath?: string;
+    tokenPath?: string;
+    expirationTimePath?: string;
+}
 export interface ValidationError {
     path: string;
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.32.5",
+  "version": "0.32.6",
   "license": "AGPL-3.0",
   "files": [
     "dist"
@@ -23,8 +23,9 @@
   "sideEffects": false,
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@plitzi/plitzi-sdk": "0.32.5",
-    "@plitzi/sdk-shared": "0.32.5",
+    "@plitzi/plitzi-sdk": "0.32.6",
+    "@plitzi/sdk-schema": "0.32.6",
+    "@plitzi/sdk-shared": "0.32.6",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.1",
     "zod": "^4.4.3"
@@ -37,15 +38,15 @@
     "@types/ejs": "^3.1.5",
     "@types/node": "^26.1.1",
     "@types/react": "^19.2.17",
-    "@vitejs/plugin-react": "^6.0.3",
+    "@vitejs/plugin-react": "^6.0.4",
     "@vitest/coverage-v8": "^4.1.10",
-    "eslint": "^9.39.4",
+    "eslint": "^9.39.5",
     "eslint-plugin-import": "^2.32.0",
-    "react": "^19.2.7",
-    "react-dom": "^19.2.7",
-    "tsx": "^4.23.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "tsx": "^4.23.1",
     "typescript": "^6.0.3",
-    "vite": "^8.1.4",
+    "vite": "^8.1.5",
     "vite-plugin-dts": "^5.0.3",
     "vitest": "^4.1.10"
   },
@@ -59,6 +60,7 @@
     "lint": "TIMING=1 eslint ./src",
     "typecheck": "tsc -p tsconfig.app.json --noEmit",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    "bench": "vitest bench --run"
   }
 }

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

@@ -1,55 +0,0 @@
-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/upsertPage.js

@@ -1,64 +0,0 @@
-import { findFolderByRef, findPageByRef, generateObjectId } 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/upsertPage.ts
-var upsertPageOp = z.object({
-	type: z.literal("upsertPage"),
-	ref: z.string().describe("Page id/slug to update, or a new id you choose to create one"),
-	label: z.string().optional(),
-	slug: z.string().optional(),
-	folder: z.string().nullable().optional().describe("Ref of an existing folder to place this page in; \"\" or null moves it to the root. Unknown → error"),
-	default: z.boolean().optional()
-}).describe("Create a page, or update it when ref already exists (only the fields you pass change).");
-var upsertPage = (space, env, op) => {
-	let folderValue;
-	if (op.folder !== void 0) if (op.folder === null || op.folder === "") folderValue = "";
-	else {
-		const resolved = findFolderByRef(space.schema, op.folder);
-		if (!resolved) return fail("folder", `Folder "${op.folder}" not found`, "Create it with upsertFolder, or read plitzi://folders");
-		folderValue = resolved.id;
-	}
-	const existing = findPageByRef(space.schema, op.ref);
-	if (existing) {
-		existing.attributes = {
-			...existing.attributes,
-			...op.slug !== void 0 ? { slug: op.slug } : {},
-			...op.label !== void 0 ? { name: op.label } : {},
-			...op.default !== void 0 ? { default: op.default } : {},
-			...folderValue !== void 0 ? { folder: folderValue } : {}
-		};
-		return {
-			...empty(),
-			updated: 1,
-			staleResources: [pageUri(env, op.ref), pagesUri(env)]
-		};
-	}
-	const id = generateObjectId();
-	const attributes = {
-		slug: op.slug ?? "",
-		name: op.label ?? op.ref,
-		default: op.default ?? false,
-		folder: folderValue ?? ""
-	};
-	space.schema.flat[id] = {
-		id,
-		attributes,
-		definition: {
-			rootId: id,
-			label: op.label ?? op.ref,
-			type: "page",
-			items: [],
-			styleSelectors: { base: "" },
-			aiRef: op.ref
-		}
-	};
-	space.schema.pages.push(id);
-	return {
-		...empty(),
-		created: 1,
-		staleResources: [pageUri(env, op.ref), pagesUri(env)]
-	};
-};
-//#endregion
-export { upsertPage, upsertPageOp };

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

@@ -1,262 +0,0 @@
-import { findFolderByRef, findPageByRef, folderAncestorIds, getPageElements, pageFoldersOf, pageRefOf, resolveRef, routeParamNames, slugRouteParams } from "../../helpers/space.js";
-import { expandShorthand, isCssProperty, suggestCssProperty } from "../operations/style/cssCatalog.js";
-import { buildTypeRegistry } from "../operations/schema/registry.js";
-//#region src/modules/mcp/tools/shared/validator.ts
-var REF_RE = /^[a-zA-Z0-9._-]+$/;
-var MAX_OPS = 100;
-var STYLE_CATEGORIES = [
-	"color",
-	"spacing",
-	"shadow",
-	"custom"
-];
-var VAR_REF = /\{\{\s*([A-Za-z_][\w.-]*)\s*\}\}/g;
-var CSS_VAR = /var\(\s*--([A-Za-z_][\w-]*)\s*\)/g;
-var RAW_CODE_TYPES = /* @__PURE__ */ new Set([
-	"blockJsx",
-	"blockHtml",
-	"custom"
-]);
-var warnOnce = (ctx, message) => {
-	if (!ctx.warned.has(message)) {
-		ctx.warned.add(message);
-		ctx.warnings.push(message);
-	}
-};
-var checkVarRefs = (text, path, ctx) => {
-	for (const match of text.matchAll(VAR_REF)) {
-		const name = match[1];
-		if (!ctx.schemaVars.has(name)) warnOnce(ctx, `Unknown variable {{${name}}} at ${path}: not a space schema variable or a page route param. Read plitzi://schema-variables, or use a route param from the page skeleton (routeParams).`);
-	}
-};
-var checkStyleVarRefs = (text, path, ctx) => {
-	for (const match of text.matchAll(CSS_VAR)) {
-		const name = match[1];
-		if (!ctx.styleVars.has(name)) {
-			const tokens = [...ctx.styleVars];
-			warnOnce(ctx, `Unknown style variable var(--${name}) at ${path}: not a design token in this space. ${tokens.length > 0 ? `Available tokens: ${tokens.slice(0, 30).join(", ")}${tokens.length > 30 ? ", …" : ""}.` : "Read plitzi://style-variables for the valid token names."}`);
-		}
-	}
-};
-var checkTypeProps = (type, props, path, ctx) => {
-	if (!props || RAW_CODE_TYPES.has(type)) return;
-	const known = ctx.typeProps.get(type);
-	if (!known || known.size === 0) return;
-	for (const key of Object.keys(props)) {
-		if (key === "subType" || known.has(key)) continue;
-		warnOnce(ctx, `Type "${type}" has no observed prop "${key}" at ${path} (observed: ${[...known].sort().join(", ")}). It may still be valid — verify against plitzi://types.`);
-	}
-};
-var checkRef = (ref, path, ctx) => {
-	if (!ref || ref.trim().length === 0) {
-		ctx.errors.push({
-			path,
-			message: "Ref must not be empty",
-			hint: "Use a semantic name like \"hero.title\""
-		});
-		return;
-	}
-	if (!REF_RE.test(ref)) ctx.errors.push({
-		path,
-		message: `Ref "${ref}" has invalid characters`,
-		hint: "Allowed characters: letters, numbers, dot, hyphen, underscore"
-	});
-};
-var checkCss = (css, path, ctx) => {
-	if (!css) return;
-	const declared = {};
-	for (const [key, value] of Object.entries(css)) if (value !== null) declared[key] = value;
-	for (const [key, value] of Object.entries(expandShorthand(declared))) {
-		if (!isCssProperty(key)) {
-			const suggestion = suggestCssProperty(key);
-			ctx.errors.push({
-				path: `${path}.${key}`,
-				message: `Unknown CSS property "${key}"`,
-				hint: suggestion ? `Use the kebab-case key "${suggestion}"` : "Read plitzi://css-properties for the valid property keys"
-			});
-		}
-		if (typeof value === "string") {
-			checkStyleVarRefs(value, `${path}.${key}`, ctx);
-			checkVarRefs(value, `${path}.${key}`, ctx);
-		}
-	}
-};
-var checkSlotCss = (slot, path, ctx) => {
-	checkCss(slot.desktop, `${path}.desktop`, ctx);
-	checkCss(slot.tablet, `${path}.tablet`, ctx);
-	checkCss(slot.mobile, `${path}.mobile`, ctx);
-	for (const [state, dm] of Object.entries(slot.states ?? {})) {
-		checkCss(dm.desktop, `${path}.states.${state}.desktop`, ctx);
-		checkCss(dm.tablet, `${path}.states.${state}.tablet`, ctx);
-		checkCss(dm.mobile, `${path}.states.${state}.mobile`, ctx);
-	}
-	for (const [name, dm] of Object.entries(slot.variants ?? {})) {
-		checkCss(dm.desktop, `${path}.variants.${name}.desktop`, ctx);
-		checkCss(dm.tablet, `${path}.variants.${name}.tablet`, ctx);
-		checkCss(dm.mobile, `${path}.variants.${name}.mobile`, ctx);
-	}
-};
-var checkElementProps = (element, 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) => {
-	checkRef(element.ref, `${path}.ref`, ctx);
-	if (seen.has(element.ref)) ctx.errors.push({
-		path: `${path}.ref`,
-		message: `Duplicate ref "${element.ref}" in this batch`,
-		hint: "Use a unique ref"
-	});
-	seen.add(element.ref);
-	if (!element.type) ctx.errors.push({
-		path: `${path}.type`,
-		message: "Element type is required",
-		hint: "Read plitzi://types for known types"
-	});
-	else if (!ctx.knownTypes.has(element.type)) ctx.warnings.push(`Type "${element.type}" was not seen in this space; ensure a plugin provides it (${path}.type).`);
-	checkElementProps(element, path, ctx);
-	element.children?.forEach((child, i) => checkElementInput(child, `${path}.children[${i}]`, ctx, seen));
-};
-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 validateOperations = (space, ops) => {
-	const registry = buildTypeRegistry(space.schema);
-	const batchPages = batchDeclaredPages(ops);
-	const batchFolders = batchDeclaredFolders(ops);
-	const folderRefs = () => pageFoldersOf(space.schema).map((f) => f.id);
-	const ctx = {
-		errors: [],
-		warnings: [],
-		warned: /* @__PURE__ */ new Set(),
-		knownTypes: new Set(Object.keys(registry.types)),
-		typeProps: new Map(Object.entries(registry.types).map(([type, info]) => [type, new Set(Object.keys(info.props))])),
-		schemaVars: /* @__PURE__ */ new Set([
-			...space.schema.variables.map((v) => v.name),
-			...routeParamNames(space.schema),
-			...batchDeclaredVars(ops)
-		]),
-		styleVars: new Set(Object.values(space.style.variables).flatMap((group) => Object.keys(group)))
-	};
-	if (ops.length > MAX_OPS) ctx.errors.push({
-		path: "operations",
-		message: `Batch has ${ops.length} operations (max ${MAX_OPS})`,
-		hint: `Split into batches of at most ${MAX_OPS}`
-	});
-	ops.forEach((op, i) => {
-		const base = `operations[${i}]`;
-		if ((op.type === "upsertElement" || op.type === "patchElement" || op.type === "deleteElement" || op.type === "moveElement") && op.pageRef) {
-			if (!findPageByRef(space.schema, op.pageRef) && !batchPages.has(op.pageRef)) {
-				const validRefs = getPageElements(space.schema).map(pageRefOf);
-				ctx.errors.push({
-					path: `${base}.pageRef`,
-					message: `Page "${op.pageRef}" does not exist`,
-					hint: "Use an existing page ref, or create it with upsertPage earlier in the same batch",
-					validValues: validRefs
-				});
-			}
-		}
-		switch (op.type) {
-			case "upsertElement":
-				checkElementInput(op.element, `${base}.element`, ctx, /* @__PURE__ */ new Set());
-				break;
-			case "patchElement": {
-				checkRef(op.ref, `${base}.ref`, ctx);
-				const page = findPageByRef(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) checkTypeProps(target.definition.type, op.props, base, ctx);
-				}
-				break;
-			}
-			case "upsertDefinition":
-			case "patchDefinition": {
-				const { type, ref, slots, ...slot } = op;
-				checkRef(ref, `${base}.ref`, ctx);
-				checkSlotCss(slot, base, ctx);
-				for (const [slotName, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${base}.slots.${slotName}`, ctx);
-				break;
-			}
-			case "upsertGlobalStyle":
-			case "patchGlobalStyle": {
-				const { type, componentType, slots, ...slot } = op;
-				checkRef(componentType, `${base}.componentType`, ctx);
-				checkSlotCss(slot, base, ctx);
-				for (const [slotName, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${base}.slots.${slotName}`, ctx);
-				break;
-			}
-			case "deleteGlobalStyle":
-				checkRef(op.componentType, `${base}.componentType`, ctx);
-				break;
-			case "upsertPage":
-				checkRef(op.ref, `${base}.ref`, ctx);
-				if (typeof op.folder === "string" && op.folder !== "") {
-					if (!findFolderByRef(space.schema, op.folder) && !batchFolders.has(op.folder)) ctx.errors.push({
-						path: `${base}.folder`,
-						message: `Folder "${op.folder}" does not exist`,
-						hint: "Create it with upsertFolder earlier in the same batch, or read plitzi://folders for valid refs",
-						validValues: folderRefs()
-					});
-				}
-				break;
-			case "upsertFolder":
-				checkRef(op.ref, `${base}.ref`, ctx);
-				if (typeof op.parentId === "string") {
-					checkRef(op.parentId, `${base}.parentId`, ctx);
-					const parent = findFolderByRef(space.schema, op.parentId);
-					if (!parent && !batchFolders.has(op.parentId)) ctx.errors.push({
-						path: `${base}.parentId`,
-						message: `Parent folder "${op.parentId}" does not exist`,
-						hint: "Create the parent with upsertFolder first, or read plitzi://folders for valid refs",
-						validValues: folderRefs()
-					});
-					const selfId = findFolderByRef(space.schema, op.ref)?.id ?? op.ref;
-					if ((parent?.id ?? op.parentId) === selfId || parent && folderAncestorIds(pageFoldersOf(space.schema), parent.id).includes(selfId)) ctx.errors.push({
-						path: `${base}.parentId`,
-						message: `Folder "${op.ref}" cannot be nested under itself or one of its descendants`,
-						hint: "Choose a parent that is not this folder or below it"
-					});
-				}
-				break;
-			case "deleteDefinition":
-			case "deleteFolder":
-			case "deletePage":
-			case "upsertVariable":
-			case "deleteVariable":
-				checkRef("ref" in op ? op.ref : op.name, `${base}.${"ref" in op ? "ref" : "name"}`, ctx);
-				break;
-			case "upsertStyleVariable":
-			case "deleteStyleVariable":
-				if (!STYLE_CATEGORIES.includes(op.category)) ctx.errors.push({
-					path: `${base}.category`,
-					message: `Unknown style-variable category "${op.category}"`,
-					hint: "Use one of the valid categories",
-					validValues: STYLE_CATEGORIES
-				});
-				break;
-			default: break;
-		}
-	});
-	return {
-		valid: ctx.errors.length === 0,
-		errors: ctx.errors,
-		warnings: ctx.warnings
-	};
-};
-//#endregion
-export { validateOperations };

package/dist/src/modules/mcp/tools/operations/schema/registry.d.ts

@@ -1,22 +0,0 @@
-import { Schema } from '@plitzi/sdk-shared';
-export interface TypePropInfo {
-    valueTypes: string[];
-    examples: unknown[];
-}
-export interface TypeInfo {
-    count: number;
-    subTypes: string[];
-    slots: string[];
-    props: Record<string, TypePropInfo>;
-}
-export interface TypeRegistry {
-    note: string;
-    cssProperties: string[];
-    styleVariableCategories: string[];
-    templateSyntax: {
-        schemaVariable: string;
-        styleVariable: string;
-    };
-    types: Record<string, TypeInfo>;
-}
-export declare const buildTypeRegistry: (schema: Schema) => TypeRegistry;

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

@@ -1,4 +0,0 @@
-import { Space } from '../../helpers';
-import { ValidationResult } from '../../types';
-import { Operation } from '../operations';
-export declare const validateOperations: (space: Space, ops: Operation[]) => ValidationResult;