@plitzi/sdk-server 0.32.4 → 0.32.6

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

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

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

@@ -0,0 +1,109 @@
+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/style/definitions/deleteDefinition.js

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

@@ -0,0 +1,28 @@
+import { defUri, defsUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { definitionToAI } from "../translator.js";
+import { guardKind, mergePatch, writeStyleItem } from "../write.js";
+import { patchCssShape } from "../shared.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 };

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

@@ -0,0 +1,24 @@
+import { defUri, defsUri } from "../../../../helpers/uris.js";
+import { empty } from "../../../../helpers/opResult.js";
+import { guardKind, writeStyleItem } from "../write.js";
+import { upsertCssShape } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/definitions/upsertDefinition.ts
+var upsertDefinitionOp = z.object({
+	type: z.literal("upsertDefinition"),
+	ref: z.string().describe("Class name you choose (kebab-case), or an existing class ref to fully replace"),
+	...upsertCssShape
+}).describe("Create a reusable style class (CSS), or fully replace it when ref exists. Apply it by attaching ref to an element via its style.base. Use patchDefinition to change only some CSS.");
+var upsertDefinition = (space, env, op) => {
+	const { type, ref, slots, ...base } = op;
+	const guard = guardKind(space.style, ref, "class");
+	if (guard) return guard;
+	writeStyleItem(space.style, ref, base, slots, "class", void 0);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [defUri(env, ref), defsUri(env)]
+	};
+};
+//#endregion
+export { upsertDefinition, upsertDefinitionOp };

package/dist/modules/mcp/tools/operations/style/globalStyles/deleteGlobalStyle.js

@@ -0,0 +1,21 @@
+import { globalUri, globalsUri } 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/globalStyles/deleteGlobalStyle.ts
+var deleteGlobalStyleOp = z.object({
+	type: z.literal("deleteGlobalStyle"),
+	componentType: z.string().describe("Element type whose site-wide style to remove")
+}).describe("Remove the site-wide style for an element type (elements of that type keep their own classes).");
+var deleteGlobalStyle = (space, env, op) => {
+	const guard = guardKind(space.style, op.componentType, "element");
+	if (guard) return guard;
+	for (const mode of MODES) Reflect.deleteProperty(space.style.platform[mode], op.componentType);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [globalUri(env, op.componentType), globalsUri(env)]
+	};
+};
+//#endregion
+export { deleteGlobalStyle, deleteGlobalStyleOp };

package/dist/modules/mcp/tools/operations/style/globalStyles/patchGlobalStyle.js

@@ -0,0 +1,28 @@
+import { globalUri, globalsUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { globalStyleToAI } from "../translator.js";
+import { guardKind, mergePatch, writeStyleItem } from "../write.js";
+import { patchCssShape } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/globalStyles/patchGlobalStyle.ts
+var patchGlobalStyleOp = z.object({
+	type: z.literal("patchGlobalStyle"),
+	componentType: z.string().describe("Element type whose global style to merge into; affects ALL of that type"),
+	...patchCssShape
+}).describe("Partially update the site-wide style for an element type: CSS is merged (a null value removes a property). Never creates — use upsertGlobalStyle for that.");
+var patchGlobalStyle = (space, env, op) => {
+	const guard = guardKind(space.style, op.componentType, "element");
+	if (guard) return guard;
+	const existing = globalStyleToAI(space.style, op.componentType);
+	if (!existing) return fail("componentType", `No global style for "${op.componentType}"`, "patchGlobalStyle only updates an existing global; use upsertGlobalStyle to create one");
+	const { type, componentType, slots: slotsPatch, ...basePatch } = op;
+	const { base, slots } = mergePatch(existing, basePatch, slotsPatch);
+	writeStyleItem(space.style, componentType, base, slots, "element", componentType);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [globalUri(env, componentType), globalsUri(env)]
+	};
+};
+//#endregion
+export { patchGlobalStyle, patchGlobalStyleOp };

package/dist/modules/mcp/tools/operations/style/globalStyles/upsertGlobalStyle.js

@@ -0,0 +1,24 @@
+import { globalUri, globalsUri } from "../../../../helpers/uris.js";
+import { empty } from "../../../../helpers/opResult.js";
+import { guardKind, writeStyleItem } from "../write.js";
+import { upsertCssShape } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/globalStyles/upsertGlobalStyle.ts
+var upsertGlobalStyleOp = z.object({
+	type: z.literal("upsertGlobalStyle"),
+	componentType: z.string().describe("Element type to style site-wide (e.g. \"button\"); affects ALL of that type"),
+	...upsertCssShape
+}).describe("Create or fully replace the site-wide style for an element TYPE — its CSS applies to every element of that type. To style one element only, use upsertDefinition + attach it. Use patchGlobalStyle for a partial change.");
+var upsertGlobalStyle = (space, env, op) => {
+	const { type, componentType, slots, ...base } = op;
+	const guard = guardKind(space.style, componentType, "element");
+	if (guard) return guard;
+	writeStyleItem(space.style, componentType, base, slots, "element", componentType);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [globalUri(env, componentType), globalsUri(env)]
+	};
+};
+//#endregion
+export { upsertGlobalStyle, upsertGlobalStyleOp };

