@plitzi/sdk-server 0.32.24 → 0.33.0

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

@@ -1,45 +0,0 @@
-import { settingsUri } from "../../../../helpers/uris.js";
-import { empty } from "../../../../helpers/opResult.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/schema/settings/patchSettings.ts
-var userProvider = z.enum([
-	"auth0",
-	"basic",
-	"custom",
-	""
-]);
-var storage = z.enum([
-	"localStorage",
-	"sessionStorage",
-	""
-]);
-var patchSettingsOp = z.object({
-	type: z.literal("patchSettings"),
-	customCss: z.string().optional().describe("Raw global CSS for the whole space (keyframes, @font-face, resets)"),
-	keepState: z.boolean().optional().describe("Persist element state across reloads"),
-	stateStorage: z.enum(["localStorage", "sessionStorage"]).optional(),
-	userProvider: userProvider.optional().describe("Auth provider; \"\" disables authentication"),
-	auth0Domain: z.string().optional(),
-	auth0ClientId: z.string().optional(),
-	tokenStorage: storage.optional(),
-	loginUrl: z.string().optional(),
-	userUrl: z.string().optional(),
-	refreshUrl: z.string().optional(),
-	logoutUrl: z.string().optional(),
-	detailsPath: z.string().optional(),
-	tokenPath: z.string().optional(),
-	expirationTimePath: z.string().optional()
-}).describe("Merge space-level settings: the global CSS (customCss) and the state/auth (user-provider) configuration. Only the fields you pass change; the rest are preserved. Use customCss for site-wide CSS, never to style one element (attach a definition for that).");
-var patchSettings = (space, env, op) => {
-	const { type, ...patch } = op;
-	const next = { ...space.schema.settings };
-	for (const [key, value] of Object.entries(patch)) next[key] = value;
-	space.schema.settings = next;
-	return {
-		...empty(),
-		updated: 1,
-		staleResources: [settingsUri(env)]
-	};
-};
-//#endregion
-export { patchSettings, patchSettingsOp };

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

