@plitzi/sdk-mcp 0.37.2 → 0.37.3

package/dist/modules/mcp/tools/shared/validator/interactions.js

@@ -1,34 +1,14 @@
-import { getElementCallback, getGlobalCallback, getUtility, hiddenParams, invalidParams, missingRequiredParams, reconcileParams } from "../../../catalogs/index.js";
+import { getElementCallback, getGlobalCallback, getUtility, hiddenParams, reconcileParams } from "../../../catalogs/index.js";
 import { NULLISH_ELEMENT_IDS } from "../../../helpers/interactions.js";
 import { checkObservedName, warnOnce } from "./context.js";
 //#region src/modules/mcp/tools/shared/validator/interactions.ts
 var ELEMENT_FIELD_ACTIONS = /* @__PURE__ */ new Set(["setState", "toggleState"]);
-var describeType = (type) => {
-	switch (type) {
-		case "boolean": return "a boolean";
-		case "number": return "a number";
-		case "select": return "one of its allowed values";
-		case "scalar": return "a string, number or boolean";
-		default: return "a string";
-	}
-};
 var checkParams = (label, action, params, spec, base, ctx) => {
 	const unknown = Object.keys(params).filter((key) => !(key in spec));
 	if (unknown.length > 0) warnOnce(ctx, `${label} "${action}" at ${base} got unknown param(s) ${unknown.map((k) => `"${k}"`).join(", ")} — these are dropped on apply. Valid params: ${Object.keys(spec).join(", ")}.`);
 	const effective = reconcileParams(params, spec, true);
-	const missing = missingRequiredParams(params, effective, spec);
-	if (missing.length > 0) warnOnce(ctx, `${label} "${action}" at ${base} is missing required param(s) ${missing.map((k) => `"${k}"`).join(", ")} — the step is malformed without them (see plitzi://interactions for what each does).`);
 	const hidden = hiddenParams(params, effective, spec);
 	if (hidden.length > 0) warnOnce(ctx, `${label} "${action}" at ${base}: param(s) ${hidden.map((k) => `"${k}"`).join(", ")} are ignored under the current params (they only apply when a companion param is set — see plitzi://interactions). Set the companion param or drop them.`);
-	for (const { key, expected, got, options } of invalidParams(params, effective, spec)) {
-		const detail = options ? ` Allowed values: ${options.join(", ")}.` : "";
-		ctx.errors.push({
-			path: `${base}.params.${key}`,
-			message: `${label} "${action}" at ${base}: param "${key}" must be ${describeType(expected)} but got ${got}.${detail}`,
-			hint: `Set "${key}" to ${describeType(expected)}.`,
-			...options ? { validValues: options } : {}
-		});
-	}
 };
 var checkGlobalCallback = (node, base, ctx) => {
 	const builtin = getGlobalCallback(node.action);
@@ -46,50 +26,15 @@ var checkElementFieldKey = (node, base, ctx, hostRef) => {
 	const targetRef = typeof node.elementId === "string" && node.elementId !== "" ? node.elementId : hostRef;
 	const type = ctx.elementType(targetRef);
 	const meta = type ? ctx.typeMeta.get(type) : void 0;
-	if (!meta) return;
+	if (!meta?.custom) return;
 	const state = node.params?.category === "state";
 	const validKeys = state ? /* @__PURE__ */ new Set(["visibility", ...[...meta.styleSelectors].map((selector) => `styleSelectors.${selector}`)]) : meta.attributes;
 	if (validKeys.size === 0 || validKeys.has(key)) return;
 	const kind = state ? "state" : "attribute";
 	const valid = [...validKeys].sort();
-	const detail = `Element ${node.action} at ${base} names ${kind} "${key}" on type "${type}", which has no such ${kind} key`;
-	if (!meta.custom) ctx.errors.push({
-		path: base,
-		message: detail,
-		hint: `Use one of: ${valid.join(", ")}`,
-		validValues: valid
-	});
-	else warnOnce(ctx, `${detail} (${valid.join(", ")}). It may still be valid — verify against plitzi://types.`);
-};
-/**
-* The step names another element to act on — and that element does not exist.
-*
-* This is the failure with NO symptom: the runtime resolves a callback as `callbacksAvailables[elementId][action]`,
-* so a dangling target finds nothing and the step does nothing, while the flow, the render and the apply all
-* report success. Nothing else in the pipeline catches it — the field-key check below needs the element's type to
-* say anything, so an unresolvable ref used to make it return in silence.
-*
-* A `widget` batch is the whole world (plitzi_render seeds an empty space), so a target that is neither in it nor
-* created by it is certainly wrong: a hard error. A space may carry legacy flows pointing at elements deleted long
-* ago, and the post-apply audit re-checks the stored interactions of every element the batch touches — erroring
-* there would block edits on debris the agent did not write, so in `space` mode this warns.
-*/
-var checkCallbackTarget = (node, base, ctx) => {
-	const target = node.elementId;
-	if (target === void 0 || target === "" || NULLISH_ELEMENT_IDS.has(target) || ctx.elementExists(target)) return;
-	const detail = `Element callback "${node.action}" at ${base} targets elementId "${target}", which is not an element in this widget`;
-	if (ctx.mode === "widget") {
-		ctx.errors.push({
-			path: `${base}.elementId`,
-			message: detail,
-			hint: "The runtime looks the callback up on that element, so the step silently does nothing. Use the ref of an element the batch authors, or omit elementId to act on the flow host."
-		});
-		return;
-	}
-	warnOnce(ctx, `Element callback "${node.action}" at ${base} targets elementId "${target}", which is not an element in this space — the step resolves to nothing and does nothing. Point it at a real element ref, or omit elementId to act on the flow host.`);
+	warnOnce(ctx, `Element ${node.action} at ${base} names ${kind} "${key}" on type "${type}", which has no such ${kind} key (${valid.join(", ")}). It may still be valid — verify against plitzi://types.`);
 };
 var checkElementCallback = (node, base, ctx, hostRef) => {
-	checkCallbackTarget(node, base, ctx);
 	const builtin = getElementCallback(node.action);
 	if (!builtin) {
 		if (getUtility(node.action)) warnOnce(ctx, `"${node.action}" at ${base} is a utility, not an element callback — use nodeType "utility".`);

package/dist/modules/mcp/tools/tryFunction.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ToolContext } from './shared/tool';
+export declare const tryFunctionShape: {
+    task: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+};
+/**
+ * Runs one task of the space's functions — the draft, in the sandbox, with the limits and the record any run has — and
+ * answers what it returned, what it logged and where it failed. How an agent checks the code it wrote before a page
+ * relies on it: the live site only runs what the space was last published with.
+ */
+export declare const tryFunction: (input: {
+    task: string;
+    params?: Record<string, unknown>;
+    dryRun?: boolean;
+}, ctx: ToolContext) => Promise<unknown>;
+export declare const tryFunctionTool: import('.').ToolDef;

package/dist/modules/mcp/tools/tryFunction.js

@@ -0,0 +1,43 @@
+import { defineTool } from "./shared/tool.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/tryFunction.ts
+var tryFunctionShape = {
+	task: z.string().describe("`<namespace>.<action>`"),
+	params: z.record(z.string(), z.unknown()).optional(),
+	dryRun: z.boolean().optional()
+};
+/**
+* Runs one task of the space's functions — the draft, in the sandbox, with the limits and the record any run has — and
+* answers what it returned, what it logged and where it failed. How an agent checks the code it wrote before a page
+* relies on it: the live site only runs what the space was last published with.
+*/
+var tryFunction = async (input, ctx) => {
+	if (input.dryRun) return {
+		ran: false,
+		reason: "Trying a function runs its code for real — its fetches and its writes — so not in plan mode"
+	};
+	if (!ctx.tryFunction) return {
+		ran: false,
+		reason: "This deployment runs no space functions"
+	};
+	const report = await ctx.tryFunction(input.task, input.params ?? {});
+	const step = report.steps.find((entry) => entry.action === input.task);
+	return {
+		ran: true,
+		status: report.status,
+		value: report.output.value,
+		...step?.error ? { error: step.error } : {},
+		...step?.logs ? { logs: step.logs } : {},
+		...step ? { ms: step.endTime - step.startTime } : {}
+	};
+};
+var tryFunctionTool = defineTool({
+	name: "plitzi_try_function",
+	title: "Try function",
+	description: "Run one task of the space’s functions against the draft, in the sandbox: its value, logs and error. Its writes are real.",
+	inputShape: tryFunctionShape,
+	access: "write",
+	run: (input, ctx) => tryFunction(input, ctx)
+});
+//#endregion
+export { tryFunction, tryFunctionShape, tryFunctionTool };

package/dist/modules/mcp/tools/validate.d.ts

@@ -188,6 +188,11 @@ export declare const validateShape: {
             params: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnknown>>;
             enabled: import('zod').ZodOptional<import('zod').ZodBoolean>;
             when: import('zod').ZodOptional<import('zod').ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, import('zod/v4/core').$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+            whileRunning: import('zod').ZodOptional<import('zod').ZodEnum<{
+                skip: "skip";
+                parallel: "parallel";
+                queue: "queue";
+            }>>;
             elementId: import('zod').ZodOptional<import('zod').ZodString>;
             preview: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnknown>>;
         }, import('zod/v4/core').$strip>>;
@@ -201,6 +206,11 @@ export declare const validateShape: {
         params: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnknown>>;
         enabled: import('zod').ZodOptional<import('zod').ZodBoolean>;
         when: import('zod').ZodOptional<import('zod').ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, import('zod/v4/core').$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+        whileRunning: import('zod').ZodOptional<import('zod').ZodEnum<{
+            skip: "skip";
+            parallel: "parallel";
+            queue: "queue";
+        }>>;
         elementId: import('zod').ZodOptional<import('zod').ZodString>;
         preview: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnknown>>;
     }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
@@ -217,6 +227,8 @@ export declare const validateShape: {
             localStorage: "localStorage";
             sessionStorage: "sessionStorage";
         }>>;
+        transientState: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString>>;
+        paintedState: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString>>;
         userProvider: import('zod').ZodOptional<import('zod').ZodString>;
         tokenStorage: import('zod').ZodOptional<import('zod').ZodEnum<{
             "": "";
@@ -239,6 +251,21 @@ export declare const validateShape: {
             strict: "strict";
         }>>;
         sessionRevalidateSeconds: import('zod').ZodOptional<import('zod').ZodNumber>;
+        channels: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodNullable<import('zod').ZodObject<{
+            access: import('zod').ZodObject<{
+                mode: import('zod').ZodEnum<{
+                    public: "public";
+                    session: "session";
+                    role: "role";
+                }>;
+                permissions: import('zod').ZodOptional<import('zod').ZodArray<import('zod').ZodString>>;
+            }, import('zod/v4/core').$strip>;
+            publish: import('zod').ZodOptional<import('zod').ZodEnum<{
+                server: "server";
+                clients: "clients";
+            }>>;
+            presence: import('zod').ZodOptional<import('zod').ZodBoolean>;
+        }, import('zod/v4/core').$strip>>>>;
     }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
         desktop: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnion<readonly [import('zod').ZodString, import('zod').ZodNumber]>>>;
         tablet: import('zod').ZodOptional<import('zod').ZodRecord<import('zod').ZodString, import('zod').ZodUnion<readonly [import('zod').ZodString, import('zod').ZodNumber]>>>;
@@ -991,6 +1018,13 @@ export declare const validateShape: {
     }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
         type: import('zod').ZodLiteral<"deleteAction">;
         ref: import('zod').ZodString;
+    }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
+        type: import('zod').ZodLiteral<"upsertFunctionFile">;
+        path: import('zod').ZodString;
+        content: import('zod').ZodString;
+    }, import('zod/v4/core').$strip>, import('zod').ZodObject<{
+        type: import('zod').ZodLiteral<"deleteFunctionFile">;
+        path: import('zod').ZodString;
     }, import('zod/v4/core').$strip>], "type">>;
 };
 export declare const validate: (input: ValidateInput, space: Space) => ValidationResult;