package/dist/modules/mcp/tools/operations/style/idStyles/deleteIdStyle.js

@@ -0,0 +1,21 @@
+import { idUri, idsUri } 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/idStyles/deleteIdStyle.ts
+var deleteIdStyleOp = z.object({
+	type: z.literal("deleteIdStyle"),
+	targetId: z.string().describe("DOM id whose id rule to remove (without the # prefix)")
+}).describe("Remove the id rule (`#id`) for a single element (the element keeps its own classes).");
+var deleteIdStyle = (space, env, op) => {
+	const guard = guardKind(space.style, op.targetId, "id");
+	if (guard) return guard;
+	for (const mode of MODES) Reflect.deleteProperty(space.style.platform[mode], op.targetId);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [idUri(env, op.targetId), idsUri(env)]
+	};
+};
+//#endregion
+export { deleteIdStyle, deleteIdStyleOp };

package/dist/modules/mcp/tools/operations/style/idStyles/patchIdStyle.js

@@ -0,0 +1,28 @@
+import { idUri, idsUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { idStyleToAI } from "../translator.js";
+import { guardKind, mergePatch, writeStyleItem } from "../write.js";
+import { patchCssShape } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/idStyles/patchIdStyle.ts
+var patchIdStyleOp = z.object({
+	type: z.literal("patchIdStyle"),
+	targetId: z.string().describe("DOM id whose id rule to merge into (without the # prefix)"),
+	...patchCssShape
+}).describe("Partially update the CSS of an id rule (`#id`): CSS is merged (a null value removes a property). Never creates — use upsertIdStyle for that.");
+var patchIdStyle = (space, env, op) => {
+	const guard = guardKind(space.style, op.targetId, "id");
+	if (guard) return guard;
+	const existing = idStyleToAI(space.style, op.targetId);
+	if (!existing) return fail("targetId", `No id rule for "${op.targetId}"`, "patchIdStyle only updates an existing id rule; use upsertIdStyle to create one");
+	const { type, targetId, slots: slotsPatch, ...basePatch } = op;
+	const { base, slots } = mergePatch(existing, basePatch, slotsPatch);
+	writeStyleItem(space.style, targetId, base, slots, "id", void 0);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [idUri(env, targetId), idsUri(env)]
+	};
+};
+//#endregion
+export { patchIdStyle, patchIdStyleOp };

package/dist/modules/mcp/tools/operations/style/idStyles/upsertIdStyle.js

@@ -0,0 +1,24 @@
+import { idUri, idsUri } from "../../../../helpers/uris.js";
+import { empty } from "../../../../helpers/opResult.js";
+import { guardKind, writeStyleItem } from "../write.js";
+import { upsertCssShape } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/idStyles/upsertIdStyle.ts
+var upsertIdStyleOp = z.object({
+	type: z.literal("upsertIdStyle"),
+	targetId: z.string().describe("DOM id of the element to style (without the # prefix); matches its `id` attribute"),
+	...upsertCssShape
+}).describe("Create or fully replace the CSS for a single element addressed by its DOM id (`#id`). The element must carry that `id` attribute. To style by reusable class instead, use upsertDefinition. Use patchIdStyle for a partial change.");
+var upsertIdStyle = (space, env, op) => {
+	const { type, targetId, slots, ...base } = op;
+	const guard = guardKind(space.style, targetId, "id");
+	if (guard) return guard;
+	writeStyleItem(space.style, targetId, base, slots, "id", void 0);
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [idUri(env, targetId), idsUri(env)]
+	};
+};
+//#endregion
+export { upsertIdStyle, upsertIdStyleOp };

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

