@plitzi/sdk-server 0.32.5 → 0.32.6

package/dist/modules/mcp/helpers/space.js

@@ -1,20 +1,158 @@
 //#region src/modules/mcp/helpers/space.ts
-var cloneSpace = (space) => structuredClone(space);
+var cloneSpace = (space) => ({
+	schema: structuredClone(space.schema),
+	style: structuredClone(space.style),
+	...space.catalog ? { catalog: space.catalog } : {}
+});
 var slugify = (value) => value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "";
-var isPageElement = (schema, el) => schema.pages.includes(el.id) || el.definition.type === "page";
-var getPageElements = (schema) => Object.values(schema.flat).filter((el) => isPageElement(schema, el));
-/** Stable, human-readable ref for a page. Prefers an agent-chosen aiRef, then slug, then a slugified label. */
+/** A value when it is a string, otherwise undefined — for the many attributes typed as `unknown` that are strings
+*  in practice (name, slug, subType, dom id…). */
+var strOr = (value) => typeof value === "string" ? value : void 0;
+/** Display name of a page or element: its `name` attribute when set, otherwise its definition label. */
+var nameOf = (el) => strOr(el.attributes.name) ?? el.definition.label;
+/** Stable, human-readable ref for a page: its idRef, then slug, then a slugified label. A page without an idRef is
+*  still addressable — unlike a data source, a page ref has meaningful fallbacks the agent can read off the tree. */
 var pageRefOf = (el) => {
-	if (el.definition.aiRef) return el.definition.aiRef;
-	const slug = typeof el.attributes.slug === "string" ? el.attributes.slug.trim() : "";
+	if (el.idRef) return el.idRef;
+	const slug = strOr(el.attributes.slug)?.trim();
 	if (slug) return slugify(slug);
 	if (el.attributes.default === true) return "home";
-	return slugify(typeof el.attributes.name === "string" ? el.attributes.name : el.definition.label) || el.id;
+	return slugify(nameOf(el)) || el.id;
 };