@@ -1,122 +0,0 @@
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/schema/shared.ts
-var combinator = z.enum(["and", "or"]);
-var operator = z.enum([
-	"",
-	"=",
-	"!=",
-	"<",
-	">",
-	"<=",
-	">=",
-	"contains",
-	"doesNotContain",
-	"beginsWith",
-	"doesNotBeginWith",
-	"endsWith",
-	"doesNotEndWith",
-	"empty",
-	"notEmpty",
-	"in",
-	"notIn",
-	"between",
-	"notBetween"
-]);
-var ruleValue = z.union([
-	z.string(),
-	z.number(),
-	z.boolean(),
-	z.null(),
-	z.record(z.string(), z.unknown()),
-	z.array(z.unknown())
-]);
-var ruleBase = {
-	id: z.string().optional(),
-	field: z.string().describe("The data field the rule tests"),
-	operator,
-	enabled: z.boolean().optional()
-};
-var rule = z.union([z.object({
-	...ruleBase,
-	isBinding: z.literal(true),
-	value: z.string()
-}), z.object({
-	...ruleBase,
-	isBinding: z.literal(false).optional(),
-	value: ruleValue
-})]);
-var ruleGroup = z.lazy(() => z.object({
-	id: z.string().optional(),
-	combinator,
-	rules: z.array(z.union([rule, ruleGroup])),
-	enabled: z.boolean().optional()
-}));
-var styleRefs = z.object({
-	base: z.array(z.string()).optional(),
-	slots: z.record(z.string(), z.array(z.string())).optional()
-});
-var styleVariantInput = z.record(z.string(), z.record(z.string(), z.union([z.string(), z.array(z.string())])));
-var initialStateInput = z.object({
-	styleVariant: styleVariantInput.optional().describe("Variant each attached class uses: { className: { base|slot: variantName | [names] } }"),
-	visibility: z.boolean().optional().describe("Initial visibility of the element")
-});
-var elementShape = {
-	ref: z.string().describe("Semantic id you choose, or an existing element ref/id. On a new element it becomes the idRef everything addresses it by: its data source is `<type>_<ref>`, and interactions target it by this ref. Letters, digits, `-` and `_`, starting with a letter — a dot would break the `<type>_<idRef>.<field>` grammar. Unique across the space."),
-	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"),
-	initialState: initialStateInput.optional().describe("Applied style variant(s) and initial visibility (see plitzi://guide styling)")
-};
-var elementInput = z.lazy(() => z.object({
-	...elementShape,
-	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()
-]);
-var bindingCategory = z.enum([
-	"attributes",
-	"style",
-	"initialState"
-]).describe("What the value feeds: a prop (attributes), a style value (style), or an initialState key");
-var bindingTransformer = z.object({
-	action: z.string().describe("Transformer action name"),
-	params: z.record(z.string(), z.string()),
-	enabled: z.boolean().optional().describe("Set false to keep the transformer in the chain but skip it at runtime (defaults to true)")
-});
-var bindingInput = z.object({
-	to: z.string().describe("Target field the value feeds (a prop key, style value, or initialState key)"),
-	source: z.string().describe("Data source path, e.g. \"apiContainer_x.data\" — see plitzi://data-sources"),
-	id: z.string().optional().describe("Stable binding id; generated when omitted"),
-	transformers: z.array(bindingTransformer).optional(),
-	when: ruleGroup.optional().describe("QueryBuilder RuleGroup gating the binding (validated structurally)"),
-	enabled: z.boolean().optional()
-});
-var interactionNodeType = z.enum([
-	"trigger",
-	"globalCallback",
-	"callback",
-	"utility"
-]).describe("trigger starts a flow (must be first); the rest run in order after it");
-var interactionNode = z.object({
-	id: z.string().optional().describe("Existing node id to preserve; generated when omitted"),
-	title: z.string().describe("Human label for the step"),
-	nodeType: interactionNodeType,
-	action: z.string().describe("Action name, e.g. \"onClick\", \"login\" — see plitzi://interactions"),
-	params: z.record(z.string(), z.unknown()).optional(),
-	enabled: z.boolean().optional(),
-	when: ruleGroup.optional().describe("QueryBuilder RuleGroup gating this step (validated structurally)"),
-	elementId: z.string().optional().describe("Element whose callback this step invokes; defaults to this element. Its ref or raw id — a raw id is normalised to the idRef the runtime looks callbacks up by, and a target without one is given it."),
-	preview: z.record(z.string(), z.unknown()).optional()
-});
-//#endregion
-export { bindingCategory, bindingInput, elementInput, elementShape, initialStateInput, interactionNode, interactionNodeType, position, ruleGroup, scalar, styleRefs, styleVariantInput };

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

@@ -1,215 +0,0 @@
-import { computeVersion } from "../../../helpers/computeVersion.js";
-import { descendantCount, descendantIds, elementById, elementRefOf, getPageElements, isPageElement, nameOf, orderedChildren, pageFoldersOf, pageRefOf, pageRefOfElement, slugRouteParams, spaceIndex, strOr } from "../../../helpers/space.js";
-import { bindingsToAI, flowsFromInteractions } from "../../../helpers/interactions.js";
-import { definitionToAI, globalStylesForType, idStyleToAI } from "../style/translator.js";
-//#region src/modules/mcp/tools/operations/schema/translator.ts
-var splitClasses = (value) => value ? value.split(/\s+/).filter(Boolean) : [];
-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,
-	enabled: page.attributes.enabled !== false,
-	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 elementView = (schema, el, style) => {
-	const cache = spaceIndex(schema).detailCache;
-	const cached = cache.get(el.id);
-	if (cached && cached.style === style) return cached;
-	const detail = elementDetailToAI(schema, el, style);
-	const view = {
-		style,
-		detail,
-		version: computeVersion(detail)
-	};
-	cache.set(el.id, view);
-	return view;
-};
-var skeletonNode = (schema, el, style) => {
-	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),
-		stateVersion: style ? elementView(schema, el, style).version : void 0,
-		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, style)) : void 0
-	};
-};
-var pageSkeletonToAI = (schema, pageEl, style) => {
-	const slug = strOr(pageEl.attributes.slug) ?? "";
-	return {
-		ref: pageRefOf(pageEl),
-		label: nameOf(pageEl),
-		slug,
-		default: pageEl.attributes.default === true,
-		enabled: pageEl.attributes.enabled !== false,
-		routeParams: slugRouteParams(slug),
-		tree: orderedChildren(schema, pageEl).map((child) => skeletonNode(schema, child, style))
-	};
-};
-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 variantNamesOf = (def) => {
-	const names = new Set(Object.keys(def.variants ?? {}));
-	for (const slot of Object.values(def.slots ?? {})) for (const name of Object.keys(slot.variants ?? {})) names.add(name);
-	return [...names].sort();
-};
-var availableVariantsFrom = (resolvedStyle) => {
-	if (!resolvedStyle) return;
-	const result = {};
-	for (const [ref, def] of Object.entries(resolvedStyle)) {
-		const names = variantNamesOf(def);
-		if (names.length > 0) result[ref] = names;
-	}
-	return Object.keys(result).length > 0 ? result : void 0;
-};
-var initialStateToAI = (el) => {
-	const initialState = el.definition.initialState;
-	if (!initialState) return;
-	const result = {};
-	if (initialState.styleVariant) {
-		const styleVariant = {};
-		for (const [cls, selectors] of Object.entries(initialState.styleVariant)) {
-			if (!selectors) continue;
-			const bySelector = {};
-			for (const [selector, variant] of Object.entries(selectors)) if (variant !== void 0) bySelector[selector] = variant;
-			if (Object.keys(bySelector).length > 0) styleVariant[cls] = bySelector;
-		}
-		if (Object.keys(styleVariant).length > 0) result.styleVariant = styleVariant;
-	}
-	if (typeof initialState.visibility === "boolean") result.visibility = initialState.visibility;
-	return Object.keys(result).length > 0 ? result : 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
-	};
-	const initialState = initialStateToAI(el);
-	if (initialState) detail.initialState = initialState;
-	const bindings = bindingsToAI(el.definition.bindings);
-	if (bindings) detail.bindings = bindings;
-	const interactions = flowsFromInteractions(el.definition.interactions);
-	if (interactions.length > 0) detail.interactions = interactions;
-	if (style) {
-		const resolvedStyle = resolveDefinitions(style, base, slots);
-		if (resolvedStyle) {
-			detail.resolvedStyle = resolvedStyle;
-			const availableVariants = availableVariantsFrom(resolvedStyle);
-			if (availableVariants) detail.availableVariants = availableVariants;
-		}
-		const globalStyles = globalStylesForType(style, el.definition.type);
-		if (globalStyles.length > 0) detail.globalStyles = globalStyles;
-		const domId = strOr(el.attributes.id);
-		if (domId) {
-			const idStyle = idStyleToAI(style, domId);
-			if (idStyle) detail.idStyle = idStyle;
-		}
-	}
-	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;
-};
-var settingsToAI = (schema) => {
-	const result = {};
-	for (const [key, value] of Object.entries(schema.settings)) result[key] = value;
-	return result;
-};
-//#endregion
-export { elementDetailToAI, elementView, folderRefToAI, foldersToAI, pageSkeletonToAI, pageStylesToAI, pageSummariesToAI, schemaVariablesToAI, settingsToAI };

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