@@ -0,0 +1,27 @@
+import { deleteDefinitionOp } from "./definitions/deleteDefinition.js";
+import { patchDefinitionOp } from "./definitions/patchDefinition.js";
+import { upsertDefinitionOp } from "./definitions/upsertDefinition.js";
+import { deleteGlobalStyleOp } from "./globalStyles/deleteGlobalStyle.js";
+import { patchGlobalStyleOp } from "./globalStyles/patchGlobalStyle.js";
+import { upsertGlobalStyleOp } from "./globalStyles/upsertGlobalStyle.js";
+import { deleteIdStyleOp } from "./idStyles/deleteIdStyle.js";
+import { patchIdStyleOp } from "./idStyles/patchIdStyle.js";
+import { upsertIdStyleOp } from "./idStyles/upsertIdStyle.js";
+import { deleteStyleVariableOp } from "./variables/deleteStyleVariable.js";
+import { upsertStyleVariableOp } from "./variables/upsertStyleVariable.js";
+//#region src/modules/mcp/tools/operations/style/operations.ts
+var styleOps = {
+	upsertDefinition: upsertDefinitionOp,
+	patchDefinition: patchDefinitionOp,
+	deleteDefinition: deleteDefinitionOp,
+	upsertGlobalStyle: upsertGlobalStyleOp,
+	patchGlobalStyle: patchGlobalStyleOp,
+	deleteGlobalStyle: deleteGlobalStyleOp,
+	upsertIdStyle: upsertIdStyleOp,
+	patchIdStyle: patchIdStyleOp,
+	deleteIdStyle: deleteIdStyleOp,
+	upsertStyleVariable: upsertStyleVariableOp,
+	deleteStyleVariable: deleteStyleVariableOp
+};
+//#endregion
+export { styleOps };

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

@@ -0,0 +1,59 @@
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/shared.ts
+var cssMap = z.record(z.string(), z.union([z.string(), z.number()])).describe("kebab-case CSS props; use var(--name) for tokens and {{name}} for schema vars");
+var displayModeCss = z.object({
+	desktop: cssMap.optional(),
+	tablet: cssMap.optional(),
+	mobile: cssMap.optional()
+});
+var definitionSlot = displayModeCss.extend({
+	states: z.record(z.string(), displayModeCss).optional(),
+	variants: z.record(z.string(), displayModeCss).optional()
+});
+var cssPatchMap = z.record(z.string(), z.union([
+	z.string(),
+	z.number(),
+	z.null()
+])).describe("kebab-case CSS props; a value of null removes the property, others are merged onto the existing CSS");
+var displayModeCssPatch = z.object({
+	desktop: cssPatchMap.optional(),
+	tablet: cssPatchMap.optional(),
+	mobile: cssPatchMap.optional()
+});
+var definitionSlotPatch = displayModeCssPatch.extend({
+	states: z.record(z.string(), displayModeCssPatch).optional(),
+	variants: z.record(z.string(), displayModeCssPatch).optional()
+});
+var styleCategory = z.enum([
+	"color",
+	"spacing",
+	"shadow",
+	"custom"
+]);
+var themeValue = z.union([
+	z.string(),
+	z.number(),
+	z.object({
+		light: z.string().optional(),
+		dark: z.string().optional(),
+		default: z.string().optional()
+	})
+]);
+var upsertCssShape = {
+	desktop: cssMap.optional(),
+	tablet: cssMap.optional(),
+	mobile: cssMap.optional(),
+	states: z.record(z.string(), displayModeCss).optional(),
+	variants: z.record(z.string(), displayModeCss).optional(),
+	slots: z.record(z.string(), definitionSlot).optional()
+};
+var patchCssShape = {
+	desktop: cssPatchMap.optional(),
+	tablet: cssPatchMap.optional(),
+	mobile: cssPatchMap.optional(),
+	states: z.record(z.string(), displayModeCssPatch).optional(),
+	variants: z.record(z.string(), displayModeCssPatch).optional(),
+	slots: z.record(z.string(), definitionSlotPatch).optional()
+};
+//#endregion
+export { displayModeCss, displayModeCssPatch, patchCssShape, styleCategory, themeValue, upsertCssShape };

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

