@plitzi/sdk-mcp 0.38.7 → 0.38.9

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

@@ -1,66 +1,78 @@
 import { actionOps } from "./actions/index.js";
+import { closed, typeOf } from "./closed.js";
 import { connectorOps } from "./connectors/index.js";
 import { dataOps } from "./data/index.js";
 import { functionOps } from "./functions/index.js";
 import { elementOps } from "./schema/operations.js";
 import { registerSharedSchemaIds } from "./schemaIds.js";
 import { styleOps } from "./style/operations.js";
+import { closest } from "@plitzi/sdk-authoring";
 import { z } from "zod";
 //#region src/modules/mcp/tools/operations/index.ts
 registerSharedSchemaIds();
+/** A batch's operations, each read by its `type` — and a type none of them has answered with the nearest one. */
+var union = (options) => {
+	const types = options.map(typeOf);
+	return z.discriminatedUnion("type", options, { error: (issue) => {
+		const { input } = issue;
+		const type = typeof input === "object" && input !== null && "type" in input ? String(input.type) : "";
+		const nearest = closest(type, types);
+		return type === "" ? "An operation needs its `type`: plitzi_describe_operation lists every one" : `There is no "${type}" operation${nearest ? ` — did you mean "${nearest}"?` : ""}: plitzi_describe_operation lists every type`;
+	} });
+};
 var documentOps = [
-	elementOps.upsertElement,
-	elementOps.repeatElement,
-	elementOps.patchElement,
-	elementOps.deleteElement,
-	elementOps.moveElement,
-	elementOps.upsertPage,
-	elementOps.deletePage,
-	elementOps.upsertLayout,
-	elementOps.deleteLayout,
-	elementOps.upsertFolder,
-	elementOps.deleteFolder,
-	elementOps.upsertVariable,
-	elementOps.deleteVariable,
-	elementOps.upsertFlag,
-	elementOps.deleteFlag,
-	elementOps.upsertBinding,
-	elementOps.patchBinding,
-	elementOps.deleteBinding,
-	elementOps.upsertInteractionFlow,
-	elementOps.patchInteractionNode,
-	elementOps.deleteInteraction,
-	elementOps.patchSettings,
-	elementOps.upsertComponent,
-	elementOps.deleteComponent,
-	styleOps.upsertDefinition,
-	styleOps.upsertDefinitions,
-	styleOps.patchDefinition,
-	styleOps.deleteDefinition,
-	styleOps.upsertGlobalStyle,
-	styleOps.patchGlobalStyle,
-	styleOps.deleteGlobalStyle,
-	styleOps.upsertIdStyle,
-	styleOps.patchIdStyle,
-	styleOps.deleteIdStyle,
-	styleOps.upsertStyleVariable,
-	styleOps.deleteStyleVariable,
-	styleOps.upsertFont,
-	styleOps.deleteFont
+	closed(elementOps.upsertElement),
+	closed(elementOps.repeatElement),
+	closed(elementOps.patchElement),
+	closed(elementOps.deleteElement),
+	closed(elementOps.moveElement),
+	closed(elementOps.upsertPage),
+	closed(elementOps.deletePage),
+	closed(elementOps.upsertLayout),
+	closed(elementOps.deleteLayout),
+	closed(elementOps.upsertFolder),
+	closed(elementOps.deleteFolder),
+	closed(elementOps.upsertVariable),
+	closed(elementOps.deleteVariable),
+	closed(elementOps.upsertFlag),
+	closed(elementOps.deleteFlag),
+	closed(elementOps.upsertBinding),
+	closed(elementOps.patchBinding),
+	closed(elementOps.deleteBinding),
+	closed(elementOps.upsertInteractionFlow),
+	closed(elementOps.patchInteractionNode),
+	closed(elementOps.deleteInteraction),
+	closed(elementOps.patchSettings),
+	closed(elementOps.upsertComponent),
+	closed(elementOps.deleteComponent),
+	closed(styleOps.upsertDefinition),
+	closed(styleOps.upsertDefinitions),
+	closed(styleOps.patchDefinition),
+	closed(styleOps.deleteDefinition),
+	closed(styleOps.upsertGlobalStyle),
+	closed(styleOps.patchGlobalStyle),
+	closed(styleOps.deleteGlobalStyle),
+	closed(styleOps.upsertIdStyle),
+	closed(styleOps.patchIdStyle),
+	closed(styleOps.deleteIdStyle),
+	closed(styleOps.upsertStyleVariable),
+	closed(styleOps.deleteStyleVariable),
+	closed(styleOps.upsertFont),
+	closed(styleOps.deleteFont)
 ];