-/** Stable ref for a non-page element. An agent-chosen aiRef when present, otherwise the opaque id. */
-var elementRefOf = (el) => el.definition.aiRef ?? el.id;
-/** Finds a page by its semantic ref (aiRef/slug/…) or its raw id, so legacy schemas without an aiRef still resolve. */
-var findPageByRef = (schema, pageRef) => getPageElements(schema).find((el) => pageRefOf(el) === pageRef || el.id === pageRef);
+/** Stable ref for ADDRESSING a non-page element in the tree: its idRef when present, otherwise the opaque id so an
+*  element without one is still reachable — the agent needs to name it to give it an idRef in the first place.
+*  This is not the wiring key: the runtime wires interactions and data sources by idRef only, so an element
+*  addressed here by its id alone publishes no source and takes no interactions (see `getSourceName`). */
+var elementRefOf = (el) => el.idRef ?? el.id;
+var buildIndex = (schema) => {
+	const flat = schema.flat;
+	const lookup = (id) => flat[id];
+	const pageIds = new Set(schema.pages);
+	for (const el of Object.values(flat)) if (el.definition.type === "page") pageIds.add(el.id);
+	const pageElements = [];
+	const pageByRef = /* @__PURE__ */ new Map();
+	const elementByRef = /* @__PURE__ */ new Map();
+	for (const el of Object.values(flat)) if (pageIds.has(el.id)) {
+		pageElements.push(el);
+		const ref = pageRefOf(el);
+		if (!pageByRef.has(ref)) pageByRef.set(ref, el);
+		if (!pageByRef.has(el.id)) pageByRef.set(el.id, el);
+	} else {
+		const ref = elementRefOf(el);
+		if (!elementByRef.has(ref)) elementByRef.set(ref, el);
+		if (!elementByRef.has(el.id)) elementByRef.set(el.id, el);
+	}
+	const pageOf = /* @__PURE__ */ new Map();
+	for (const page of pageElements) {
+		pageOf.set(page.id, page.id);
+		const stack = [...page.definition.items ?? []];
+		while (stack.length > 0) {
+			const id = stack.pop();
+			if (id === void 0 || pageOf.has(id)) continue;
+			const el = lookup(id);
+			if (!el) continue;
+			pageOf.set(id, page.id);
+			for (const childId of el.definition.items ?? []) stack.push(childId);
+		}
+	}
+	return {
+		pageIds,
+		pageElements,
+		pageByRef,
+		elementByRef,
+		pageOf,
+		detailCache: /* @__PURE__ */ new Map()
+	};
+};
+var indexCache = /* @__PURE__ */ new WeakMap();
+/** The index for a schema, built once and memoized on the schema object. */
+var spaceIndex = (schema) => {
+	let index = indexCache.get(schema);
+	if (!index) {
+		index = buildIndex(schema);
+		indexCache.set(schema, index);
+	}
+	return index;
+};
+var cachedIndex = (schema) => indexCache.get(schema);
+/** A new non-page element was created under `pageId`. */
+var indexAddElement = (schema, el, pageId) => {
+	const index = cachedIndex(schema);
+	if (!index) return;
+	index.elementByRef.set(el.id, el);
+	if (el.idRef) index.elementByRef.set(el.idRef, el);
+	index.pageOf.set(el.id, pageId);
+	index.detailCache.clear();
+};
+/** These non-page elements were deleted (an element and its descendants). */
+var indexRemoveElements = (schema, els) => {
+	const index = cachedIndex(schema);
+	if (!index) return;
+	for (const el of els) {
+		index.elementByRef.delete(el.id);
+		if (el.idRef) index.elementByRef.delete(el.idRef);
+		index.pageOf.delete(el.id);
+	}
+	index.detailCache.clear();
+};
+/** An existing element was just given an idRef (it had none), so it becomes addressable by that ref. */
+var indexReRefElement = (schema, el) => {
+	const index = cachedIndex(schema);
+	if (!index) return;
+	if (el.idRef) index.elementByRef.set(el.idRef, el);
+	index.detailCache.clear();
+};
+/** A new page element was created. */
+var indexAddPage = (schema, page) => {
+	const index = cachedIndex(schema);
+	if (!index) return;
+	index.pageIds.add(page.id);
+	index.pageElements.push(page);
+	index.pageByRef.set(page.id, page);
+	index.pageByRef.set(pageRefOf(page), page);
+	index.pageOf.set(page.id, page.id);
+	index.detailCache.clear();
+};
+/** A page and its `descendants` (its non-page elements) were deleted. */
+var indexRemovePage = (schema, page, descendants) => {
+	const index = cachedIndex(schema);
+	if (!index) return;
+	index.pageIds.delete(page.id);
+	const at = index.pageElements.findIndex((p) => p.id === page.id);
+	if (at >= 0) index.pageElements.splice(at, 1);
+	index.pageByRef.delete(page.id);
+	index.pageByRef.delete(pageRefOf(page));
+	index.pageOf.delete(page.id);
+	for (const el of descendants) {
+		index.elementByRef.delete(el.id);
+		if (el.idRef) index.elementByRef.delete(el.idRef);
+		index.pageOf.delete(el.id);
+	}
+	index.detailCache.clear();
+};
+/** A page's slug/name/default changed; re-key its pageByRef entry if that changed its ref. `oldRef` is the ref
+*  computed BEFORE the attribute change. */
+var indexReRefPage = (schema, page, oldRef) => {
+	const index = cachedIndex(schema);
+	if (!index) return;
+	const newRef = pageRefOf(page);
+	if (newRef !== oldRef) {
+		index.pageByRef.delete(oldRef);
+		index.pageByRef.set(newRef, page);
+		index.detailCache.clear();
+	}
+};
+/** A move reparented an element within its page: the ref/page maps are unchanged, but the moved element's
+*  parentRef and both parents' childRefs did change, so their memoized detail must be dropped. */
+var indexInvalidateDetails = (schema) => {
+	cachedIndex(schema)?.detailCache.clear();
+};
+var isPageElement = (schema, el) => spaceIndex(schema).pageIds.has(el.id) || el.definition.type === "page";
+var getPageElements = (schema) => spaceIndex(schema).pageElements;
+/** Finds a page by its semantic ref (idRef/slug/…) or its raw id, so legacy schemas without an idRef still resolve. */
+var findPageByRef = (schema, pageRef) => spaceIndex(schema).pageByRef.get(pageRef);
+/** Find any non-page element by its semantic ref (idRef) or raw id, across the whole space. */
+var findElementByRef = (schema, ref) => spaceIndex(schema).elementByRef.get(ref);
 var pageFoldersOf = (schema) => {
 	schema.pageFolders ??= [];
 	return schema.pageFolders;
@@ -96,35 +234,22 @@ var descendantIds = (schema, pageRootId) => {
 	return acc;
 };
 /** Resolve a ref to a concrete element within a page subtree (or the page root itself). Accepts either the
-*  semantic ref (aiRef) or the raw element id, so schemas predating aiRef keep working through their ids. */
+*  semantic ref (idRef) or the raw element id, so schemas predating idRef keep working through their ids. */
 var resolveRef = (schema, page, ref) => {
 	if (elementRefOf(page) === ref || pageRefOf(page) === ref || page.id === ref) return page;
-	for (const id of descendantIds(schema, page.id)) {
-		const el = elementById(schema, id);
-		if (el && (elementRefOf(el) === ref || el.id === ref)) return el;
-	}
+	const index = spaceIndex(schema);
+	const el = index.elementByRef.get(ref);
+	return el && index.pageOf.get(el.id) === page.id ? el : void 0;
 };
 /** Ordered children of an element, honoring definition.items and skipping dangling ids. */
 var orderedChildren = (schema, el) => {
 	return (el.definition.items ?? []).map((id) => schema.flat[id]).filter((child) => Boolean(child));
 };
-/** The page ref an element belongs to, walking up parents. 'unknown' when it has no page ancestor. */
+/** The page ref an element belongs to. 'unknown' when it has no page ancestor. */
 var pageRefOfElement = (schema, el) => {
-	let current = el;
-	const guard = /* @__PURE__ */ new Set();
-	while (current && !guard.has(current.id)) {
-		guard.add(current.id);
-		if (isPageElement(schema, current)) return pageRefOf(current);
-		current = current.definition.parentId ? schema.flat[current.definition.parentId] : void 0;
-	}
-	return "unknown";
-};
-/** Find any non-page element by its semantic ref (aiRef) or raw id, across the whole space. */
-var findElementByRef = (schema, ref) => {
-	for (const el of Object.values(schema.flat)) {
-		if (isPageElement(schema, el)) continue;
-		if (elementRefOf(el) === ref || el.id === ref) return el;
-	}
+	const pageId = spaceIndex(schema).pageOf.get(el.id);
+	const page = pageId ? schema.flat[pageId] : void 0;
+	return page ? pageRefOf(page) : "unknown";
 };
 /** Total number of descendant elements under a subtree (excluding the root). */
 var descendantCount = (schema, rootId) => descendantIds(schema, rootId).length;
@@ -134,4 +259,4 @@ var generateObjectId = () => {
 	return `${Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0")}${Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("")}`;
 };
 //#endregion
-export { cloneSpace, descendantCount, descendantIds, elementById, elementRefOf, emptySpaceMessage, findElementByRef, findFolderByRef, findPageByRef, folderAncestorIds, generateObjectId, getPageElements, isPageElement, orderedChildren, pageFoldersOf, pageRefOf, pageRefOfElement, resolveRef, routeParamNames, slugRouteParams, slugify, sortFolders, unauthorizedSpaceMessage };
+export { cloneSpace, descendantCount, descendantIds, elementById, elementRefOf, emptySpaceMessage, findElementByRef, findFolderByRef, findPageByRef, folderAncestorIds, generateObjectId, getPageElements, indexAddElement, indexAddPage, indexInvalidateDetails, indexReRefElement, indexReRefPage, indexRemoveElements, indexRemovePage, isPageElement, nameOf, orderedChildren, pageFoldersOf, pageRefOf, pageRefOfElement, resolveRef, routeParamNames, slugRouteParams, slugify, sortFolders, spaceIndex, strOr, unauthorizedSpaceMessage };

package/dist/modules/mcp/helpers/uris.js

@@ -0,0 +1,44 @@
+//#region src/modules/mcp/helpers/uris.ts
+var guideUri = "plitzi://guide";
+var typesUri = "plitzi://types";
+var cssPropertiesUri = "plitzi://css-properties";
+var primerUri = (env) => `plitzi://primer/${env}`;
+var pagesUri = (env) => `plitzi://schema/${env}/pages`;
+var pageUri = (env, ref) => `plitzi://schema/${env}/pages/${ref}`;
+var elementUri = (env, ref) => `plitzi://schema/${env}/elements/${ref}`;
+var schemaVarsUri = (env) => `plitzi://schema-variables/${env}`;
+var settingsUri = (env) => `plitzi://settings/${env}`;
+var interactionsUri = (env) => `plitzi://interactions/${env}`;
+var dataSourcesUri = (env) => `plitzi://data-sources/${env}`;
+var foldersUri = (env) => `plitzi://folders/${env}`;
+var folderUri = (env, ref) => `plitzi://folders/${env}/${ref}`;
+var defsUri = (env) => `plitzi://definitions/${env}`;
+var defUri = (env, ref) => `plitzi://definitions/${env}/${ref}`;
+var globalsUri = (env) => `plitzi://global-styles/${env}`;
+var globalUri = (env, componentType) => `plitzi://global-styles/${env}/${componentType}`;
+var idsUri = (env) => `plitzi://id-styles/${env}`;
+var idUri = (env, targetId) => `plitzi://id-styles/${env}/${targetId}`;
+var styleVarsUri = (env) => `plitzi://style-variables/${env}`;
+var styleVarUri = (env, category) => `plitzi://style-variables/${env}/${category}`;
+var aliasedRoots = [
+	"definitions",
+	"global-styles",
+	"id-styles",
+	"style-variables",
+	"schema-variables",
+	"folders"
+];
+var itemTemplates = (env) => [
+	pageUri(env, "{ref}"),
+	elementUri(env, "{ref}"),
+	defUri(env, "{ref}"),
+	globalUri(env, "{componentType}"),
+	idUri(env, "{targetId}"),
+	styleVarUri(env, "{category}"),
+	folderUri(env, "{ref}")
+];
+/** The remainder of `uri` after `prefix`, or undefined when it does not start with it — so a resolver matches a
+*  family and extracts its ref in one step, without repeating the prefix string for both the startsWith and slice. */
+var afterPrefix = (uri, prefix) => uri.startsWith(prefix) ? uri.slice(prefix.length) : void 0;
+//#endregion
+export { afterPrefix, aliasedRoots, cssPropertiesUri, dataSourcesUri, defUri, defsUri, elementUri, folderUri, foldersUri, globalUri, globalsUri, guideUri, idUri, idsUri, interactionsUri, itemTemplates, pageUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarUri, styleVarsUri, typesUri };

package/dist/modules/mcp/resources/canonical.js

@@ -1,29 +1,14 @@
+import { afterPrefix, aliasedRoots, itemTemplates, primerUri } from "../helpers/uris.js";
 //#region src/modules/mcp/resources/canonical.ts
-var ALIASED_ROOTS = [
-	"definitions",
-	"global-styles",
-	"style-variables",
-	"schema-variables",
-	"folders"
-];
 var canonicalUri = (env, uri) => {
-	const aliasPrefix = `plitzi://schema/${env}/`;
-	if (!uri.startsWith(aliasPrefix)) return uri;
-	const rest = uri.slice(aliasPrefix.length);
-	for (const root of ALIASED_ROOTS) {
+	const rest = afterPrefix(uri, `plitzi://schema/${env}/`);
+	if (rest === void 0) return uri;
+	for (const root of aliasedRoots) {
 		if (rest === root) return `plitzi://${root}/${env}`;
 		if (rest.startsWith(`${root}/`)) return `plitzi://${root}/${env}/${rest.slice(root.length + 1)}`;
 	}
 	return uri;
 };
-var itemTemplates = (env) => [
-	`plitzi://schema/${env}/pages/{ref}`,
-	`plitzi://schema/${env}/elements/{ref}`,
-	`plitzi://definitions/${env}/{ref}`,
-	`plitzi://global-styles/${env}/{componentType}`,
-	`plitzi://style-variables/${env}/{category}`,
-	`plitzi://folders/${env}/{ref}`
-];
 /** Teachable message for a URI that read as null. Distinguishes a well-formed URI whose ref does not resolve (the
 *  resource may be stale/deleted) from a URI whose shape matches no template at all (malformed — echo the valid
 *  templates so the agent stops hand-building URIs). See RFC 0004 I2. */
@@ -38,8 +23,8 @@ var resourceErrorMessage = (env, uri) => {
 		error: "MALFORMED_URI",
 		message: `'${uri}' matches no resource template.`,
 		hint: "Do not hand-build element URIs — take the ready-made uri from plitzi_search or a write response.",
-		validTemplates: [`plitzi://primer/${env}`, ...itemTemplates(env)]
+		validTemplates: [primerUri(env), ...itemTemplates(env)]
 	});
 };
 //#endregion