@@ -0,0 +1,101 @@
+//#region src/modules/mcp/tools/operations/style/translator.ts
+var DISPLAY_MODES = [
+	"desktop",
+	"tablet",
+	"mobile"
+];
+var isClassDefinition = (item) => item.type === "class";
+var definitionRefs = (style) => {
+	const refs = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const [name, item] of Object.entries(style.platform[mode])) if (isClassDefinition(item)) refs.add(name);
+	return Array.from(refs).sort();
+};
+var fillSlot = (target, mode, block) => {
+	if (block.default && Object.keys(block.default).length > 0) target[mode] = block.default;
+	if (block.states) {
+		for (const [state, obj] of Object.entries(block.states)) if (Object.keys(obj).length > 0) {
+			(target.states ??= {})[state] ??= {};
+			target.states[state][mode] = obj;
+		}
+	}
+	if (block.variants) {
+		for (const [name, variant] of Object.entries(block.variants)) if (variant.default && Object.keys(variant.default).length > 0) {
+			(target.variants ??= {})[name] ??= {};
+			target.variants[name][mode] = variant.default;
+		}
+	}
+};
+var projectItem = (style, ref, accept) => {
+	const def = { ref };
+	let found = false;
+	for (const mode of DISPLAY_MODES) {
+		const item = style.platform[mode][ref];
+		if (!item || !accept(item)) continue;
+		found = true;
+		for (const [slot, block] of Object.entries(item.attributes)) if (slot === "base") fillSlot(def, mode, block);
+		else fillSlot((def.slots ??= {})[slot] ??= {}, mode, block);
+	}
+	return found ? def : void 0;
+};
+var definitionToAI = (style, ref) => projectItem(style, ref, isClassDefinition);
+var definitionVariantNames = (style, ref) => {
+	const def = definitionToAI(style, ref);
+	if (!def) return;
+	const result = {};
+	const baseVariants = Object.keys(def.variants ?? {});
+	if (baseVariants.length > 0) result.base = baseVariants.sort();
+	for (const [slot, slotDef] of Object.entries(def.slots ?? {})) {
+		const variants = Object.keys(slotDef.variants ?? {});
+		if (variants.length > 0) result[slot] = variants.sort();
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+};
+var globalStylesForType = (style, componentType) => {
+	const isGlobal = (item) => item.type === "element" && item.componentType === componentType;
+	const refs = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const [name, item] of Object.entries(style.platform[mode])) if (isGlobal(item)) refs.add(name);
+	const globals = [];
+	for (const ref of Array.from(refs).sort()) {
+		const def = projectItem(style, ref, isGlobal);
+		if (def) globals.push({
+			...def,
+			appliesToType: componentType
+		});
+	}
+	return globals;
+};
+var globalStyleToAI = (style, componentType) => {
+	const def = projectItem(style, componentType, (item) => item.type === "element" && item.componentType === componentType);
+	return def ? {
+		...def,
+		appliesToType: componentType
+	} : void 0;
+};
+var globalStyleTypes = (style) => {
+	const types = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const item of Object.values(style.platform[mode])) if (item.type === "element" && item.componentType) types.add(item.componentType);
+	return Array.from(types).sort();
+};
+var idStyleIds = (style) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const mode of DISPLAY_MODES) for (const [name, item] of Object.entries(style.platform[mode])) if (item.type === "id") ids.add(name);
+	return Array.from(ids).sort();
+};
+var idStyleToAI = (style, targetId) => {
+	const def = projectItem(style, targetId, (item) => item.type === "id");
+	return def ? {
+		...def,
+		targetId
+	} : void 0;
+};
+var styleVariablesToAI = (style) => {
+	const data = {};
+	for (const [category, group] of Object.entries(style.variables)) data[category] = Object.entries(group).map(([name, value]) => ({
+		name,
+		reference: `var(--${name})`,
+		value
+	}));
+	return data;
+};
+//#endregion
+export { definitionRefs, definitionToAI, definitionVariantNames, globalStyleToAI, globalStyleTypes, globalStylesForType, idStyleIds, idStyleToAI, isClassDefinition, styleVariablesToAI };

package/dist/modules/mcp/tools/operations/style/variables/deleteStyleVariable.js

@@ -0,0 +1,21 @@
+import { styleVarUri, styleVarsUri } from "../../../../helpers/uris.js";
+import { empty } from "../../../../helpers/opResult.js";
+import { styleCategory } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/variables/deleteStyleVariable.ts
+var deleteStyleVariableOp = z.object({
+	type: z.literal("deleteStyleVariable"),
+	category: styleCategory,
+	name: z.string().describe("Token name without the -- prefix")
+}).describe("Delete a design token by category + name.");
+var deleteStyleVariable = (space, env, op) => {
+	const group = space.style.variables[op.category];
+	if (group) Reflect.deleteProperty(group, op.name);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [styleVarUri(env, op.category), styleVarsUri(env)]
+	};
+};
+//#endregion
+export { deleteStyleVariable, deleteStyleVariableOp };

package/dist/modules/mcp/tools/operations/style/variables/upsertStyleVariable.js

@@ -0,0 +1,22 @@
+import { styleVarUri, styleVarsUri } from "../../../../helpers/uris.js";
+import { empty } from "../../../../helpers/opResult.js";
+import { styleCategory, themeValue } from "../shared.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/style/variables/upsertStyleVariable.ts
+var upsertStyleVariableOp = z.object({
+	type: z.literal("upsertStyleVariable"),
+	category: styleCategory,
+	name: z.string().describe("Token name without the -- prefix; referenced in CSS as var(--name)"),
+	value: themeValue
+}).describe("Create or update a design token (referenced in CSS as var(--name); value may differ per light/dark).");
+var upsertStyleVariable = (space, env, op) => {
+	const group = space.style.variables[op.category] ??= {};
+	group[op.name] = op.value;
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [styleVarUri(env, op.category), styleVarsUri(env)]
+	};
+};
+//#endregion
+export { upsertStyleVariable, upsertStyleVariableOp };