-var documentOperation = z.discriminatedUnion("type", documentOps);
-var operation = z.discriminatedUnion("type", [
+var documentOperation = union(documentOps);
+var operation = union([
 	...documentOps,
-	connectorOps.upsertConnector,
-	connectorOps.patchConnector,
-	connectorOps.deleteConnector,
-	actionOps.upsertAction,
-	actionOps.patchAction,
-	actionOps.deleteAction,
-	functionOps.upsertFunctionFile,
-	functionOps.deleteFunctionFile,
-	dataOps.upsertDataFile,
-	dataOps.deleteDataFile
+	closed(connectorOps.upsertConnector),
+	closed(connectorOps.patchConnector),
+	closed(connectorOps.deleteConnector),
+	closed(actionOps.upsertAction),
+	closed(actionOps.patchAction),
+	closed(actionOps.deleteAction),
+	closed(functionOps.upsertFunctionFile),
+	closed(functionOps.deleteFunctionFile),
+	closed(dataOps.upsertDataFile),
+	closed(dataOps.deleteDataFile)
 ]);
 var STYLE_OP_TYPES = new Set(Object.keys(styleOps));
 var isStyleOp = (type) => STYLE_OP_TYPES.has(type);
@@ -68,5 +80,14 @@ var MAX_OPS = 1e3;
 var environment = z.string().optional().describe("Environment; default main");
 var operations = z.array(operation).max(MAX_OPS).describe(`Operations applied atomically, in order (max ${MAX_OPS})`);
 var documentOperations = z.array(documentOperation).max(MAX_OPS).describe(`Operations applied atomically, in order (max ${MAX_OPS})`);
+/** Every operation by its type — the closed vocabulary an agent picks from, and what `plitzi_describe_operation` reads. */
+var OPERATIONS_BY_TYPE = new Map(operation.options.map((variant) => [variant.shape.type.value, variant]));
+var DOCUMENT_OPERATION_TYPES = documentOperation.options.map((variant) => variant.shape.type.value);
+/**
+* `documentOperations` as advertised beside a tool that already carries the whole vocabulary (`plitzi_apply`): each
+* operation's type from the closed list, its fields left to the schema the agent already has. One copy of a ~14k-token
+* schema per connection instead of two; what runs is still parsed against the full one.
+*/
+var compactDocumentOperations = z.array(z.looseObject({ type: z.enum(DOCUMENT_OPERATION_TYPES) })).max(MAX_OPS).describe(`Operations applied atomically, in order (max ${MAX_OPS}) — the document operations of plitzi_apply, with the same fields; plitzi_describe_operation gives any one of them`);
 //#endregion
-export { MAX_OPS, documentOperation, documentOperations, environment, isStyleOp, operation, operations };
+export { MAX_OPS, OPERATIONS_BY_TYPE, compactDocumentOperations, documentOperation, documentOperations, environment, isStyleOp, operation, operations };

package/dist/modules/mcp/tools/operations/schema/bindings/upsertBinding.d.ts

@@ -21,7 +21,7 @@ export declare const upsertBindingOp: z.ZodObject<{
         }, z.core.$strip>>>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+    }, z.core.$strict>;
 }, z.core.$strip>;
 export type UpsertBinding = z.infer<typeof upsertBindingOp>;
 export declare const upsertBinding: (space: Space, env: Env, op: UpsertBinding) => OpResult;

package/dist/modules/mcp/tools/operations/schema/interactions/upsertInteractionFlow.d.ts

@@ -27,7 +27,7 @@ export declare const upsertInteractionFlowOp: z.ZodObject<{
         }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type UpsertInteractionFlow = z.infer<typeof upsertInteractionFlowOp>;
 export declare const upsertInteractionFlow: (space: Space, env: Env, op: UpsertInteractionFlow) => OpResult;

package/dist/modules/mcp/tools/operations/schema/operations.d.ts