-export { canonicalUri, itemTemplates, resourceErrorMessage };
+export { canonicalUri, resourceErrorMessage };

package/dist/modules/mcp/resources/core.js

@@ -1,13 +1,14 @@
+import { cssProperties } from "../catalogs/cssCatalog.js";
+import { buildTypeRegistry } from "../catalogs/registry.js";
+import "../helpers/uris.js";
 import { guideText } from "../helpers/guide.js";
 import { envelope } from "./envelope.js";
-import { cssProperties } from "../tools/operations/style/cssCatalog.js";
-import { buildTypeRegistry } from "../tools/operations/schema/registry.js";
 //#region src/modules/mcp/resources/core.ts
 /** Space-independent singletons: the usage guide, the observed type registry and the CSS property catalog.
 *  Returns undefined when the URI is not one of these, so the router falls through to the next resolver. */
 var readCoreResource = (space, uri) => {
 	if (uri === "plitzi://guide") return envelope(guideText);
-	if (uri === "plitzi://types") return envelope(buildTypeRegistry(space.schema));
+	if (uri === "plitzi://types") return envelope(buildTypeRegistry(space.schema, space.catalog));
 	if (uri === "plitzi://css-properties") return envelope(cssProperties);
 };
 //#endregion

package/dist/modules/mcp/resources/primer.js