@@ -1,18 +0,0 @@
-import { schemaVarsUri } from "../../../../helpers/uris.js";
-import { empty } from "../../../../helpers/opResult.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/schema/variables/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/variables/upsertVariable.js

@@ -1,42 +0,0 @@
-import { schemaVarsUri } from "../../../../helpers/uris.js";
-import { empty } from "../../../../helpers/opResult.js";
-import { scalar } from "../shared.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/schema/variables/upsertVariable.ts
-var upsertVariableOp = z.object({
-	type: z.literal("upsertVariable"),
-	name: z.string().describe("Variable name; referenced in content as {{name}}"),
-	variableType: z.string().describe("Runtime type (text|number|...); NOT the `type` discriminator"),
-	value: scalar,
-	category: z.string().optional(),
-	subValues: z.array(z.object({
-		when: z.unknown(),
-		value: scalar
-	})).optional()
-}).describe("Create or update a space-level schema variable (a {{name}} value shared across the space).");
-var upsertVariable = (space, env, op) => {
-	const variable = {
-		name: op.name,
-		category: op.category ?? "general",
-		type: op.variableType,
-		value: op.value,
-		subValues: op.subValues ?? []
-	};
-	const idx = space.schema.variables.findIndex((v) => v.name === op.name);
-	if (idx >= 0) {
-		space.schema.variables[idx] = variable;
-		return {
-			...empty(),
-			updated: 1,
-			staleResources: [schemaVarsUri(env)]
-		};
-	}
-	space.schema.variables.push(variable);
-	return {
-		...empty(),
-		created: 1,
-		staleResources: [schemaVarsUri(env)]
-	};
-};
-//#endregion
-export { upsertVariable, upsertVariableOp };

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

