@plitzi/sdk-server 0.32.3 → 0.32.5

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

@@ -0,0 +1,142 @@
+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) => {
+	const emit = async (uri) => {
+		const result = readResource(await getSpace(), env, uri);
+		if (!result) throw new Error(resourceErrorMessage(env, uri));
+		return jsonContents(uri, result);
+	};
+	server.registerResource("Guide", "plitzi://guide", {
+		description: "How to read and write this space with mcp-ai",
+		mimeType: "text/markdown"
+	}, () => ({ contents: [{
+		uri: "plitzi://guide",
+		mimeType: "text/markdown",
+		text: guideText
+	}] }));
+	server.registerResource("CSS properties", "plitzi://css-properties", {
+		description: "Valid kebab-case CSS property keys",
+		mimeType: "application/json"
+	}, () => jsonContents("plitzi://css-properties", envelope(cssProperties)));
+	const fixed = [
+		[
+			"Primer",
+			`plitzi://primer/${env}`,
+			"Read this FIRST. Cold-start bundle in one call: guide, types, css-properties and SUMMARIES of pages, definitions and variables — summaries only, never full page/element trees, so it stays small even on a large space. Open a page or element on demand afterwards."
+		],
+		[
+			"Element types",
+			"plitzi://types",
+			"Observed element types with props, slots and subTypes"
+		],
+		[
+			"Pages",
+			`plitzi://schema/${env}/pages`,
+			"Page summaries (ref, label, elementCount) — no element trees"
+		],
+		[
+			"Folders",
+			`plitzi://folders/${env}`,
+			"Page folders (the sidebar tree): ref, name, slug, parentId"
+		],
+		[
+			"Style definitions",
+			`plitzi://definitions/${env}`,
+			"Style definition refs (names)"
+		],
+		[
+			"Global styles",
+			`plitzi://global-styles/${env}`,
+			"Element types that have a site-wide global style"
+		],
+		[
+			"Style variables",
+			`plitzi://style-variables/${env}`,
+			"Design tokens by category"
+		],
+		[
+			"Schema variables",
+			`plitzi://schema-variables/${env}`,
+			"Space-level values referenced via {{name}}"
+		],
+		[
+			"Style definitions (schema alias)",
+			`plitzi://schema/${env}/definitions`,
+			"Alias of plitzi://definitions/{env}"
+		],
+		[
+			"Style variables (schema alias)",
+			`plitzi://schema/${env}/style-variables`,
+			"Alias of plitzi://style-variables/{env}"
+		],
+		[
+			"Schema variables (schema alias)",
+			`plitzi://schema/${env}/schema-variables`,
+			"Alias of plitzi://schema-variables/{env}"
+		]
+	];
+	for (const [name, uri, description] of fixed) server.registerResource(name, uri, {
+		description,
+		mimeType: "application/json"
+	}, () => emit(uri));
+	const templates = [
+		[
+			"Page",
+			`plitzi://schema/${env}/pages/{ref}`,
+			"One page as a skeleton tree (ref/type/label/children), no props"
+		],
+		[
+			"Page styles",
+			`plitzi://schema/${env}/pages/{ref}/styles`,
+			"Every style a page uses in one read: class definitions its elements attach (with CSS) + global styles"
+		],
+		[
+			"Element",
+			`plitzi://schema/${env}/elements/{ref}`,
+			"One element in full detail (props, style) by ref or id"
+		],
+		[
+			"Folder",
+			`plitzi://folders/${env}/{ref}`,
+			"One page folder (name, slug, parentId) by folder id"
+		],
+		[
+			"Style definition",
+			`plitzi://definitions/${env}/{ref}`,
+			"One style definition (CSS) by class ref"
+		],
+		[
+			"Global style",
+			`plitzi://global-styles/${env}/{componentType}`,
+			"The site-wide CSS applied to every element of one type"
+		],
+		[
+			"Style variables by category",
+			`plitzi://style-variables/${env}/{category}`,
+			"Design tokens for one category"
+		],
+		[
+			"Style definition (schema alias)",
+			`plitzi://schema/${env}/definitions/{ref}`,
+			"Alias of plitzi://definitions/{env}/{ref}"
+		],
+		[
+			"Style variables by category (schema alias)",
+			`plitzi://schema/${env}/style-variables/{category}`,
+			"Alias of plitzi://style-variables/{env}/{category}"
+		]
+	];
+	for (const [name, tpl, description] of templates) server.registerResource(name, new ResourceTemplate(tpl, { list: void 0 }), {
+		description,
+		mimeType: "application/json"
+	}, (uri) => emit(uri.href));
+};
+//#endregion
+export { registerResources };

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

