@plitzi/sdk-server 0.32.5 → 0.32.7

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

@@ -1,7 +1,8 @@
 import { computeVersion } from "../helpers/computeVersion.js";
-import { elementRefOf, getPageElements, isPageElement, pageRefOf, pageRefOfElement } from "../helpers/space.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 { elementDetailToAI, pageSkeletonToAI } from "./operations/schema/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
@@ -15,21 +16,20 @@ var searchShape = {
 	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 labelOf = (el) => (typeof el.attributes.name === "string" ? el.attributes.name : void 0) ?? el.definition.label;
 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(labelOf(current));
+		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 results = [];
+	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;
@@ -40,22 +40,33 @@ var search = (input, space, env) => {
 		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;
-		const ref = elementRefOf(el);
-		const detail = elementDetailToAI(space.schema, el, space.style);
-		results.push({
+		matched.push({
+			el,
 			pageRef,
-			ref,
-			uri: `plitzi://schema/${env}/elements/${ref}`,
-			pageUri: `plitzi://schema/${env}/pages/${pageRef}`,
-			stateVersion: computeVersion(detail),
-			parentRef: detail.parentRef,
-			path: breadcrumb(space.schema, el),
-			label: el.definition.label,
-			type: el.definition.type,
-			matches,
-			detail: input.include === "detail" ? detail : void 0
+			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)) {
@@ -66,7 +77,7 @@ var search = (input, space, env) => {
 	}
 	const pages = [];
 	for (const page of getPageElements(space.schema)) {
-		const label = labelOf(page);
+		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}`);
@@ -75,19 +86,15 @@ var search = (input, space, env) => {
 		const ref = pageRefOf(page);
 		pages.push({
 			ref,
-			uri: `plitzi://schema/${env}/pages/${ref}`,
-			stateVersion: computeVersion(pageSkeletonToAI(space.schema, page)),
+			uri: pageUri(env, ref),
+			stateVersion: computeVersion(pageSkeletonToAI(space.schema, page, space.style)),
 			label,
 			slug,
 			matches
 		});
 	}
-	const offset = input.offset ?? 0;
-	const limit = input.limit ?? 50;
-	const total = results.length;
-	const nextOffset = offset + limit < total ? offset + limit : void 0;
 	return {
-		results: results.slice(offset, offset + limit),
+		results,
 		total,
 		offset,
 		limit,
@@ -99,7 +106,7 @@ var search = (input, space, env) => {
 var searchTool = defineTool({
 	name: "plitzi_search",
 	title: "Search",
-	description: "Find elements by 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.",
+	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)

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

@@ -20,6 +20,7 @@ var defineTool = (spec) => ({
 	inputShape: spec.inputShape,
 	access: spec.access,
 	requires: spec.requires,
+	spaceless: spec.spaceless,
 	execute: (args, ctx) => spec.run(z.object(spec.inputShape).parse(args), ctx)
 });
 //#endregion

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

@@ -0,0 +1,124 @@
+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 "upsertGlobalStyle":
+		case "patchGlobalStyle":
+			touched.globalStyles.add(op.componentType);
+			break;
+		case "upsertIdStyle":
+		case "patchIdStyle":
+			touched.idStyles.add(op.targetId);
+			break;
+		default: break;
+	}
+	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

@@ -0,0 +1,30 @@
+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 batchDeclaredVariants = (ops) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const op of ops) {
+		if (op.type !== "upsertDefinition" && op.type !== "patchDefinition") continue;
+		const names = new Set(Object.keys(op.variants ?? {}));
+		for (const slot of Object.values(op.slots ?? {})) for (const name of Object.keys(slot.variants ?? {})) names.add(name);
+		if (names.size > 0) map.set(op.ref, /* @__PURE__ */ new Set([...map.get(op.ref) ?? [], ...names]));
+	}
+	return map;
+};
+//#endregion
+export { batchDeclaredFolders, batchDeclaredPages, batchDeclaredVariants, batchDeclaredVars };

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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,35 @@
+//#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

@@ -0,0 +1,47 @@
+import { compoundLonghands, expandShorthand, isCssProperty, suggestCssProperty } from "../../../catalogs/cssCatalog.js";
+import { checkStyleVarRefs, checkVarRefs, warnOnce } 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))) {
+		const longhands = compoundLonghands(key);
+		if (longhands) if (!isCssProperty(key)) ctx.errors.push({
+			path: `${path}.${key}`,
+			message: `Compound CSS shorthand "${key}" is not supported — write its atomic longhand properties`,
+			hint: `Use: ${longhands.join(", ")}. (Note: flex layout is display + flex-direction + flex-grow/shrink/basis, not "flex".)`,
+			validValues: longhands
+		});
+		else warnOnce(ctx, `CSS shorthand "${key}" at ${path}.${key} is accepted but stored as one compound value. Plitzi styling is atomic — prefer the longhands (${longhands.join(", ")}) so a breakpoint/state/variant can override each property independently.`);
+		else 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

@@ -0,0 +1,55 @@
+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))) warnOnce(ctx, `Element applies variant "${name}" on class "${cls}" (${selector}) at ${path}, but that class defines no such variant${declared ? ` (declares: ${Object.entries(declared).map(([s, v]) => `${s}:${v.join("/")}`).join(", ")})` : ""}. Create it via upsertDefinition/patchDefinition "variants", or fix the name.`);
+		}
+	}
+};
+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) => {
+	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, checkTypeProps, checkVariantApplication };