@plitzi/sdk-server 0.32.25 → 0.33.0

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 };

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

@@ -1,70 +0,0 @@
-import { getTransformer, suggestTransformer } from "../../../catalogs/builtinTransformers.js";
-import { descendantIds, elementRefOf, 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 idRef = head.slice(sep + 1);
-	const el = findElementByRef(space.schema, idRef);
-	if (!el || getSourceName(el.definition.type, el) !== head) return;
-	return {
-		ref: elementRefOf(el),
-		id: el.id
-	};
-};
-var checkBindingTarget = (ref, category, to, path, ctx) => {
-	if (category !== "attributes" && category !== "initialState") return;
-	const type = ctx.elementType(ref);
-	const targets = type ? ctx.typeMeta.get(type)?.bindingTargets?.[category] : void 0;
-	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(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 };

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

@@ -1,35 +0,0 @@
-//#region src/modules/mcp/tools/shared/validator/context.ts
-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 checkObservedName = (value, observed, kind, resource, path, ctx) => {
-	if (!value || observed.size === 0 || observed.has(value)) return;
-	warnOnce(ctx, `${kind} "${value}" at ${path} was not seen in this space. Verify against ${resource}; it may still be valid.`);
-};
-//#endregion
-export { RAW_CODE_TYPES, checkObservedName, checkStyleVarRefs, checkVarRefs, warnOnce };

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

@@ -1,39 +0,0 @@
-import { expandShorthand, isCssProperty, suggestCssProperty } from "../../../catalogs/cssCatalog/index.js";
-import { checkStyleVarRefs, checkVarRefs } from "./context.js";
-//#region src/modules/mcp/tools/shared/validator/css.ts
-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);
-	}
-};
-//#endregion
-export { checkCss, checkSlotCss };

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