@@ -1,109 +0,0 @@
-import { findElementByRef, findPageByRef, generateObjectId, indexAddElement, indexReRefElement, resolveRef, spaceIndex } from "../../../helpers/space.js";
-import { folderUri, foldersUri, pageUri, pagesUri, schemaVarsUri, settingsUri } from "../../../helpers/uris.js";
-import { fail } from "../../../helpers/opResult.js";
-import { isValidIdRef, makeIdRef } from "@plitzi/sdk-schema/helpers/idRef";
-//#region src/modules/mcp/tools/operations/schema/write.ts
-var ID_REF_HINT = "Start with a letter, then letters, numbers, hyphens and underscores (e.g. \"hero-cta\" or \"food_item\"). The ref becomes the element idRef, which the runtime embeds in source names like `apiContainer_<idRef>.field` and in interaction targets — a dot would split those paths (an underscore is fine: the FIRST `_` separates the type from the idRef, and element types carry none, so extra underscores are unambiguous).";
-var TAKEN_HINT = "An idRef must be unique across the space — pick a different ref, or address the existing element by this ref.";
-/** Every ref in an element input tree (the element plus its nested children) — each becomes a new element's idRef. */
-var collectInputRefs = (input) => [input.ref, ...(input.children ?? []).flatMap(collectInputRefs)];
-/** Validate a ref that is about to become an element's idRef: the charset, then whether anything already answers
-*  to it. The charset rule is sdk-schema's `isValidIdRef` — never a regex restated here, so the MCP cannot drift
-*  from what the builder and the schema validator enforce.
-*
-*  Uniqueness is checked with the ref lookups rather than `FlatMap.idRefConflict`, and deliberately so: these are
-*  a superset of it. FlatMap asks whether another element holds this idRef; the MCP must also refuse a ref that
-*  shadows a raw id or a page slug, because its handlers resolve refs through those too — calling both would just
-*  run the same rule twice. Null when the ref is usable.
-*
-*  Enforced here, at every point a ref BECOMES an idRef — addressing an existing element by its raw id is not
-*  charset-checked, which is why the validator cannot simply tighten its own REF_RE for every ref it sees. */
-var guardNewRef = (space, ref, field) => {
-	if (!isValidIdRef(ref)) return fail(field, `"${ref}" is not a valid idRef`, ID_REF_HINT);
-	if (findElementByRef(space.schema, ref) || findPageByRef(space.schema, ref)) return fail(field, `"${ref}" is already used by another element in this space`, TAKEN_HINT);
-	return null;
-};
-var removeFromParent = (space, child) => {
-	const parent = child.definition.parentId ? space.schema.flat[child.definition.parentId] : void 0;
-	if (parent?.definition.items) parent.definition.items = parent.definition.items.filter((id) => id !== child.id);
-};
-var placeChild = (parent, childId, index) => {
-	const items = parent.definition.items ?? (parent.definition.items = []);
-	if (index === void 0 || index < 0 || index >= items.length) items.push(childId);
-	else items.splice(index, 0, childId);
-};
-var writeInitialState = (el, input, merge) => {
-	const current = el.definition.initialState ?? {};
-	const next = { ...current };
-	if (input.styleVariant !== void 0) if (merge) {
-		const merged = { ...current.styleVariant };
-		for (const [cls, selectors] of Object.entries(input.styleVariant)) merged[cls] = {
-			...merged[cls],
-			...selectors
-		};
-		next.styleVariant = merged;
-	} else next.styleVariant = input.styleVariant;
-	if (input.visibility !== void 0) next.visibility = input.visibility;
-	el.definition.initialState = next;
-};
-var createElement = (space, page, input, parent, index) => {
-	const id = generateObjectId();
-	const { subType, ...props } = {
-		subType: input.subType,
-		...input.props
-	};
-	const styleSelectors = { base: (input.style?.base ?? []).join(" ") };
-	for (const [slot, classes] of Object.entries(input.style?.slots ?? {})) styleSelectors[slot] = classes.join(" ");
-	const el = {
-		id,
-		idRef: input.ref,
-		attributes: subType === void 0 ? props : {
-			subType,
-			...props
-		},
-		definition: {
-			rootId: page.id,
-			parentId: parent.id,
-			label: input.label ?? input.ref,
-			type: input.type,
-			items: [],
-			styleSelectors
-		}
-	};
-	space.schema.flat[id] = el;
-	placeChild(parent, id, index);
-	indexAddElement(space.schema, el, page.id);
-	if (input.initialState) writeInitialState(el, input.initialState, false);
-	for (const child of input.children ?? []) createElement(space, page, child, el, void 0);
-};
-/** The idRef an element is wired by, minting one when it has none. Interactions are keyed by idRef, so an element
-*  that is about to host or be targeted by a flow must have one — rather than make the agent assign it with a
-*  separate patchElement, the MCP gives it a free `<type>-<n>` ref (unique across the space) and proceeds. An
-*  element that already has an idRef keeps it. Mutates the element in place and returns the ref. */
-var ensureIdRef = (space, el) => {
-	if (el.idRef) return el.idRef;
-	const index = spaceIndex(space.schema);
-	el.idRef = makeIdRef(el.definition.type, (candidate) => index.elementByRef.has(candidate) || index.pageByRef.has(candidate));
-	indexReRefElement(space.schema, el);
-	return el.idRef;
-};
-/** The key an interaction node must store to reach a target element. Every ref field also accepts a raw id, so a
-*  target given as an id is resolved to the element's idRef — the key the runtime registers callbacks under. A
-*  target that has no idRef is given one (see `ensureIdRef`), since it must be reachable to be wired to. A target
-*  that resolves to no element is left as written — it is already a ref, or a key only a plugin knows. */
-var resolveTargetRef = (space, elementId) => {
-	const el = space.schema.flat[elementId] ?? findElementByRef(space.schema, elementId);
-	return el ? ensureIdRef(space, el) : elementId;
-};
-/** Resolve a non-page element within a page for the element-scoped ops (bindings, interactions). Returns the
-*  element, or a teachable OpResult when the page or element ref does not resolve — so each op reports the same
-*  errors as patchElement without repeating them. */
-var resolveElement = (space, env, pageRef, ref) => {
-	const page = findPageByRef(space.schema, pageRef);
-	if (!page) return { error: fail("pageRef", `Page "${pageRef}" not found`, `Read plitzi://schema/${env}/pages for valid refs`) };
-	const el = resolveRef(space.schema, page, ref);
-	if (!el || el.id === page.id) return { error: fail("ref", `Element "${ref}" not found in page "${pageRef}"`, "Use an existing element ref or id") };
-	return { el };
-};
-//#endregion
-export { ID_REF_HINT, collectInputRefs, createElement, ensureIdRef, folderUri, foldersUri, guardNewRef, pageUri, pagesUri, placeChild, removeFromParent, resolveElement, resolveTargetRef, schemaVarsUri, settingsUri, writeInitialState };

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