@@ -0,0 +1,25 @@
+import { canonicalUri } from "./canonical.js";
+import { readCoreResource } from "./core.js";
+import { readPrimerResource } from "./primer.js";
+import { readSchemaResource } from "./schema.js";
+import { readStyleResource } from "./style.js";
+//#region src/modules/mcp/resources/router.ts
+var resolvers = [
+	(space, _env, uri) => readCoreResource(space, uri),
+	readPrimerResource,
+	readSchemaResource,
+	readStyleResource
+];
+/** Resolve a resource URI to its versioned envelope, or null if unknown / not found. */
+var readResource = (space, env, rawUri) => {
+	const uri = canonicalUri(env, rawUri);
+	for (const resolve of resolvers) {
+		const result = resolve(space, env, uri);
+		if (result !== void 0) return result;
+	}
+	return null;
+};
+/** Current version of a resource, for optimistic-concurrency checks. Null when the URI is unknown. */
+var resourceVersion = (space, env, uri) => readResource(space, env, uri)?.stateVersion ?? null;
+//#endregion
+export { readResource, resourceVersion };

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

@@ -0,0 +1,33 @@
+import { findElementByRef, findPageByRef } from "../helpers/space.js";
+import { envelope } from "./envelope.js";
+import { elementDetailToAI, folderRefToAI, foldersToAI, pageSkeletonToAI, pageStylesToAI, pageSummariesToAI, schemaVariablesToAI } 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);
+		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;
+	}
+	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;
+	}
+	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));
+};
+//#endregion
+export { readSchemaResource };

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

@@ -0,0 +1,27 @@
+import { envelope } from "./envelope.js";
+import { definitionRefs, definitionToAI, globalStyleToAI, globalStyleTypes, 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);
+		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);
+		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);
+		const byCategory = styleVariablesToAI(space.style);
+		return envelope(Object.hasOwn(byCategory, category) ? byCategory[category] : []);
+	}
+};
+//#endregion
+export { readStyleResource };

package/dist/modules/mcp/screenshotClient.js

@@ -0,0 +1,47 @@
+import { PREVIEW_TOKEN_PARAM } from "./constants.js";
+//#region src/modules/mcp/screenshotClient.ts
+var composeUrl = (base, pagePath, token) => {
+	const url = new URL(pagePath, base);
+	if (token) url.searchParams.set(PREVIEW_TOKEN_PARAM, token);
+	return url.toString();
+};
+/** Default `ScreenshotClient`: composes the navigable preview URL (renderBaseUrl + pagePath + `?__pt=token`) and
+*  POSTs it to the browser service. Any network/HTTP failure surfaces as `ok:false` so the tool can fall back to
+*  the HTML preview instead of hard-failing. */
+var createHttpScreenshotClient = ({ serviceUrl, renderBaseUrl, fetchImpl = fetch }) => ({ async capture({ pagePath, token, viewports }) {
+	const url = composeUrl(renderBaseUrl, pagePath, token);
+	let res;
+	try {
+		res = await fetchImpl(serviceUrl, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				url,
+				viewports
+			})
+		});
+	} catch (err) {
+		return {
+			ok: false,
+			error: "SCREENSHOT_UNREACHABLE",
+			message: `Browser service unreachable: ${String(err)}`
+		};
+	}
+	if (!res.ok) return {
+		ok: false,
+		error: "SCREENSHOT_FAILED",
+		message: `Browser service returned ${res.status}.`
+	};
+	const body = await res.json();
+	if (!body.images || body.images.length === 0) return {
+		ok: false,
+		error: "SCREENSHOT_EMPTY",
+		message: "Browser service returned no images."
+	};
+	return {
+		ok: true,
+		images: body.images
+	};
+} });
+//#endregion
+export { createHttpScreenshotClient };

package/dist/modules/mcp/server.js

@@ -1,29 +1,61 @@
-import { bindTools } from "./helpers.js";
-import { registerResources } from "./resources/index.js";
-import { tools_exports } from "./tools/index.js";
-import package_default from "../../package.js";
+import { emptySpaceMessage, unauthorizedSpaceMessage } from "./helpers/space.js";
+import { serverInstructions } from "./helpers/guide.js";
+import { registerResources } from "./resources/register.js";
+import { tools } from "./tools/index.js";
+import { isCallToolResult } from "../ai/toolkit.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
 //#region src/modules/mcp/server.ts