@@ -1,24 +1,29 @@
-import { guideText } from "../helpers/guide.js";
+import { cssProperties } from "../catalogs/cssCatalog.js";
+import { buildDataSourceCatalog, buildInteractionCatalog } from "../catalogs/observed.js";
+import { buildTypeRegistry } from "../catalogs/registry.js";
+import { guideQuickstart } from "../helpers/guide.js";
 import { envelope } from "./envelope.js";
-import { cssProperties } from "../tools/operations/style/cssCatalog.js";
-import { buildTypeRegistry } from "../tools/operations/schema/registry.js";
 import { definitionRefs, styleVariablesToAI } from "../tools/operations/style/translator.js";
-import { foldersToAI, pageSummariesToAI, schemaVariablesToAI } from "../tools/operations/schema/translator.js";
+import { foldersToAI, pageSummariesToAI, schemaVariablesToAI, settingsToAI } from "../tools/operations/schema/translator.js";
 //#region src/modules/mcp/resources/primer.ts
 /** The cold-start bundle: everything the guide says to read before the first write, in one round-trip.
 *  Summaries only — never full page/element trees (those are opened on demand), so it stays cheap even on a
-*  large space. Returns undefined when the URI is not the primer. */
+*  large space. Carries the condensed `guideQuickstart` (not the full guideText, which the agent reads on demand at
+*  plitzi://guide) to keep the bundle small. Returns undefined when the URI is not the primer. */
 var readPrimerResource = (space, env, uri) => {
 	if (uri !== `plitzi://primer/${env}`) return;
 	return envelope({
-		guide: guideText,
-		types: buildTypeRegistry(space.schema),
+		guide: guideQuickstart,
+		types: buildTypeRegistry(space.schema, space.catalog),
 		cssProperties,
 		pages: pageSummariesToAI(space.schema),
 		folders: foldersToAI(space.schema),
 		definitions: definitionRefs(space.style),
 		styleVariables: styleVariablesToAI(space.style),
-		schemaVariables: schemaVariablesToAI(space.schema, false)
+		schemaVariables: schemaVariablesToAI(space.schema, false),
+		settings: settingsToAI(space.schema),
+		interactions: buildInteractionCatalog(space.schema),
+		dataSources: buildDataSourceCatalog(space.schema)
 	});
 };
 //#endregion

package/dist/modules/mcp/resources/register.js

@@ -1,17 +1,24 @@
+import { cssProperties } from "../catalogs/cssCatalog.js";
 import { guideText } from "../helpers/guide.js";
 import { resourceErrorMessage } from "./canonical.js";
 import { envelope, jsonContents } from "./envelope.js";
-import { cssProperties } from "../tools/operations/style/cssCatalog.js";
 import { readResource } from "./router.js";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp";
 //#region src/modules/mcp/resources/register.ts
 /** Register every resource on the MCP server: fixed listings plus templated per-item reads. The space is
 *  loaded lazily via getSpace, so listing resources never touches the store — only reading one does. */
-var registerResources = (server, getSpace, env) => {
+var registerResources = (server, getSpace, env, log) => {
 	const emit = async (uri) => {
-		const result = readResource(await getSpace(), env, uri);
-		if (!result) throw new Error(resourceErrorMessage(env, uri));
-		return jsonContents(uri, result);
+		const start = performance.now();
+		try {
+			const result = readResource(await getSpace(), env, uri);
+			if (!result) throw new Error(resourceErrorMessage(env, uri));
+			log.resourceRead(uri, performance.now() - start);
+			return jsonContents(uri, result);
+		} catch (error) {
+			log.resourceRead(uri, performance.now() - start, error);
+			throw error;
+		}
 	};
 	server.registerResource("Guide", "plitzi://guide", {
 		description: "How to read and write this space with mcp-ai",
@@ -56,6 +63,11 @@ var registerResources = (server, getSpace, env) => {
 			`plitzi://global-styles/${env}`,
 			"Element types that have a site-wide global style"
 		],
+		[
+			"Id styles",
+			`plitzi://id-styles/${env}`,
+			"DOM ids that have an id rule (#id) targeting a single element"
+		],
 		[
 			"Style variables",
 			`plitzi://style-variables/${env}`,
@@ -66,6 +78,21 @@ var registerResources = (server, getSpace, env) => {
 			`plitzi://schema-variables/${env}`,
 			"Space-level values referenced via {{name}}"
 		],
+		[
+			"Settings",
+			`plitzi://settings/${env}`,
+			"Space-level settings: global customCss and state/auth configuration"
+		],
+		[
+			"Interactions catalog",
+			`plitzi://interactions/${env}`,
+			"Interaction actions (observed, grouped by node type) plus the built-in vocabularies — globalCallbacks (with their source module), element callbacks and utilities — each with its full param schema, the vocabulary for upsertInteractionFlow"
+		],
+		[
+			"Data sources catalog",
+			`plitzi://data-sources/${env}`,
+			"Data-source paths and binding targets observed in this space — the vocabulary for upsertBinding"
+		],
 		[
 			"Style definitions (schema alias)",
 			`plitzi://schema/${env}/definitions`,
@@ -117,6 +144,11 @@ var registerResources = (server, getSpace, env) => {
 			`plitzi://global-styles/${env}/{componentType}`,
 			"The site-wide CSS applied to every element of one type"
 		],
+		[
+			"Id style",
+			`plitzi://id-styles/${env}/{targetId}`,
+			"The CSS of an id rule (#id) targeting a single element"
+		],
 		[
 			"Style variables by category",
 			`plitzi://style-variables/${env}/{category}`,

package/dist/modules/mcp/resources/schema.js

@@ -1,33 +1,43 @@
+import { buildDataSourceCatalog, buildInteractionCatalog } from "../catalogs/observed.js";
 import { findElementByRef, findPageByRef } from "../helpers/space.js";
+import { afterPrefix, dataSourcesUri, elementUri, folderUri, foldersUri, interactionsUri, pageUri, pagesUri, schemaVarsUri, settingsUri } from "../helpers/uris.js";
 import { envelope } from "./envelope.js";
-import { elementDetailToAI, folderRefToAI, foldersToAI, pageSkeletonToAI, pageStylesToAI, pageSummariesToAI, schemaVariablesToAI } from "../tools/operations/schema/translator.js";
+import { elementView, folderRefToAI, foldersToAI, pageSkeletonToAI, pageStylesToAI, pageSummariesToAI, schemaVariablesToAI, settingsToAI } from "../tools/operations/schema/translator.js";
 //#region src/modules/mcp/resources/schema.ts
 /** Element-schema reads: page listings/skeletons/styles, folders, single elements and schema variables. Returns
 *  undefined when the URI belongs to another domain, null when the shape is ours but the ref does not resolve. */
 var readSchemaResource = (space, env, uri) => {
-	if (uri === `plitzi://schema/${env}/pages`) return envelope(pageSummariesToAI(space.schema));
-	if (uri === `plitzi://folders/${env}`) return envelope(foldersToAI(space.schema));
-	if (uri.startsWith(`plitzi://folders/${env}/`)) {
-		const ref = uri.slice(`plitzi://folders/${env}/`.length);
-		const folder = folderRefToAI(space.schema, ref);
+	if (uri === pagesUri(env)) return envelope(pageSummariesToAI(space.schema));
+	if (uri === foldersUri(env)) return envelope(foldersToAI(space.schema));
+	const folderRef = afterPrefix(uri, folderUri(env, ""));
+	if (folderRef !== void 0) {
+		const folder = folderRefToAI(space.schema, folderRef);
 		return folder ? envelope(folder) : null;
 	}
-	if (uri.startsWith(`plitzi://schema/${env}/pages/`) && uri.endsWith("/styles")) {
-		const ref = uri.slice(`plitzi://schema/${env}/pages/`.length, -7);
-		const page = findPageByRef(space.schema, ref);
-		return page ? envelope(pageStylesToAI(space.schema, space.style, page)) : null;
+	const pageItem = afterPrefix(uri, pageUri(env, ""));
+	if (pageItem !== void 0) {
+		if (pageItem.endsWith("/styles")) {
+			const ref = pageItem.slice(0, -7);
+			const page = findPageByRef(space.schema, ref);
+			return page ? envelope(pageStylesToAI(space.schema, space.style, page)) : null;
+		}
+		const page = findPageByRef(space.schema, pageItem);
+		return page ? envelope(pageSkeletonToAI(space.schema, page, space.style)) : null;
 	}
-	if (uri.startsWith(`plitzi://schema/${env}/pages/`)) {
-		const ref = uri.slice(`plitzi://schema/${env}/pages/`.length);
-		const page = findPageByRef(space.schema, ref);
-		return page ? envelope(pageSkeletonToAI(space.schema, page)) : null;
+	const elementRef = afterPrefix(uri, elementUri(env, ""));
+	if (elementRef !== void 0) {
+		const el = findElementByRef(space.schema, elementRef);
+		if (!el) return null;
+		const view = elementView(space.schema, el, space.style);
+		return {
+			stateVersion: view.version,
+			data: view.detail
+		};
 	}
-	if (uri.startsWith(`plitzi://schema/${env}/elements/`)) {
-		const ref = uri.slice(`plitzi://schema/${env}/elements/`.length);
-		const el = findElementByRef(space.schema, ref);
-		return el ? envelope(elementDetailToAI(space.schema, el, space.style)) : null;
-	}
-	if (uri === `plitzi://schema-variables/${env}`) return envelope(schemaVariablesToAI(space.schema));
+	if (uri === schemaVarsUri(env)) return envelope(schemaVariablesToAI(space.schema));
+	if (uri === settingsUri(env)) return envelope(settingsToAI(space.schema));
+	if (uri === interactionsUri(env)) return envelope(buildInteractionCatalog(space.schema));
+	if (uri === dataSourcesUri(env)) return envelope(buildDataSourceCatalog(space.schema));
 };
 //#endregion
 export { readSchemaResource };

package/dist/modules/mcp/resources/style.js

@@ -1,24 +1,31 @@
+import { afterPrefix, defUri, defsUri, globalUri, globalsUri, idUri, idsUri, styleVarUri, styleVarsUri } from "../helpers/uris.js";
 import { envelope } from "./envelope.js";
-import { definitionRefs, definitionToAI, globalStyleToAI, globalStyleTypes, styleVariablesToAI } from "../tools/operations/style/translator.js";
+import { definitionRefs, definitionToAI, globalStyleToAI, globalStyleTypes, idStyleIds, idStyleToAI, styleVariablesToAI } from "../tools/operations/style/translator.js";
 //#region src/modules/mcp/resources/style.ts
 /** Style-schema reads: definitions, global (per-type) styles and design-token variables by category. Returns
 *  undefined when the URI belongs to another domain, null when the shape is ours but the ref does not resolve. */
 var readStyleResource = (space, env, uri) => {
-	if (uri === `plitzi://definitions/${env}`) return envelope(definitionRefs(space.style));
-	if (uri.startsWith(`plitzi://definitions/${env}/`)) {
-		const ref = uri.slice(`plitzi://definitions/${env}/`.length);
-		const def = definitionToAI(space.style, ref);
+	if (uri === defsUri(env)) return envelope(definitionRefs(space.style));
+	const defRef = afterPrefix(uri, defUri(env, ""));
+	if (defRef !== void 0) {
+		const def = definitionToAI(space.style, defRef);
 		return def ? envelope(def) : null;
 	}
-	if (uri === `plitzi://global-styles/${env}`) return envelope(globalStyleTypes(space.style));
-	if (uri.startsWith(`plitzi://global-styles/${env}/`)) {
-		const componentType = uri.slice(`plitzi://global-styles/${env}/`.length);
+	if (uri === globalsUri(env)) return envelope(globalStyleTypes(space.style));
+	const componentType = afterPrefix(uri, globalUri(env, ""));
+	if (componentType !== void 0) {
 		const global = globalStyleToAI(space.style, componentType);
 		return global ? envelope(global) : null;
 	}
-	if (uri === `plitzi://style-variables/${env}`) return envelope(styleVariablesToAI(space.style));
-	if (uri.startsWith(`plitzi://style-variables/${env}/`)) {
-		const category = uri.slice(`plitzi://style-variables/${env}/`.length);
+	if (uri === idsUri(env)) return envelope(idStyleIds(space.style));
+	const targetId = afterPrefix(uri, idUri(env, ""));
+	if (targetId !== void 0) {
+		const idStyle = idStyleToAI(space.style, targetId);
+		return idStyle ? envelope(idStyle) : null;
+	}
+	if (uri === styleVarsUri(env)) return envelope(styleVariablesToAI(space.style));
+	const category = afterPrefix(uri, styleVarUri(env, ""));
+	if (category !== void 0) {
 		const byCategory = styleVariablesToAI(space.style);
 		return envelope(Object.hasOwn(byCategory, category) ? byCategory[category] : []);
 	}

package/dist/modules/mcp/server.js

@@ -1,5 +1,6 @@
 import { emptySpaceMessage, unauthorizedSpaceMessage } from "./helpers/space.js";
 import { serverInstructions } from "./helpers/guide.js";
+import { createMcpLog } from "./helpers/log.js";
 import { registerResources } from "./resources/register.js";
 import { tools } from "./tools/index.js";
 import { isCallToolResult } from "../ai/toolkit.js";
@@ -10,7 +11,8 @@ var asText = (data) => ({ content: [{
 	type: "text",
 	text: JSON.stringify(data)
 }] });
-var createMcpServer = ({ adapters, getSpaceId, preview, screenshot }) => {
+var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger }) => {
+	const log = createMcpLog(logger);
 	let spaceIdPromise;
 	const requireSpaceId = () => spaceIdPromise ??= getSpaceId().then((id) => {
 		if (!id) throw new Error(unauthorizedSpaceMessage);
@@ -18,11 +20,16 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot }) => {
 	});
 	const loadSpace = async () => {
 		const spaceId = await requireSpaceId();
-		const [schema, style] = await Promise.all([adapters.getSchema?.(spaceId, MCP_ENV), adapters.getStyle?.(spaceId, MCP_ENV)]);
+		const [schema, style, catalog] = await Promise.all([
+			adapters.getSchema?.(spaceId, MCP_ENV),
+			adapters.getStyle?.(spaceId, MCP_ENV),
+			adapters.getComponentCatalog?.(spaceId, MCP_ENV).catch(() => void 0)
+		]);
 		if (!schema || !style) throw new Error(emptySpaceMessage);
 		return {
 			schema,
-			style
+			style,
+			catalog
 		};
 	};
 	const { saveSchema, saveStyle } = adapters;
@@ -34,9 +41,9 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot }) => {
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.3.0"
+		version: "0.32.6"
 	}, { instructions: serverInstructions });
-	registerResources(server, getSpace, MCP_ENV);
+	registerResources(server, getSpace, MCP_ENV, log);
 	const toolContext = async () => ({
 		space: await getSpace(),
 		env: MCP_ENV,
@@ -52,8 +59,15 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot }) => {
 			description: tool.description,
 			inputSchema: tool.inputShape
 		}, async (args) => {
-			const result = await tool.execute(args, await toolContext());
-			return isCallToolResult(result) ? result : asText(result);
+			const start = performance.now();
+			try {
+				const result = await tool.execute(args, await toolContext());
+				log.toolCall(tool.name, args, performance.now() - start);
+				return isCallToolResult(result) ? result : asText(result);
+			} catch (error) {
+				log.toolCall(tool.name, args, performance.now() - start, error);
+				throw error;
+			}
 		});
 	}
 	return server;