@@ -168,7 +168,7 @@ export declare const elementOps: {
             }, import('zod/v4/core').$strip>>>;
             when: import('zod').ZodOptional<import('zod').ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, import('zod/v4/core').$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
             enabled: import('zod').ZodOptional<import('zod').ZodBoolean>;
-        }, import('zod/v4/core').$strip>;
+        }, import('zod/v4/core').$strict>;
     }, import('zod/v4/core').$strip>;
     patchBinding: import('zod').ZodObject<{
         type: import('zod').ZodLiteral<"patchBinding">;
@@ -228,7 +228,7 @@ export declare const elementOps: {
             }>>;
             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/v4/core').$strict>>;
     }, import('zod/v4/core').$strip>;
     patchInteractionNode: import('zod').ZodObject<{
         type: import('zod').ZodLiteral<"patchInteractionNode">;

package/dist/modules/mcp/tools/operations/schema/shared.d.ts

@@ -104,7 +104,7 @@ export declare const bindingInput: z.ZodObject<{
     }, z.core.$strip>>>;
     when: z.ZodOptional<z.ZodType<RuleGroup, unknown, z.core.$ZodTypeInternals<RuleGroup, unknown>>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const interactionNodeType: z.ZodEnum<{
     trigger: "trigger";
     globalCallback: "globalCallback";
@@ -132,7 +132,7 @@ export declare const interactionNode: z.ZodObject<{
     }>>;
     elementId: z.ZodOptional<z.ZodString>;
     preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 /** What the validator checks: an authored node, or one read back from storage — which may carry a `task` type the
  *  write vocabulary above does not offer. Checking the stored shape is the point; refusing it is the validator's. */
 export type InteractionNodeInput = Omit<z.infer<typeof interactionNode>, 'nodeType'> & {

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

@@ -1,3 +1,4 @@
+import { closedObject } from "../closed.js";
 import { isSuggestionCode } from "@plitzi/sdk-authoring";
 import { z } from "zod";
 import { FLAG_GATE_PATTERN } from "@plitzi/sdk-shared/flags";
@@ -111,10 +112,10 @@ var elementShape = {
 	motion: elementMotion.optional(),
 	quiet: elementQuiet.optional()
 };
-var elementInput = z.lazy(() => z.object({
+var elementInput = z.lazy(() => closedObject("An element", {
 	...elementShape,
 	children: z.array(elementInput).optional()
-}));
+}, "plitzi_describe_operation { type: \"upsertElement\" }"));
 var position = z.enum([
 	"inside",
 	"before",
@@ -135,21 +136,21 @@ var bindingTransformer = z.object({
 	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({
+var bindingInput = closedObject("A binding", {
 	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()
-});
+}, "plitzi_describe_operation { type: \"upsertBinding\" }");
 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({
+var interactionNode = closedObject("A flow step", {
 	id: z.string().optional().describe("Existing node id to preserve; generated when omitted"),
 	title: z.string().describe("Human label for the step"),
 	nodeType: interactionNodeType,
@@ -160,6 +161,6 @@ var interactionNode = z.object({
 	whileRunning: z.enum(WHILE_RUNNING_MODES).optional().describe("Trigger only: a refiring while this flow runs"),
 	elementId: z.string().optional().describe("Element whose callback this step invokes, by name; defaults to this element"),
 	preview: z.record(z.string(), z.unknown()).optional()
-});
+}, "plitzi_describe_operation { type: \"upsertInteractionFlow\" }");
 //#endregion
 export { bindingCategory, bindingInput, elementAnchor, elementFlag, elementInput, elementMotion, elementQuiet, elementRuntime, elementShape, initialStateInput, interactionNode, interactionNodeType, position, ruleGroup, scalar, styleRefs, styleVariantInput };

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

@@ -4,10 +4,10 @@ import { bindingInput, elementAnchor, elementFlag, elementInput, elementMotion,
 import { ancestors, ancestorsPatch, conditions, conditionsPatch, cssMap, cssPatchMap, definitionSlot, definitionSlotPatch, displayModeCss, displayModeCssPatch, pseudos, pseudosPatch, themeValue, variantPart, variantPartPatch } from "./style/shared.js";
 import { z } from "zod";
 //#region src/modules/mcp/tools/operations/schemaIds.ts
-/** The op union is the tool input of plitzi_apply, plitzi_validate, plitzi_render AND plitzi_preview, and every
-*  host reads it as JSON Schema on tools/list — four copies of the same 30 operations in the model's context, on
-*  EVERY request of every conversation the server is connected to. It measured ~25k tokens PER TOOL (~100k in
-*  total), which dwarfs anything a widget payload ever costs.
+/** The op union is the tool input of plitzi_apply (and of plitzi_render where apply is not listed), and every host
+*  reads it as JSON Schema on tools/list — on EVERY request of every conversation the server is connected to. It
+*  measured ~25k tokens a copy, which dwarfs anything a widget payload ever costs; one copy per connection is what
+*  `compactInputShape` keeps it to, and this keeps that copy small.
 *
 *  Most of that weight is one subschema pasted over and over: an element tree appears in upsertElement,
 *  patchElement and both repeat templates; a breakpoint CSS block in every style op; a rule group in every binding

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

@@ -13,7 +13,7 @@ export declare const renderShape: {
             after: "after";
             inside: "inside";
         }>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"repeatElement">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -31,7 +31,7 @@ export declare const renderShape: {
         }>>;
         template: z.ZodType<import('./operations/schema').TemplateElement, unknown, z.core.$ZodTypeInternals<import('./operations/schema').TemplateElement, unknown>>;
         items: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"patchElement">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -56,11 +56,11 @@ export declare const renderShape: {
         anchor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         motion: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         quiet: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteElement">;
         pageRef: z.ZodString;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"moveElement">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -70,7 +70,7 @@ export declare const renderShape: {
             after: "after";
             inside: "inside";
         }>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertPage">;
         ref: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -81,10 +81,10 @@ export declare const renderShape: {
         layoutContainer: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         flag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deletePage">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertLayout">;
         ref: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -100,19 +100,19 @@ export declare const renderShape: {
             address: "address";
             figure: "figure";
         }>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteLayout">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertFolder">;
         ref: z.ZodString;
         name: z.ZodOptional<z.ZodString>;
         slug: z.ZodOptional<z.ZodString>;
         parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteFolder">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertVariable">;
         name: z.ZodString;
         variableType: z.ZodString;
@@ -122,10 +122,10 @@ export declare const renderShape: {
             when: z.ZodUnknown;
             value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
         }, z.core.$strip>>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteVariable">;
         name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertFlag">;
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
@@ -134,10 +134,10 @@ export declare const renderShape: {
             when: z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>;
             value: z.ZodBoolean;
         }, z.core.$strip>>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteFlag">;
         name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertBinding">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -157,8 +157,8 @@ export declare const renderShape: {
             }, z.core.$strip>>>;
             when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
             enabled: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"patchBinding">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -177,7 +177,7 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteBinding">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -188,7 +188,7 @@ export declare const renderShape: {
         }>;
         to: z.ZodString;
         id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertInteractionFlow">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -214,8 +214,8 @@ export declare const renderShape: {
             }>>;
             elementId: z.ZodOptional<z.ZodString>;
             preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"patchInteractionNode">;
         pageRef: z.ZodString;
         ref: z.ZodString;
@@ -233,13 +233,13 @@ export declare const renderShape: {
         }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteInteraction">;
         pageRef: z.ZodString;
         ref: z.ZodString;
         flowId: z.ZodOptional<z.ZodString>;
         nodeId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"patchSettings">;
         customCss: z.ZodOptional<z.ZodString>;
         notifications: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
@@ -287,7 +287,7 @@ export declare const renderShape: {
             }>>;
             presence: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertComponent">;
         ref: z.ZodString;
         label: z.ZodOptional<z.ZodString>;
@@ -295,10 +295,10 @@ export declare const renderShape: {
         slots: z.ZodOptional<z.ZodArray<z.ZodString>>;
         fromRef: z.ZodOptional<z.ZodString>;
         instanceRef: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteComponent">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         mobile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -449,7 +449,7 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         type: z.ZodLiteral<"upsertDefinition">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertDefinitions">;
         definitions: z.ZodRecord<z.ZodString, z.ZodObject<{
             desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -601,7 +601,7 @@ export declare const renderShape: {
                 }, z.core.$strip>>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
         mobile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
@@ -752,10 +752,10 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         type: z.ZodLiteral<"patchDefinition">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteDefinition">;
         ref: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         mobile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -906,7 +906,7 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         type: z.ZodLiteral<"upsertGlobalStyle">;
         componentType: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
         mobile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
@@ -1057,10 +1057,10 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         type: z.ZodLiteral<"patchGlobalStyle">;
         componentType: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteGlobalStyle">;
         componentType: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         mobile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -1211,7 +1211,7 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         type: z.ZodLiteral<"upsertIdStyle">;
         targetId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
         mobile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>>;
@@ -1362,10 +1362,10 @@ export declare const renderShape: {
         }, z.core.$strip>>>;
         type: z.ZodLiteral<"patchIdStyle">;
         targetId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteIdStyle">;
         targetId: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertStyleVariable">;
         category: z.ZodEnum<{
             color: "color";
@@ -1379,7 +1379,7 @@ export declare const renderShape: {
             dark: z.ZodOptional<z.ZodString>;
             default: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>]>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteStyleVariable">;
         category: z.ZodEnum<{
             color: "color";
@@ -1388,7 +1388,7 @@ export declare const renderShape: {
             custom: "custom";
         }>;
         name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"upsertFont">;
         family: z.ZodString;
         source: z.ZodEnum<{
@@ -1417,10 +1417,10 @@ export declare const renderShape: {
             url: z.ZodOptional<z.ZodString>;
             path: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"deleteFont">;
         family: z.ZodString;
-    }, z.core.$strip>], "type">>;
+    }, z.core.$strict>], "type">>;
     patch: z.ZodOptional<z.ZodBoolean>;
     renderId: z.ZodOptional<z.ZodString>;
 };

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

@@ -2,7 +2,7 @@ import { iconFontCss } from "../apps/render/styles.js";
 import { RENDER_APP_URI } from "../apps/render/index.js";
 import { emptySpace } from "../helpers/space.js";
 import { proxifyResources } from "../proxy/rewrite.js";
-import { documentOperations } from "./operations/index.js";
+import { compactDocumentOperations, documentOperations } from "./operations/index.js";
 import { draftBatch } from "./shared/draftBatch.js";
 import { defineTool } from "./shared/tool.js";
 import { interactionReport } from "./shared/interactionReport.js";
@@ -146,6 +146,10 @@ var renderTool = defineTool({
 	title: "Render widget",
 	description: "Show the user a real, rendered UI widget instead of describing one — cards, hero sections, pricing tables, forms, menus, checklists, profiles, galleries. It runs the Plitzi SDK fully offline: no backend, account, or setup. Reach for it whenever a visual layout beats prose: the user asks you to design/build/show something, OR your answer is naturally visual (a recipe → a card, a comparison → a table, steps → a checklist). Prefer showing over telling.\n\nAuthor the widget as an ordered list of `operations` that build an element tree under the pre-seeded root page \"render\". Three rules:\n1. STRUCTURE — one upsertElement builds the whole tree: set pageRef:\"render\" and give element a nested `children` array. Each element is { ref (unique), type, subType?, props?, style?, children? }; children render in order. (To attach to something you already made, use a top-level parentRef:\"<existing ref>\" instead.)\n1b. REPEATS — the moment two siblings share a shape and differ only in data (list, steps, cards, table, timeline), do NOT copy-paste them: use repeatElement { pageRef, ref (wrapper), style, template, items }. The template is written once with {{item.field}} placeholders and rendered per row; refs come out numbered (\"step-1\", \"step-2\"…). A list INSIDE each row (days with their own steps) is the same op: give the wrapping node repeat:{ items:\"{{item.<list>}}\", template:… } and put the sub-rows in the row data.\n2. STYLE — declare ALL the classes in ONE upsertDefinitions { definitions: { \"<class>\": { desktop:{ …CSS in kebab-case… } }, … } }, then attach via the element style:{ base:[\"<class ref>\"] }. Lay containers out with flex/grid. Keep the call small: one class per look, not per property.\n2a. GRAPHICS — a logo, a sparkline, a badge, a decorative shape: draw it as an INLINE <svg> in a blockHtml element (props.content), keeping a viewBox with width/height \"100%\" so its class sizes it, and fill/stroke \"currentColor\" so it follows the host theme. Budget it: a handful of paths, drawn once and reused, never a data: URI and never a full illustration — a photo-real scene costs more than the whole widget, so use an https image, a flat colour or a gradient for that. Markup only: scripts and on* handlers are rejected.\n2b. LAYOUT — it renders in a side panel, so width is free and HEIGHT is scarce. Plain containers stack children vertically, which is the tall half-empty default to avoid: put peers (metrics, plans, options, image + text) in a wrapping row — display:flex, flex-direction:row, flex-wrap:wrap, children flex-grow:\"1\" + flex-basis:\"0%\" + min-width — or a grid with grid-template-columns:\"repeat(auto-fit, minmax(160px, 1fr))\". Keep padding 12-16px and gap 8-12px, and let the outer container fill the panel. Stack only what reads in order (heading over paragraph, forms, steps, prose). Nothing carries a minimum size, so an element with no content and no size takes none — give a spacer or a rail its own height/width — while heading/paragraph do keep the margins the browser gives them (zero them, space with the parent gap).\n2c. THEME — it is embedded in the host UI, which MAY BE DARK, so never hardcode a light palette. Take colours from the host variables with a light-dark() fallback — background-color:\"var(--color-background-secondary, light-dark(#ffffff, #1f2430))\", color:\"var(--color-text-primary, light-dark(#0f172a, #e8eaed))\", border-color:\"var(--color-border-primary, light-dark(#e2e8f0, #333a48))\" — and always set `color` wherever you set `background-color` (a brand accent states its own text colour too).\n3. CONTENT — visible copy goes in props.content (text, heading, paragraph, button); heading level is the element subType (\"h1\"..\"h6\"); image/video take props.src. Write real https URLs: everything the widget loads from outside (images, media, fonts, an apiContainer endpoint) is fetched for it by the render server, so redirects and hotlink rules are handled and there is nothing to configure. It must still point at the actual file — use a URL you have seen work, and when you have none, draw the block with a gradient or an inline SVG instead of guessing one. An unknown prop comes back as a warning naming the right one.\n\nCommon types: container, heading, paragraph, text, button, link, image, video, list, listItem, markdown (plitzi://render/types lists every built-in type with descriptions). Widgets can also be data-driven and interactive — an apiContainer fetches at runtime, upsertBinding wires data into elements, and upsertInteractionFlow makes them react to clicks (see the guide).\nREAD the resource plitzi://render/guide first — it has the element/prop table, the style model and a full worked example, and following it is the difference between a widget that renders and repeated failed calls.\nITERATING — to change a widget you already rendered, do NOT rebuild it: call again with patch:true, the `renderId` that render answered with, and ONLY the operations that differ (patchDefinition, patchElement, deleteElement…). The widget merges them and reports back what it applied; address rows by the refs you already know. Patch ONLY to modify that widget: a different subject or a different kind of widget is a fresh render, without patch — a patch is merged into the previous batch, so patching a new idea leaves you with both.\nReturns a compact summary including the renderId (the widget itself is shown to the user), plus — when the widget has interaction flows — an `interactions` line per flow naming what got wired to what. That reports the WIRING, not that a click was performed: say what you connected, never that you verified it at runtime. On failure it returns teachable errors (path + hint) — read them and retry.",
 	inputShape: renderShape,
+	compactInputShape: {
+		...renderShape,
+		operations: compactDocumentOperations
+	},
 	access: "read",
 	spaceless: true,
 	ui: { resourceUri: RENDER_APP_URI },

package/dist/modules/mcp/tools/shared/draftBatch.d.ts

@@ -17,9 +17,10 @@ export type DraftResult = {
 };
 /**
  * A batch run on a copy of the space and read back — the one way every tool that takes operations handles them, so
- * `plitzi_validate` answers exactly what `plitzi_apply` would, and `plitzi_render` holds a widget to the same rules.
+ * a `dryRun` answers exactly what `plitzi_apply` would save, and `plitzi_render` holds a widget to the same rules.
  *
- * In order: the sugar ops expanded; what was already wrong with the elements the batch touches fixed where it has one
+ * In order: the sugar ops expanded; what has one reading read that way (`normalizeOperations`, said in `warnings`);
+ * what was already wrong with the elements the batch touches fixed where it has one
  * reading (`fixTouched`, each fix said in `warnings`); each op checked against the input it takes; the batch applied to
  * the copy; and the copy read by `lintDraft` — structure and meaning, the same reading every other writer gets. The
  * first stage to refuse ends it; the space handed in is never touched.