-var createMcpServer = (adapters = {}, engine, tools, prompts, resources) => {
-	const boundTools = bindTools([...Object.values(tools_exports), ...tools ?? []], adapters);
+var MCP_ENV = "main";
+var asText = (data) => ({ content: [{
+	type: "text",
+	text: JSON.stringify(data)
+}] });
+var createMcpServer = ({ adapters, getSpaceId, preview, screenshot }) => {
+	let spaceIdPromise;
+	const requireSpaceId = () => spaceIdPromise ??= getSpaceId().then((id) => {
+		if (!id) throw new Error(unauthorizedSpaceMessage);
+		return id;
+	});
+	const loadSpace = async () => {
+		const spaceId = await requireSpaceId();
+		const [schema, style] = await Promise.all([adapters.getSchema?.(spaceId, MCP_ENV), adapters.getStyle?.(spaceId, MCP_ENV)]);
+		if (!schema || !style) throw new Error(emptySpaceMessage);
+		return {
+			schema,
+			style
+		};
+	};
+	const { saveSchema, saveStyle } = adapters;
+	const persisters = {
+		schema: saveSchema ? async (schema) => saveSchema(await requireSpaceId(), MCP_ENV, schema) : void 0,
+		style: saveStyle ? async (style) => saveStyle(await requireSpaceId(), MCP_ENV, style) : void 0
+	};
+	let spacePromise;
+	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: package_default.version
+		version: "0.3.0"
+	}, { instructions: serverInstructions });
+	registerResources(server, getSpace, MCP_ENV);
+	const toolContext = async () => ({
+		space: await getSpace(),
+		env: MCP_ENV,
+		persisters,
+		spaceId: await requireSpaceId(),
+		preview,
+		screenshot
 	});
-	engine.setToolsAvailables(boundTools);
-	registerResources(server, resources, engine.readResource);
-	for (const tool of boundTools) {
-		if (!engine.can(tool.name)) continue;
-		const { title, description, inputSchema, annotations } = tool.mcpDefinition;
-		const definition = {
-			title,
-			description,
-			inputSchema,
-			annotations
-		};
-		server.registerTool(tool.name, definition, engine.execute(tool.name, tool.handler));
+	for (const tool of tools) {
+		if (tool.requires === "screenshot" && !screenshot) continue;
+		server.registerTool(tool.name, {
+			title: tool.title,
+			description: tool.description,
+			inputSchema: tool.inputShape
+		}, async (args) => {
+			const result = await tool.execute(args, await toolContext());
+			return isCallToolResult(result) ? result : asText(result);
+		});
 	}
-	if (prompts) for (const prompt of prompts) server.registerPrompt(prompt.name, prompt.definition, engine.executePrompt(prompt.name, prompt.handler));
 	return server;
 };
 //#endregion

package/dist/modules/mcp/tools/apply/dispatch.js