@@ -1,54 +0,0 @@
-import { bindingInput, elementInput, initialStateInput, interactionNode, position, ruleGroup, styleRefs, styleVariantInput } from "./schema/shared.js";
-import { cssMap, cssPatchMap, definitionSlot, definitionSlotPatch, displayModeCss, displayModeCssPatch, themeValue } from "./style/shared.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/schemaIds.ts
-/** The op union is the tool input of plitzi_apply, plitzi_validate, plitzi_render AND plitzi_preview, and every
-*  host reads it as JSON Schema on tools/list — four copies of the same 30 operations in the model's context, on
-*  EVERY request of every conversation the server is connected to. It measured ~25k tokens PER TOOL (~100k in
-*  total), which dwarfs anything a widget payload ever costs.
-*
-*  Most of that weight is one subschema pasted over and over: an element tree appears in upsertElement,
-*  patchElement and both repeat templates; a breakpoint CSS block in every style op; a rule group in every binding
-*  and interaction step. Zod emits a named `definitions` entry (and `$ref`s to it) for any schema carrying an `id`
-*  in the global registry, so registering the shared ones here collapses those copies — without touching the ops,
-*  the tools, or the MCP SDK, whose own converter honours the registry (it is given no options otherwise).
-*
-*  An id only pays when the schema is REUSED: giving one to a subschema that appears once makes the listing bigger,
-*  because the `definitions` entry and the ref cost more than the single copy they replace (measured, and reverted).
-*
-*  The ids are the names the MODEL reads in the refs, so they are written for it: `Element`, not `ElementInput`.
-*  This runs once, at module load of the op vocabulary, so every conversion path benefits — the MCP tools list and
-*  the co-worker's own tool-schema converter alike. */
-var SHARED_SCHEMAS = [
-	[elementInput, "Element"],
-	[ruleGroup, "RuleGroup"],
-	[styleRefs, "StyleRefs"],
-	[initialStateInput, "InitialState"],
-	[styleVariantInput, "StyleVariant"],
-	[interactionNode, "InteractionNode"],
-	[bindingInput, "Binding"],
-	[position, "Position"],
-	[cssMap, "Css"],
-	[cssPatchMap, "CssPatch"],
-	[definitionSlot, "StyleSlot"],
-	[definitionSlotPatch, "StyleSlotPatch"],
-	[displayModeCss, "BreakpointCss"],
-	[displayModeCssPatch, "BreakpointCssPatch"],
-	[themeValue, "ThemeValue"]
-];
-var claimSchemaId = (schema, id) => {
-	const taken = z.globalRegistry._idmap.get(id);
-	if (taken !== void 0 && taken !== schema) {
-		z.globalRegistry.add(schema, { id: `Plitzi${id}` });
-		return;
-	}
-	z.globalRegistry.add(schema, { id });
-};
-/** Idempotent: the module can be imported more than once in a test run, and a schema that already carries its id
-*  is left alone (re-adding the same one is harmless but pointless). Runs at module load, never per request — the
-*  MCP builds a server per request and this must not grow with them (pinned in the statelessness test). */
-var registerSharedSchemaIds = () => {
-	for (const [schema, id] of SHARED_SCHEMAS) if (z.globalRegistry.get(schema)?.id === void 0) claimSchemaId(schema, id);
-};
-//#endregion
-export { claimSchemaId, registerSharedSchemaIds };