package/dist/modules/mcp/tools/validate.js

@@ -1,38 +1,21 @@
-import { cloneSpace } from "../helpers/space.js";
 import { environment, operations } from "./operations/index.js";
-import { applyOperations } from "./apply/dispatch.js";
-import { expandOperations } from "./shared/expandOperations.js";
+import { draftBatch } from "./shared/draftBatch.js";
 import { defineTool } from "./shared/tool.js";
-import { validateOperations } from "./shared/validator/index.js";
-import { auditResources } from "./shared/validator/audit.js";
 //#region src/modules/mcp/tools/validate.ts
 var validateShape = {
 	environment,
 	operations
 };
 var validate = (input, space) => {
-	const expansion = expandOperations(input.operations);
-	if (expansion.errors.length > 0) return {
+	const result = draftBatch(space, input.environment ?? "main", input.operations);
+	return result.ok ? {
+		valid: true,
+		errors: [],
+		warnings: result.warnings
+	} : {
 		valid: false,
-		errors: expansion.errors,
-		warnings: []
-	};
-	const ops = expansion.operations;
-	const validation = validateOperations(space, ops);
-	if (!validation.valid) return validation;
-	const env = input.environment ?? "main";
-	const draft = cloneSpace(space);
-	const outcome = applyOperations(draft, env, ops);
-	if (outcome.errors.length > 0) return {
-		valid: false,
-		errors: outcome.errors,
-		warnings: validation.warnings
-	};
-	const audit = auditResources(draft, ops);
-	return {
-		valid: audit.errors.length === 0,
-		errors: audit.errors,
-		warnings: [...validation.warnings, ...audit.warnings]
+		errors: result.errors,
+		warnings: result.warnings
 	};
 };
 var validateTool = defineTool({

package/dist/modules/mcp/types/aiSchema.d.ts

@@ -1,5 +1,5 @@
 import { CssProps } from '@plitzi/sdk-authoring';
-import { ElementRuntime, Environment } from '@plitzi/sdk-shared';
+import { ElementRuntime, Environment, WhileRunning } from '@plitzi/sdk-shared';
 export type Env = Environment;
 /** CSS declarations for one selector state. Keys are kebab-case CSS properties (see plitzi://css-properties).
  *  Owned by the style engine, which is also what expands the shorthands an agent is allowed to write. */
@@ -138,6 +138,8 @@ export interface AIInteractionNode {
     params?: Record<string, unknown>;
     enabled?: boolean;
     when?: unknown;
+    /** On a trigger: what firing it again does while its flow still runs. `skip` when absent. */
+    whileRunning?: WhileRunning;
     /** Source element the callback targets (globalCallback/utility). Defaults to this element on write. */
     elementId?: string;
     preview?: Record<string, unknown>;
@@ -234,8 +236,13 @@ export interface AISchemaVariable {
  *  configuration. Every field is optional — a patch changes only the keys it sends. */
 export interface AISettings {
     customCss?: string;
+    /** Keep `runtime.state` — what `setState` writes — across reloads, filed under whoever is signed in. */
     keepState?: boolean;
     stateStorage?: 'localStorage' | 'sessionStorage';
+    /** Top-level state keys never kept, even with `keepState` on. */
+    transientState?: string[];
+    /** Kept keys the first paint shows, kept in a cookie too so the server renders with them. Small values only. */
+    paintedState?: string[];
     /** `basic` covers any HTTP+JSON backend by configuration; anything else is a name someone registered. */
     userProvider?: 'basic' | 'custom' | '' | (string & {});
     tokenStorage?: 'localStorage' | 'sessionStorage' | '';

package/dist/modules/mcp/types/previewTypes.d.ts

@@ -3,6 +3,12 @@ import { Operation } from '../tools/operations';
 export type PreviewRequestBody = {
     spaceId: number;
     env?: string;
+    /**
+     * A published revision of `env` to render instead of its latest. Ignored for `main`, which has no revisions — it is
+     * the draft. Asked for when what is shown has to be one exact version: a reviewed one, rather than whatever was
+     * published after the review.
+     */
+    revision?: number;
     pageRef?: string;
     operations?: Operation[];
     /**

package/dist/modules/mcp/types/screenshotTypes.d.ts

@@ -9,9 +9,20 @@ export type ScreenshotImage = {
     mimeType: string;
     data: string;
 };
+/**
+ * What a capture brings back of a page: how it looks, and how assistive technology reads it — the accessibility tree a
+ * screen reader walks, and the one a browser agent such as Claude in Chrome finds the page's controls in.
+ */
+export type CaptureView = 'image' | 'accessibility';
+/** One viewport's accessibility tree, as an indented outline: `- button "Close"`, `- heading "Plans" [level=1]`. */
+export type AccessibilityOutline = {
+    label: string;
+    outline: string;
+};
 export type ScreenshotResult = {
     ok: true;
     images: ScreenshotImage[];
+    accessibility?: AccessibilityOutline[];
 } | {
     ok: false;
     error: string;
@@ -27,6 +38,11 @@ export type ScreenshotInput = {
      * forces a theme keeps its own; left out, the browser's default applies, which is light.
      */
     colorScheme?: ColorScheme;
+    /**
+     * What to bring back; `['image']` when left out. A browser that cannot read the accessibility tree answers without
+     * `accessibility`, and the caller says so rather than failing.
+     */
+    views?: CaptureView[];
 };
 /** How plitzi_screenshot reaches the headless-browser service. The consumer injects an implementation (an HTTP
  *  client to the dedicated browser pod); absent → the tool is not registered. A capture that fails (pod down)

package/dist/modules/mcp/types/toolTypes.d.ts

@@ -1,6 +1,6 @@
 import { AIDefinition, AIElementDetail, ValidationError } from './aiSchema';
 import { Operation } from '../tools/operations';
-import { ActionEntry, ConnectorEntry, Schema, Style } from '@plitzi/sdk-shared';
+import { ActionEntry, ConnectorEntry, FunctionsSaveResult, Schema, Style } from '@plitzi/sdk-shared';
 /** The element schema, the style schema and the connectors persist independently (Space model / Style model / one
  *  row per connector), so each has its own optional persister. When one is absent, that store is applied in memory
  *  but reported unsaved. Connectors save and delete a row at a time — a batch touching two of them saves those two
@@ -12,6 +12,8 @@ export interface Persisters {
     deleteConnector?: (connectorId: string) => Promise<void>;
     saveAction?: (entry: ActionEntry) => Promise<void>;
     deleteAction?: (actionId: string) => Promise<void>;
+    /** Saves the functions' files whole, against the version the batch read; answers what is wrong where it is. */
+    saveFunctions?: (files: Record<string, string>, base: string) => Promise<FunctionsSaveResult>;
 }
 export interface Conflict {
     resourceUri: string;
@@ -66,6 +68,8 @@ export interface MutationOutcome {
     /** The same, for actions: one row each, so a batch writes exactly the ones it touched. */
     changedActions: string[];
     deletedActions: string[];
+    /** The functions' files changed: they are saved whole, as one store. */
+    changedFunctions: boolean;
 }
 export interface ApplyInput {
     environment?: string;

package/dist/preview/createPreview.js

@@ -1,7 +1,7 @@
 import { computeVersion } from "../modules/mcp/helpers/computeVersion.js";
 import { cloneSpace, findPageByRef, getPageElements } from "../modules/mcp/helpers/space.js";
-import { applyOperations } from "../modules/mcp/tools/apply/dispatch.js";
 import { validateOperations } from "../modules/mcp/tools/shared/validator/index.js";
+import { applyOperations } from "../modules/mcp/tools/apply/dispatch.js";
 import { randomUUID } from "node:crypto";
 import { buildBody } from "@plitzi/sdk-server/ssr";
 //#region src/preview/createPreview.ts
@@ -32,12 +32,12 @@ var syntheticRequest = (pagePath) => ({
 *  building any: this runs as a stage INSIDE an SSR server, not in the MCP process that calls it over HTTP. */
 var createPreview = async (body, config, renderFn, pluginManager, caches) => {
 	const env = body.env ?? "main";
-	const revision = 0;
+	const revision = env === "main" ? 0 : body.revision ?? 0;
 	const offlineData = await config.adapters.getOfflineData(body.spaceId, env, revision);
 	if (!offlineData) return {
 		ok: false,
 		error: "NO_DATA",
-		message: `No offline data for space ${body.spaceId} (${env}).`
+		message: `No offline data for space ${body.spaceId} (${env}${revision ? ` revision ${revision}` : ""}).`
 	};
 	let draftOffline = offlineData;
 	if (body.operations && body.operations.length > 0) {
@@ -77,7 +77,8 @@ var createPreview = async (body, config, renderFn, pluginManager, caches) => {
 		token = randomUUID();
 		await config.draftStore.put(token, draftOffline, {
 			ttlMs,
-			reusable
+			reusable,
+			spaceId: body.spaceId
 		});
 	}
 	return {

package/dist/stages/preview.js

@@ -1,7 +1,17 @@
 import { createPreview } from "../preview/createPreview.js";
 import { readRawBody } from "@plitzi/sdk-server/kernel";
+import { createHash, timingSafeEqual } from "node:crypto";
 //#region src/stages/preview.ts
 var PREVIEW_PATH_DEFAULT = "/__preview";
+var digest = (value) => createHash("sha256").update(value).digest();
+/**
+* Whether the request carries the configured secret — and there has to BE one.
+*
+* This endpoint lives on the page server, which is what the public reaches on every published host. Treating a
+* missing secret as "no check" turned an internal endpoint into a public one that renders any space's draft, so an
+* enabled endpoint with no secret refuses everybody. Compared as digests, in constant time.
+*/
+var presentsSecret = (header, secret) => !!secret && typeof header === "string" && timingSafeEqual(digest(header), digest(secret));
 var json = (ctx, status, payload) => {
 	ctx.res.setHeader("Content-Type", "application/json");
 	ctx.res.setStatus(status);
@@ -13,7 +23,7 @@ var previewStage = async (ctx) => {
 	const path = preview?.path ?? PREVIEW_PATH_DEFAULT;
 	const ending = ctx.req.path === `${path}/end`;
 	if (!preview?.enabled || ctx.req.method !== "POST" || ctx.req.path !== path && !ending) return false;
-	if (preview.secret && ctx.req.headers["x-preview-secret"] !== preview.secret) return json(ctx, 403, {
+	if (!presentsSecret(ctx.req.headers["x-preview-secret"], preview.secret)) return json(ctx, 403, {
 		error: "FORBIDDEN",
 		message: "Invalid or missing preview secret."
 	});
@@ -49,6 +59,10 @@ var previewStage = async (ctx) => {
 		error: "BAD_REQUEST",
 		message: "spaceId (number) is required."
 	});
+	if (body.revision !== void 0 && (!Number.isInteger(body.revision) || body.revision < 1)) return json(ctx, 400, {
+		error: "BAD_REQUEST",
+		message: "revision must be a positive integer when given."
+	});
 	const result = await createPreview(body, ctx.config, ctx.renderFn, ctx.pluginManager, ctx.caches);
 	return json(ctx, result.ok ? 200 : 422, result);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-mcp",
-  "version": "0.37.2",
+  "version": "0.37.3",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -29,14 +29,15 @@
   "sideEffects": false,
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.7.5",
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@plitzi/plitzi-sdk": "0.37.2",
-    "@plitzi/sdk-elements": "0.37.2",
-    "@plitzi/sdk-interactions": "0.37.2",
-    "@plitzi/sdk-schema": "0.37.2",
-    "@plitzi/sdk-server": "0.37.2",
-    "@plitzi/sdk-shared": "0.37.2",
-    "@plitzi/sdk-style": "0.37.2",
+    "@modelcontextprotocol/sdk": "^1.30.1",
+    "@plitzi/plitzi-sdk": "0.37.3",
+    "@plitzi/sdk-authoring": "0.37.3",
+    "@plitzi/sdk-elements": "0.37.3",
+    "@plitzi/sdk-interactions": "0.37.3",
+    "@plitzi/sdk-schema": "0.37.3",
+    "@plitzi/sdk-server": "0.37.3",
+    "@plitzi/sdk-shared": "0.37.3",
+    "@plitzi/sdk-style": "0.37.3",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.2",
     "zod": "^4.6.5"
@@ -59,7 +60,7 @@
     "react-dom": "^19.3.0",
     "tsx": "^4.23.15",
     "typescript": "^6.0.3",
-    "vite": "^8.3.0",
+    "vite": "^8.3.1",
     "vite-plugin-dts": "^5.1.1",
     "vitest": "^5.0.1"
   },

package/skills/plitzi-render/SKILL.md

@@ -52,12 +52,11 @@ Everything the widget needs travels in ONE call, as `operations`. Three ops carr
             "flex-direction": "column",
             "gap": "12px",
             "padding": "16px",
-            "min-width": "0",
             "color": "var(--color-text-primary, light-dark(#0f172a, #e8eaed))"
           }
         },
         "row": {
-          "desktop": { "display": "flex", "flex-wrap": "wrap", "gap": "12px", "min-width": "0" },
+          "desktop": { "display": "flex", "flex-wrap": "wrap", "gap": "12px" },
           "mobile": { "flex-direction": "column" }
         },
         "tile": {

package/dist/modules/mcp/tools/shared/validator/audit.d.ts

@@ -1,4 +0,0 @@
-import { Space } from '../../../helpers';
-import { ValidationResult } from '../../../types';
-import { Operation } from '../../operations';
-export declare const auditResources: (space: Space, ops: Operation[]) => ValidationResult;

package/dist/modules/mcp/tools/shared/validator/audit.js

@@ -1,127 +0,0 @@
-import { findElementByRef } from "../../../helpers/space.js";
-import { definitionToAI, globalStyleToAI, idStyleToAI } from "../../operations/style/translator.js";
-import { checkBindingSourceScope, checkBindingTarget, checkBindingTransformers } from "./bindings.js";
-import { checkSlotCss } from "./css.js";
-import { checkVariantApplication } from "./elements.js";
-import { checkInteractionNode } from "./interactions.js";
-import { buildValidationCtx } from "./index.js";
-import { styleWithoutTag } from "@plitzi/sdk-schema/helpers/styleWithoutTag";
-//#region src/modules/mcp/tools/shared/validator/audit.ts
-var harvest = (ctx, into, label, run) => {
-	const sub = {
-		...ctx,
-		errors: [],
-		warnings: [],
-		warned: /* @__PURE__ */ new Set()
-	};
-	run(sub);
-	for (const e of sub.errors) into.errors.push({
-		path: e.path,
-		message: `Pre-existing malformation in ${label}: ${e.message}`,
-		hint: `${e.hint ? `${e.hint} ` : ""}This issue already exists in the space (NOT caused by your change), but the save is blocked until you fix it too, in this same batch.`,
-		...e.validValues ? { validValues: e.validValues } : {}
-	});
-	for (const w of sub.warnings) {
-		const message = `Pre-existing issue in ${label} (not caused by your change, but worth fixing too): ${w}`;
-		if (!into.warnings.includes(message)) into.warnings.push(message);
-	}
-};
-var toNode = (id, node) => ({
-	id,
-	title: node.title,
-	nodeType: node.type,
-	action: node.action,
-	params: node.params,
-	enabled: node.enabled,
-	when: node.when,
-	elementId: node.elementId ?? void 0,
-	preview: node.preview
-});
-var auditElement = (space, sub, el) => {
-	const hostRef = el.id;
-	const base = `element "${hostRef}"`;
-	for (const [category, list] of Object.entries(el.definition.bindings ?? {})) for (const binding of list) {
-		const path = `${base}.bindings.${category}[to=${binding.to}]`;
-		checkBindingTransformers(binding.transformers, `${path}.transformers`, sub);
-		checkBindingSourceScope(space, sub, hostRef, binding.source, `${path}.source`);
-		checkBindingTarget(hostRef, category, binding.to, path, sub);
-	}
-	for (const [id, node] of Object.entries(el.definition.interactions ?? {})) checkInteractionNode(toNode(id, node), `${base}.interactions.${id}`, sub, hostRef);
-	checkVariantApplication(el.definition.initialState, `${base}.initialState`, sub);
-};
-var auditDefinitionCss = (sub, label, def) => {
-	const { ref, slots, ...slot } = def;
-	checkSlotCss(slot, label, sub);
-	for (const [name, slotDef] of Object.entries(slots ?? {})) checkSlotCss(slotDef, `${label}.slots.${name}`, sub);
-};
-var collectTouched = (ops) => {
-	const touched = {
-		elementRefs: /* @__PURE__ */ new Set(),
-		definitions: /* @__PURE__ */ new Set(),
-		globalStyles: /* @__PURE__ */ new Set(),
-		idStyles: /* @__PURE__ */ new Set()
-	};
-	for (const op of ops) switch (op.type) {
-		case "upsertElement":
-			touched.elementRefs.add(op.element.ref);
-			break;
-		case "patchElement":
-		case "moveElement":
-		case "upsertBinding":
-		case "patchBinding":
-		case "deleteBinding":
-		case "upsertInteractionFlow":
-		case "patchInteractionNode":
-		case "deleteInteraction":
-			touched.elementRefs.add(op.ref);
-			break;
-		case "upsertDefinition":
-		case "patchDefinition":
-			touched.definitions.add(op.ref);
-			break;
-		case "upsertDefinitions":
-			for (const ref of Object.keys(op.definitions)) touched.definitions.add(ref);
-			break;
-		case "upsertGlobalStyle":
-		case "patchGlobalStyle":
-			touched.globalStyles.add(op.componentType);
-			break;
-		case "upsertIdStyle":
-		case "patchIdStyle": touched.idStyles.add(op.targetId);
-	}
-	return touched;
-};
-var auditResources = (space, ops) => {
-	const ctx = buildValidationCtx(space, ops);
-	const result = {
-		valid: true,
-		errors: [],
-		warnings: []
-	};
-	const touched = collectTouched(ops);
-	const seenElements = /* @__PURE__ */ new Set();
-	for (const ref of touched.elementRefs) {
-		const el = findElementByRef(space.schema, ref);
-		if (!el || seenElements.has(el.id)) continue;
-		seenElements.add(el.id);
-		harvest(ctx, result, `element "${el.id}"`, (sub) => auditElement(space, sub, el));
-		const tagless = styleWithoutTag(el, space.style);
-		if (tagless) result.warnings.push(`element "${el.id}" ${tagless}`);
-	}
-	for (const ref of touched.definitions) {
-		const def = definitionToAI(space.style, ref);
-		if (def) harvest(ctx, result, `definition "${ref}"`, (sub) => auditDefinitionCss(sub, `definition "${ref}"`, def));
-	}
-	for (const componentType of touched.globalStyles) {
-		const def = globalStyleToAI(space.style, componentType);
-		if (def) harvest(ctx, result, `global style "${componentType}"`, (sub) => auditDefinitionCss(sub, `global style "${componentType}"`, def));
-	}
-	for (const targetId of touched.idStyles) {
-		const def = idStyleToAI(space.style, targetId);
-		if (def) harvest(ctx, result, `id style "#${targetId}"`, (sub) => auditDefinitionCss(sub, `id style "#${targetId}"`, def));
-	}
-	result.valid = result.errors.length === 0;
-	return result;
-};
-//#endregion
-export { auditResources };