@@ -0,0 +1,83 @@
+import { fail } from "../../helpers/opResult.js";
+import { deleteElement } from "../operations/schema/deleteElement.js";
+import { deleteFolder } from "../operations/schema/deleteFolder.js";
+import { deletePage } from "../operations/schema/deletePage.js";
+import { deleteVariable } from "../operations/schema/deleteVariable.js";
+import { moveElement } from "../operations/schema/moveElement.js";
+import { patchElement } from "../operations/schema/patchElement.js";
+import { upsertElement } from "../operations/schema/upsertElement.js";
+import { upsertFolder } from "../operations/schema/upsertFolder.js";
+import { upsertPage } from "../operations/schema/upsertPage.js";
+import { upsertVariable } from "../operations/schema/upsertVariable.js";
+import { deleteDefinition } from "../operations/style/deleteDefinition.js";
+import { deleteGlobalStyle } from "../operations/style/deleteGlobalStyle.js";
+import { deleteStyleVariable } from "../operations/style/deleteStyleVariable.js";
+import { patchDefinition } from "../operations/style/patchDefinition.js";
+import { patchGlobalStyle } from "../operations/style/patchGlobalStyle.js";
+import { upsertDefinition } from "../operations/style/upsertDefinition.js";
+import { upsertGlobalStyle } from "../operations/style/upsertGlobalStyle.js";
+import { upsertStyleVariable } from "../operations/style/upsertStyleVariable.js";
+import { isStyleOp } from "../operations/index.js";
+//#region src/modules/mcp/tools/apply/dispatch.ts
+var executeOp = (space, env, op) => {
+	switch (op.type) {
+		case "upsertElement": return upsertElement(space, env, op);
+		case "patchElement": return patchElement(space, env, op);
+		case "deleteElement": return deleteElement(space, env, op);
+		case "moveElement": return moveElement(space, env, op);
+		case "upsertPage": return upsertPage(space, env, op);
+		case "deletePage": return deletePage(space, env, op);
+		case "upsertFolder": return upsertFolder(space, env, op);
+		case "deleteFolder": return deleteFolder(space, env, op);
+		case "upsertVariable": return upsertVariable(space, env, op);
+		case "deleteVariable": return deleteVariable(space, env, op);
+		case "upsertDefinition": return upsertDefinition(space, env, op);
+		case "patchDefinition": return patchDefinition(space, env, op);
+		case "deleteDefinition": return deleteDefinition(space, env, op);
+		case "upsertGlobalStyle": return upsertGlobalStyle(space, env, op);
+		case "patchGlobalStyle": return patchGlobalStyle(space, env, op);
+		case "deleteGlobalStyle": return deleteGlobalStyle(space, env, op);
+		case "upsertStyleVariable": return upsertStyleVariable(space, env, op);
+		case "deleteStyleVariable": return deleteStyleVariable(space, env, op);
+		default: return fail("type", `Unknown operation "${op.type}"`, "See the Operation union");
+	}
+};
+/** Apply operations in order to the space (mutating it). Records which schema(s) changed so the caller can
+*  persist each independently. Stops collecting counts for a failed op but records its errors. */
+var applyOperations = (space, env, ops) => {
+	const outcome = {
+		created: 0,
+		updated: 0,
+		deleted: 0,
+		staleResources: [],
+		elementRefs: [],
+		errors: [],
+		changedSchema: false,
+		changedStyle: false
+	};
+	const stale = /* @__PURE__ */ new Set();
+	const elements = /* @__PURE__ */ new Set();
+	for (let i = 0; i < ops.length; i++) {
+		const op = ops[i];
+		const result = executeOp(space, env, op);
+		if (result.errors) {
+			outcome.errors.push(...result.errors.map((e) => ({
+				...e,
+				path: `operations[${i}].${e.path}`
+			})));
+			continue;
+		}
+		if (isStyleOp(op.type)) outcome.changedStyle = true;
+		else outcome.changedSchema = true;
+		outcome.created += result.created;
+		outcome.updated += result.updated;
+		outcome.deleted += result.deleted;
+		for (const uri of result.staleResources) stale.add(uri);
+		for (const ref of result.elementRefs ?? []) elements.add(ref);
+	}
+	outcome.staleResources = Array.from(stale);
+	outcome.elementRefs = Array.from(elements);
+	return outcome;
+};
+//#endregion
+export { applyOperations };

package/dist/modules/mcp/tools/apply/index.js

