@plitzi/sdk-server 0.32.4 → 0.32.6

package/dist/modules/mcp/tools/operations/schema/interactions/deleteInteraction.js

@@ -0,0 +1,52 @@
+import { pageUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { resolveElement } from "../write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/interactions/deleteInteraction.ts
+var deleteInteractionOp = z.object({
+	type: z.literal("deleteInteraction"),
+	pageRef: z.string().describe("Page ref or id"),
+	ref: z.string().describe("Element ref or id"),
+	flowId: z.string().optional().describe("Remove the whole flow with this id (the trigger node id)"),
+	nodeId: z.string().optional().describe("Remove a single step; its neighbors are re-linked. Deleting a trigger removes its flow")
+}).describe("DESTRUCTIVE, not undoable — remove an interaction flow (by flowId) or a single step (by nodeId). Provide exactly one. To merely turn a step OFF without removing it, use patchInteractionNode { enabled: false } instead. Confirm with the user before deleting.");
+var removeFlow = (interactions, flowId) => {
+	let deleted = 0;
+	for (const [nodeId, node] of Object.entries(interactions)) if ((node.flowId || node.id) === flowId) {
+		Reflect.deleteProperty(interactions, nodeId);
+		deleted++;
+	}
+	return deleted;
+};
+var deleteInteraction = (space, env, op) => {
+	if (Boolean(op.flowId) === Boolean(op.nodeId)) return fail("nodeId", "Provide exactly one of flowId or nodeId", "flowId removes a whole flow; nodeId removes a step");
+	const found = resolveElement(space, env, op.pageRef, op.ref);
+	if ("error" in found) return found.error;
+	const interactions = found.el.definition.interactions;
+	if (!interactions) return fail("ref", `Element "${op.ref}" has no interactions`, "Nothing to delete");
+	let deleted = 0;
+	if (op.flowId) deleted = removeFlow(interactions, op.flowId);
+	else if (op.nodeId) {
+		if (!(op.nodeId in interactions)) return fail("nodeId", `Interaction node "${op.nodeId}" not found on "${op.ref}"`, "Read the element to list nodes");
+		const node = interactions[op.nodeId];
+		if (node.type === "trigger") deleted = removeFlow(interactions, node.flowId || node.id);
+		else {
+			const before = node.beforeNode ? interactions[node.beforeNode] : void 0;
+			const after = node.afterNode ? interactions[node.afterNode] : void 0;
+			if (before) before.afterNode = node.afterNode;
+			if (after) after.beforeNode = node.beforeNode;
+			Reflect.deleteProperty(interactions, op.nodeId);
+			deleted = 1;
+		}
+	}
+	if (deleted === 0) return fail("flowId", `No interaction matching "${op.flowId ?? op.nodeId}" on "${op.ref}"`, "Nothing to delete");
+	if (Object.keys(interactions).length === 0) Reflect.deleteProperty(found.el.definition, "interactions");
+	return {
+		...empty(),
+		deleted,
+		staleResources: [pageUri(env, op.pageRef)],
+		elementRefs: [op.ref]
+	};
+};
+//#endregion
+export { deleteInteraction, deleteInteractionOp };

package/dist/modules/mcp/tools/operations/schema/interactions/patchInteractionNode.js

@@ -0,0 +1,47 @@
+import { pageUri } from "../../../../helpers/uris.js";
+import { NULLISH_ELEMENT_IDS } from "../../../../helpers/interactions.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { interactionNode } from "../shared.js";
+import { resolveElement, resolveTargetRef } from "../write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/interactions/patchInteractionNode.ts
+var { title, action, params, enabled, when, elementId, preview } = interactionNode.shape;
+var patchInteractionNodeOp = z.object({
+	type: z.literal("patchInteractionNode"),
+	pageRef: z.string().describe("Page ref or id"),
+	ref: z.string().describe("Element ref or id"),
+	nodeId: z.string().describe("Id of the interaction node to update"),
+	title: title.optional(),
+	action: action.optional(),
+	params: params.describe("Merged onto the node params: listed keys change, others are preserved"),
+	enabled,
+	when,
+	elementId,
+	preview
+}).describe("Partially update ONE step of an interaction flow (found by nodeId): only the fields you pass change; the flow order/links are untouched. This is how you DISABLE/deactivate a step without removing it: pass { enabled: false } (re-enable with { enabled: true }) — the step stays in the flow. Use deleteInteraction only to actually remove a step or a flow. Fails if the node does not exist.");
+var patchInteractionNode = (space, env, op) => {
+	const found = resolveElement(space, env, op.pageRef, op.ref);
+	if ("error" in found) return found.error;
+	const node = found.el.definition.interactions?.[op.nodeId];
+	if (!node) return fail("nodeId", `Interaction node "${op.nodeId}" not found on "${op.ref}"`, "Read the element to list nodes");
+	if (op.title !== void 0) node.title = op.title;
+	if (op.action !== void 0) node.action = op.action;
+	if (op.params !== void 0) node.params = {
+		...node.params,
+		...op.params
+	};
+	if (op.enabled !== void 0) node.enabled = op.enabled;
+	if (op.when !== void 0) node.when = op.when;
+	if (op.elementId !== void 0) node.elementId = resolveTargetRef(space, op.elementId);
+	if (node.type === "utility") node.elementId = null;
+	else if (typeof node.elementId === "string" && NULLISH_ELEMENT_IDS.has(node.elementId)) node.elementId = null;
+	if (op.preview !== void 0) node.preview = op.preview;
+	return {
+		...empty(),
+		updated: 1,
+		staleResources: [pageUri(env, op.pageRef)],
+		elementRefs: [op.ref]
+	};
+};
+//#endregion
+export { patchInteractionNode, patchInteractionNodeOp };

package/dist/modules/mcp/tools/operations/schema/interactions/upsertInteractionFlow.js

@@ -0,0 +1,43 @@
+import { pageUri } from "../../../../helpers/uris.js";
+import { materializeFlow } from "../../../../helpers/interactions.js";
+import { empty } from "../../../../helpers/opResult.js";
+import { interactionNode } from "../shared.js";
+import { ensureIdRef, resolveElement, resolveTargetRef } from "../write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/interactions/upsertInteractionFlow.ts
+var upsertInteractionFlowOp = z.object({
+	type: z.literal("upsertInteractionFlow"),
+	pageRef: z.string().describe("Page ref or id"),
+	ref: z.string().describe("Element ref or id"),
+	flowId: z.string().optional().describe("Existing flow to replace (the trigger node id). Omit to create a new flow"),
+	nodes: z.array(interactionNode).min(1).describe("Ordered steps of the flow: the FIRST must be a trigger, the rest run after it in order")
+}).describe("Create or replace one interaction flow on an element from an ordered list of steps. The stored beforeNode/afterNode/flowId links are computed for you — pass the steps in execution order. For a globalCallback (addNotification, setState, navigate, auth*, *CollectionRecord) OMIT elementId: it is registered on a source module, not the host element, and the MCP sets the right source and fills the default param values for you. To edit a single step in place use patchInteractionNode.");
+var upsertInteractionFlow = (space, env, op) => {
+	const found = resolveElement(space, env, op.pageRef, op.ref);
+	if ("error" in found) return found.error;
+	const ownerRef = ensureIdRef(space, found.el);
+	const { flowId, record } = materializeFlow((op.flowId && !op.nodes[0].id ? [{
+		...op.nodes[0],
+		id: op.flowId
+	}, ...op.nodes.slice(1)] : op.nodes).map((node) => node.elementId === void 0 || node.nodeType === "utility" ? node : {
+		...node,
+		elementId: resolveTargetRef(space, node.elementId)
+	}), ownerRef);
+	const interactions = found.el.definition.interactions ?? {};
+	const targetFlow = op.flowId ?? flowId;
+	let replaced = false;
+	for (const [nodeId, node] of Object.entries(interactions)) if ((node.flowId || node.id) === targetFlow) {
+		Reflect.deleteProperty(interactions, nodeId);
+		replaced = true;
+	}
+	Object.assign(interactions, record);
+	found.el.definition.interactions = interactions;
+	return {
+		...empty(),
+		...replaced ? { updated: 1 } : { created: 1 },
+		staleResources: [pageUri(env, op.pageRef)],
+		elementRefs: [op.ref]
+	};
+};
+//#endregion
+export { upsertInteractionFlow, upsertInteractionFlowOp };

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

@@ -0,0 +1,39 @@
+import { deleteBindingOp } from "./bindings/deleteBinding.js";
+import { patchBindingOp } from "./bindings/patchBinding.js";
+import { upsertBindingOp } from "./bindings/upsertBinding.js";
+import { deleteElementOp } from "./elements/deleteElement.js";
+import { moveElementOp } from "./elements/moveElement.js";
+import { patchElementOp } from "./elements/patchElement.js";
+import { upsertElementOp } from "./elements/upsertElement.js";
+import { deleteFolderOp } from "./folders/deleteFolder.js";
+import { upsertFolderOp } from "./folders/upsertFolder.js";
+import { deleteInteractionOp } from "./interactions/deleteInteraction.js";
+import { patchInteractionNodeOp } from "./interactions/patchInteractionNode.js";
+import { upsertInteractionFlowOp } from "./interactions/upsertInteractionFlow.js";
+import { deletePageOp } from "./pages/deletePage.js";
+import { upsertPageOp } from "./pages/upsertPage.js";
+import { patchSettingsOp } from "./settings/patchSettings.js";
+import { deleteVariableOp } from "./variables/deleteVariable.js";
+import { upsertVariableOp } from "./variables/upsertVariable.js";
+//#region src/modules/mcp/tools/operations/schema/operations.ts
+var elementOps = {
+	upsertElement: upsertElementOp,
+	patchElement: patchElementOp,
+	deleteElement: deleteElementOp,
+	moveElement: moveElementOp,
+	upsertPage: upsertPageOp,
+	deletePage: deletePageOp,
+	upsertFolder: upsertFolderOp,
+	deleteFolder: deleteFolderOp,
+	upsertVariable: upsertVariableOp,
+	deleteVariable: deleteVariableOp,
+	upsertBinding: upsertBindingOp,
+	patchBinding: patchBindingOp,
+	deleteBinding: deleteBindingOp,
+	upsertInteractionFlow: upsertInteractionFlowOp,
+	patchInteractionNode: patchInteractionNodeOp,
+	deleteInteraction: deleteInteractionOp,
+	patchSettings: patchSettingsOp
+};
+//#endregion
+export { elementOps };

package/dist/modules/mcp/tools/operations/schema/pages/deletePage.js

@@ -0,0 +1,25 @@
+import { descendantIds, findPageByRef, indexRemovePage } from "../../../../helpers/space.js";
+import { pageUri, pagesUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/pages/deletePage.ts
+var deletePageOp = z.object({
+	type: z.literal("deletePage"),
+	ref: z.string().describe("Page ref or id")
+}).describe("Delete a page and every element on it.");
+var deletePage = (space, env, op) => {
+	const page = findPageByRef(space.schema, op.ref);
+	if (!page) return fail("ref", `Page "${op.ref}" not found`, "Read the pages resource for valid refs");
+	const descendantElementIds = descendantIds(space.schema, page.id);
+	const descendants = descendantElementIds.map((id) => space.schema.flat[id]);
+	for (const id of [...descendantElementIds, page.id]) Reflect.deleteProperty(space.schema.flat, id);
+	space.schema.pages = space.schema.pages.filter((id) => id !== page.id);
+	indexRemovePage(space.schema, page, descendants);
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [pageUri(env, op.ref), pagesUri(env)]
+	};
+};
+//#endregion
+export { deletePage, deletePageOp };

package/dist/modules/mcp/tools/operations/schema/pages/upsertPage.js

@@ -0,0 +1,75 @@
+import { findFolderByRef, findPageByRef, generateObjectId, indexAddPage, indexReRefPage, pageRefOf } from "../../../../helpers/space.js";
+import { pageUri, pagesUri } from "../../../../helpers/uris.js";
+import { empty, fail } from "../../../../helpers/opResult.js";
+import { guardNewRef } from "../write.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/schema/pages/upsertPage.ts
+var upsertPageOp = z.object({
+	type: z.literal("upsertPage"),
+	ref: z.string().describe("Page id/slug to update, or a new id you choose to create one. On a new page it is stored as its idRef: starts with a letter, then letters, numbers, hyphens and underscores (\"pricing\"), unique across the space."),
+	label: z.string().optional(),
+	slug: z.string().optional().describe("The page URL path, RELATIVE — do NOT start it with \"/\" (the runtime and any parent folder slugs prepend the path; a leading \"/\" is stripped). Good practice: always set one on create for a clean, stable route, e.g. \"pricing\" or \"posts/:postId\" (a \":name\" segment is a route param, readable as {{name}} and as the source navigation.routeParams.name). Omitted on create → the page ref is used as the slug."),
+	folder: z.string().nullable().optional().describe("Ref of an existing folder to place this page in; \"\" or null moves it to the root. Unknown → error"),
+	default: z.boolean().optional(),
+	enabled: z.boolean().optional().describe("false disables the page in the published SDK runtime (not routable/accessible to end users); it stays editable here. Defaults to true")
+}).describe("Create a page, or update it when ref already exists (only the fields you pass change).");
+var upsertPage = (space, env, op) => {
+	const slug = op.slug === void 0 ? void 0 : op.slug.replace(/^\/+/, "");
+	let folderValue;
+	if (op.folder !== void 0) if (op.folder === null || op.folder === "") folderValue = "";
+	else {
+		const resolved = findFolderByRef(space.schema, op.folder);
+		if (!resolved) return fail("folder", `Folder "${op.folder}" not found`, "Create it with upsertFolder, or read plitzi://folders");
+		folderValue = resolved.id;
+	}
+	const existing = findPageByRef(space.schema, op.ref);
+	if (existing) {
+		const oldRef = pageRefOf(existing);
+		existing.attributes = {
+			...existing.attributes,
+			...slug !== void 0 ? { slug } : {},
+			...op.label !== void 0 ? { name: op.label } : {},
+			...op.default !== void 0 ? { default: op.default } : {},
+			...op.enabled !== void 0 ? { enabled: op.enabled } : {},
+			...folderValue !== void 0 ? { folder: folderValue } : {}
+		};
+		indexReRefPage(space.schema, existing, oldRef);
+		return {
+			...empty(),
+			updated: 1,
+			staleResources: [pageUri(env, op.ref), pagesUri(env)]
+		};
+	}
+	const guard = guardNewRef(space, op.ref, "ref");
+	if (guard) return guard;
+	const id = generateObjectId();
+	const attributes = {
+		slug: slug ?? op.ref,
+		name: op.label ?? op.ref,
+		default: op.default ?? false,
+		enabled: op.enabled ?? true,
+		folder: folderValue ?? ""
+	};
+	const page = {
+		id,
+		idRef: op.ref,
+		attributes,
+		definition: {
+			rootId: id,
+			label: op.label ?? op.ref,
+			type: "page",
+			items: [],
+			styleSelectors: { base: "" }
+		}
+	};
+	space.schema.flat[id] = page;
+	space.schema.pages.push(id);
+	indexAddPage(space.schema, page);
+	return {
+		...empty(),
+		created: 1,
+		staleResources: [pageUri(env, op.ref), pagesUri(env)]
+	};
+};
+//#endregion
+export { upsertPage, upsertPageOp };

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

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

@@ -0,0 +1,119 @@
+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 elementInput = z.lazy(() => z.object({
+	ref: z.string().describe("Semantic id you choose, or an existing element ref/id. On a new element this is stored as its idRef and becomes the key everything else addresses it by — its data source is named `<type>_<ref>`, and an interaction targets it by this ref. Start with a letter, then letters, numbers, hyphens and underscores (\"hero-cta\" or \"food_item\"): a dot would break the `<type>_<idRef>.<field>` grammar (an underscore is fine — the first `_` separates the type from the idRef). Must be 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)"),
+	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. Give its ref or its raw id — a raw id is normalised to the element idRef the runtime looks callbacks up by, and a target without an idRef is given one automatically."),
+	preview: z.record(z.string(), z.unknown()).optional()
+});
+//#endregion
+export { bindingCategory, bindingInput, elementInput, initialStateInput, interactionNode, interactionNodeType, position, ruleGroup, scalar, styleRefs, styleVariantInput };

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

@@ -0,0 +1,215 @@
+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 };