@@ -1,68 +0,0 @@
-import { definitionVariantNames } from "../../operations/style/translator.js";
-import { RAW_CODE_TYPES, checkVarRefs, 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);
-	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.`);
-	}
-};
-var checkVariantApplication = (initialState, path, ctx) => {
-	for (const [cls, selectors] of Object.entries(initialState?.styleVariant ?? {})) {
-		const declared = definitionVariantNames(ctx.style, cls);
-		const batch = ctx.batchVariants.get(cls);
-		for (const [selector, variant] of Object.entries(selectors)) {
-			const names = Array.isArray(variant) ? variant : [variant];
-			for (const name of names) if (!((declared?.[selector]?.includes(name) ?? false) || (batch?.has(name) ?? false))) {
-				const avail = declared ? ` (declares: ${Object.entries(declared).map(([s, v]) => `${s}:${v.join("/")}`).join(", ")})` : "";
-				warnOnce(ctx, `Element applies variant "${name}" on class "${cls}" (${selector}) at ${path}, but that class defines no such variant${avail}. Create it via upsertDefinition/patchDefinition "variants", or fix the name.`);
-			}
-		}
-	}
-};
-var EXECUTABLE_MARKUP = /<script\b|\son[a-z]+\s*=|javascript:/i;
-var checkRawMarkup = (type, props, path, ctx) => {
-	if (ctx.mode !== "widget" || !props || !RAW_CODE_TYPES.has(type)) return;
-	for (const [key, value] of Object.entries(props)) if (typeof value === "string" && EXECUTABLE_MARKUP.test(value)) ctx.errors.push({
-		path: `${path}.props.${key}`,
-		message: `Executable markup in a "${type}" prop is not allowed in a widget`,
-		hint: "A widget renders inside the host UI, so <script>, javascript: URLs and inline on* handlers are rejected. Keep the markup inert (an inline <svg> is what this type is for) and wire behaviour with upsertInteractionFlow."
-	});
-};
-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) => {
-	checkIdRef(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));
-};
-//#endregion
-export { checkElementInput, checkRawMarkup, checkTypeProps, checkVariantApplication };

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

@@ -1,246 +0,0 @@
-import { BUILTIN_COMPONENTS } from "../../../catalogs/builtinComponents.js";
-import { observedDataSources, observedInteractionActions } from "../../../catalogs/observed.js";
-import { buildTypeRegistry } from "../../../catalogs/registry.js";
-import { findElementByRef, findFolderByRef, findPageByRef, folderAncestorIds, getPageElements, pageFoldersOf, pageRefOf, resolveRef, routeParamNames } from "../../../helpers/space.js";
-import { MAX_OPS } from "../../operations/index.js";
-import { batchDeclaredFolders, batchDeclaredPages, batchDeclaredVariants, batchDeclaredVars } from "./batch.js";
-import { checkObservedName, checkVarRefs, warnOnce } from "./context.js";
-import { checkBindingSourceScope, checkBindingTarget, checkBindingTransformers } from "./bindings.js";
-import { checkSlotCss } from "./css.js";
-import { checkRef } from "./refs.js";
-import { checkElementInput, checkRawMarkup, checkTypeProps, checkVariantApplication } from "./elements.js";
-import { checkInteractionNode } from "./interactions.js";
-//#region src/modules/mcp/tools/shared/validator/index.ts
-var STYLE_CATEGORIES = [
-	"color",
-	"spacing",
-	"shadow",
-	"custom"
-];
-var buildTypeMeta = (catalog) => {
-	const meta = /* @__PURE__ */ new Map();
-	for (const [type, entry] of Object.entries(catalog ?? {})) {
-		const bindingsAllowed = entry.bindingsAllowed;
-		meta.set(type, {
-			attributes: new Set(entry.attributes ?? []),
-			styleSelectors: new Set(entry.styleSelectors ?? []),
-			custom: entry.custom ?? false,
-			...bindingsAllowed ? { bindingTargets: {
-				attributes: new Set(bindingsAllowed.attributes ?? []),
-				initialState: new Set(bindingsAllowed.initialState ?? [])
-			} } : {}
-		});
-	}
-	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. */
-var buildValidationCtx = (space, ops, mode = "space") => {
-	const registry = buildTypeRegistry(space.schema, space.catalog);
-	return {
-		mode,
-		errors: [],
-		warnings: [],
-		warned: /* @__PURE__ */ new Set(),
-		knownTypes: /* @__PURE__ */ new Set([...Object.keys(registry.types), ...Object.keys(BUILTIN_COMPONENTS)]),
-		typeProps: new Map(Object.entries(registry.types).map(([type, info]) => [type, new Set(Object.keys(info.props))])),
-		typeMeta: buildTypeMeta(space.catalog),
-		elementType: (ref) => (findElementByRef(space.schema, ref) ?? findPageByRef(space.schema, ref))?.definition.type,
-		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))),
-		style: space.style,
-		batchVariants: batchDeclaredVariants(ops),
-		observedActions: observedInteractionActions(space.schema),
-		observedSources: observedDataSources(space.schema)
-	};
-};
-var validateOperations = (space, ops, mode = "space") => {
-	const batchPages = batchDeclaredPages(ops);
-	const batchFolders = batchDeclaredFolders(ops);
-	const folderRefs = () => pageFoldersOf(space.schema).map((f) => f.id);
-	const ctx = buildValidationCtx(space, ops, mode);
-	if (ops.length > 1e3) 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.type === "upsertBinding" || op.type === "patchBinding" || op.type === "deleteBinding" || op.type === "upsertInteractionFlow" || op.type === "patchInteractionNode" || op.type === "deleteInteraction") && 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());
-				checkVariantApplication(op.element.initialState, `${base}.element.initialState`, ctx);
-				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) {
-						checkRawMarkup(target.definition.type, op.props, base, ctx);
-						checkTypeProps(target.definition.type, op.props, base, ctx);
-					}
-				}
-				checkVariantApplication(op.initialState, `${base}.initialState`, ctx);
-				break;
-			}
-			case "upsertDefinitions": {
-				const entries = Object.entries(op.definitions);
-				if (entries.length === 0) ctx.errors.push({
-					path: `${base}.definitions`,
-					message: "This operation declares no classes",
-					hint: "Key each class by its name: { \"definitions\": { \"card\": { \"desktop\": { … } } } }"
-				});
-				for (const [ref, { slots, ...slot }] of entries) {
-					const entry = `${base}.definitions.${ref}`;
-					checkRef(ref, entry, ctx);
-					checkSlotCss(slot, entry, ctx);
-					for (const [slotName, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${entry}.slots.${slotName}`, 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 (op.slug === void 0 && !findPageByRef(space.schema, op.ref)) warnOnce(ctx, `Page "${op.ref}" is being created without a slug. Set a slug for a clean, stable URL (good practice); the page ref is used as a fallback.`);
-				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;
-			case "upsertBinding":
-				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"
-				});
-				op.nodes.forEach((node, n) => checkInteractionNode(node, `${base}.nodes[${n}]`, ctx, op.ref));
-				break;
-			case "patchInteractionNode": {
-				checkRef(op.ref, `${base}.ref`, ctx);
-				const existing = findElementByRef(space.schema, op.ref)?.definition.interactions?.[op.nodeId];
-				if (existing) {
-					const merged = {
-						id: existing.id,
-						title: op.title ?? existing.title,
-						nodeType: existing.type,
-						action: op.action ?? existing.action,
-						params: {
-							...existing.params,
-							...op.params ?? {}
-						},
-						enabled: op.enabled ?? existing.enabled,
-						elementId: op.elementId ?? existing.elementId ?? void 0
-					};
-					checkInteractionNode(merged, base, ctx, op.ref);
-				} else checkObservedName(op.action, ctx.observedActions, "Interaction action", "plitzi://interactions", `${base}.action`, ctx);
-				break;
-			}
-			case "deleteInteraction":
-				checkRef(op.ref, `${base}.ref`, ctx);
-				if (Boolean(op.flowId) === Boolean(op.nodeId)) ctx.errors.push({
-					path: `${base}.nodeId`,
-					message: "Provide exactly one of flowId or nodeId",
-					hint: "flowId removes a whole flow; nodeId removes a single step"
-				});
-		}
-	});
-	return {
-		valid: ctx.errors.length === 0,
-		errors: ctx.errors,
-		warnings: ctx.warnings
-	};
-};
-//#endregion
-export { buildValidationCtx, validateOperations };