@@ -0,0 +1,121 @@
+import { cloneSpace } from "../../helpers/space.js";
+import { environment, operations } from "../operations/index.js";
+import { applyOperations } from "./dispatch.js";
+import { changedResources, conflictMessage, detectConflicts, resolvedElements } from "./writeResult.js";
+import { defineTool } from "../shared/tool.js";
+import { validateOperations } from "../shared/validator.js";
+import { z } from "zod";
+import { validateSchema } from "@plitzi/sdk-schema";
+//#region src/modules/mcp/tools/apply/index.ts
+var applyShape = {
+	environment,
+	dryRun: z.boolean().optional().describe("Validate and apply in memory only, WITHOUT persisting. Returns the same result (changed versions + full element detail) so you can inspect the outcome and decide on more changes before committing for real."),
+	expectedResourceVersions: z.record(z.string(), z.string()).optional().describe("Resource URI → the stateVersion you read; guards against concurrent edits"),
+	operations
+};
+var noWarnings = (warnings) => warnings.length > 0 ? warnings : void 0;
+var schemaErrorToValidation = (error) => ({
+	path: error.elementId ? `schema.${error.elementId}` : "schema",
+	message: error.message,
+	hint: "This batch would leave the schema inconsistent (broken parent/child link or a cycle); nothing was applied."
+});
+var apply = async (input, space, persisters) => {
+	const env = input.environment ?? "main";
+	const validation = validateOperations(space, input.operations);
+	if (!validation.valid) return {
+		applied: false,
+		persisted: false,
+		summary: {
+			created: 0,
+			updated: 0,
+			deleted: 0
+		},
+		changed: [],
+		errors: validation.errors,
+		warnings: noWarnings(validation.warnings)
+	};
+	const conflicts = detectConflicts(space, env, input.expectedResourceVersions);
+	if (conflicts.length > 0) return {
+		applied: false,
+		persisted: false,
+		summary: {
+			created: 0,
+			updated: 0,
+			deleted: 0
+		},
+		changed: [],
+		conflict: {
+			message: conflictMessage,
+			conflicts
+		}
+	};
+	const draft = cloneSpace(space);
+	const outcome = applyOperations(draft, env, input.operations);
+	if (outcome.errors.length > 0) return {
+		applied: false,
+		persisted: false,
+		summary: {
+			created: 0,
+			updated: 0,
+			deleted: 0
+		},
+		changed: [],
+		errors: outcome.errors,
+		warnings: noWarnings(validation.warnings)
+	};
+	const integrity = validateSchema(draft.schema);
+	if (!integrity.valid) return {
+		applied: false,
+		persisted: false,
+		summary: {
+			created: 0,
+			updated: 0,
+			deleted: 0
+		},
+		changed: [],
+		errors: integrity.errors.map(schemaErrorToValidation),
+		warnings: noWarnings(validation.warnings)
+	};
+	if (input.dryRun) return {
+		applied: false,
+		dryRun: true,
+		summary: {
+			created: outcome.created,
+			updated: outcome.updated,
+			deleted: outcome.deleted
+		},
+		changed: changedResources(draft, env, outcome.staleResources),
+		elements: resolvedElements(draft, env, outcome.elementRefs),
+		warnings: noWarnings(validation.warnings)
+	};
+	let persisted = true;
+	if (outcome.changedSchema) if (persisters?.schema) await persisters.schema(draft.schema);
+	else persisted = false;
+	if (outcome.changedStyle) if (persisters?.style) await persisters.style(draft.style);
+	else persisted = false;
+	return {
+		applied: true,
+		persisted,
+		summary: {
+			created: outcome.created,
+			updated: outcome.updated,
+			deleted: outcome.deleted
+		},
+		changed: changedResources(draft, env, outcome.staleResources),
+		elements: resolvedElements(draft, env, outcome.elementRefs),
+		warnings: noWarnings(validation.warnings)
+	};
+};
+var applyTool = defineTool({
+	name: "plitzi_apply",
+	title: "Apply",
+	description: "Validate, apply and persist a batch of operations atomically. Returns the changed resources and their new versions, plus the full detail of every element it created or updated. Pass dryRun to apply in memory only (inspect the outcome without committing). Rejects the whole batch on any error or version conflict.",
+	inputShape: applyShape,
+	access: "write",
+	run: (input, ctx) => apply({
+		...input,
+		environment: ctx.env
+	}, ctx.space, ctx.persisters)
+});
+//#endregion
+export { apply, applyShape, applyTool };

package/dist/modules/mcp/tools/apply/writeResult.js

@@ -0,0 +1,36 @@
+import { readResource, resourceVersion } from "../../resources/router.js";
+//#region src/modules/mcp/tools/apply/writeResult.ts
+var detectConflicts = (space, env, expected) => {
+	if (!expected) return [];
+	const conflicts = [];
+	for (const [uri, version] of Object.entries(expected)) {
+		const current = resourceVersion(space, env, uri);
+		if (current !== null && current !== version) conflicts.push({
+			resourceUri: uri,
+			expectedVersion: version,
+			currentVersion: current
+		});
+	}
+	return conflicts;
+};
+var changedResources = (space, env, uris) => uris.map((uri) => ({
+	uri,
+	stateVersion: resourceVersion(space, env, uri) ?? ""
+}));
+/** Full detail of each created/updated element (by ref), skipping any that no longer resolve (e.g. deleted later
+*  in the same batch). Returns undefined when there is nothing, so the field stays off the response. */
+var resolvedElements = (space, env, refs) => {
+	const elements = refs.map((ref) => {
+		const uri = `plitzi://schema/${env}/elements/${ref}`;
+		const res = readResource(space, env, uri);
+		return res ? {
+			uri,
+			stateVersion: res.stateVersion,
+			...res.data
+		} : void 0;
+	}).filter((el) => el !== void 0);
+	return elements.length > 0 ? elements : void 0;
+};
+var conflictMessage = "Cannot apply: your data is stale. Re-read the changed resources and retry.";
+//#endregion
+export { changedResources, conflictMessage, detectConflicts, resolvedElements };