package/dist/modules/mcp/tools/operations/style/definitions/deleteDefinition.js

@@ -1,21 +0,0 @@
-import { defUri, defsUri } from "../../../../helpers/uris.js";
-import { empty } from "../../../../helpers/opResult.js";
-import { MODES, guardKind } from "../write.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/style/definitions/deleteDefinition.ts
-var deleteDefinitionOp = z.object({
-	type: z.literal("deleteDefinition"),
-	ref: z.string().describe("Class ref of the definition to delete")
-}).describe("Delete a style class definition by ref (does not detach it from elements that still list it).");
-var deleteDefinition = (space, env, op) => {
-	const guard = guardKind(space.style, op.ref, "class");
-	if (guard) return guard;
-	for (const mode of MODES) Reflect.deleteProperty(space.style.platform[mode], op.ref);
-	return {
-		...empty(),
-		deleted: 1,
-		staleResources: [defUri(env, op.ref), defsUri(env)]
-	};
-};
-//#endregion
-export { deleteDefinition, deleteDefinitionOp };

package/dist/modules/mcp/tools/operations/style/definitions/patchDefinition.js

@@ -1,28 +0,0 @@
-import { defUri, defsUri } from "../../../../helpers/uris.js";
-import { empty, fail } from "../../../../helpers/opResult.js";
-import { definitionToAI } from "../translator.js";
-import { patchCssShape } from "../shared.js";
-import { guardKind, mergePatch, writeStyleItem } from "../write.js";
-import { z } from "zod";
-//#region src/modules/mcp/tools/operations/style/definitions/patchDefinition.ts
-var patchDefinitionOp = z.object({
-	type: z.literal("patchDefinition"),
-	ref: z.string().describe("Existing class ref to patch"),
-	...patchCssShape
-}).describe("Partially update an existing style class: the CSS you pass is merged (a null value removes that property, others are kept). Never creates — use upsertDefinition for that.");
-var patchDefinition = (space, env, op) => {
-	const guard = guardKind(space.style, op.ref, "class");
-	if (guard) return guard;
-	const existing = definitionToAI(space.style, op.ref);
-	if (!existing) return fail("ref", `Definition "${op.ref}" not found`, "patchDefinition only updates an existing definition; use upsertDefinition to create one");
-	const { type, ref, slots: slotsPatch, ...basePatch } = op;
-	const { base, slots } = mergePatch(existing, basePatch, slotsPatch);
-	writeStyleItem(space.style, ref, base, slots, "class", void 0);
-	return {
-		...empty(),
-		updated: 1,
-		staleResources: [defUri(env, ref), defsUri(env)]
-	};
-};
-//#endregion
-export { patchDefinition, patchDefinitionOp };