@plitzi/sdk-mcp 0.37.2 → 0.37.4

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

@@ -1,13 +1,9 @@
-import { cloneSpace } from "../../helpers/space.js";
-import { environment, operations } from "../operations/index.js";
-import { applyOperations } from "./dispatch.js";
+import { functionFileUri, functionsUri } from "../../helpers/uris.js";
 import { changedResources, conflictMessage, detectConflicts, resolvedElements } from "./writeResult.js";
-import { expandOperations } from "../shared/expandOperations.js";
+import { environment, operations } from "../operations/index.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";
 import { z } from "zod";
-import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
 import { generateCache } from "@plitzi/sdk-style/StyleHelper";
 //#region src/modules/mcp/tools/apply/index.ts
 var applyShape = {
@@ -17,39 +13,18 @@ var applyShape = {
 	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."
-});
+/** Why the platform did not save the functions, as the batch's errors: each problem where it is, or the refusal. */
+var functionsErrors = (saved, env) => "problems" in saved ? saved.problems.map((problem) => ({
+	path: problem.file ? `functions/${problem.file}${problem.line ? `:${String(problem.line)}` : ""}` : "functions",
+	message: problem.message,
+	hint: `Fix it with upsertFunctionFile; read ${functionFileUri(env, problem.file ?? "index.ts")} for the file`
+})) : [{
+	path: "functions",
+	message: saved.refusal.error,
+	hint: `Read ${functionsUri(env)} again and redo the change on the current files`
+}];
 var apply = async (input, space, persisters) => {
 	const env = input.environment ?? "main";
-	const expansion = expandOperations(input.operations);
-	if (expansion.errors.length > 0) return {
-		applied: false,
-		persisted: false,
-		summary: {
-			created: 0,
-			updated: 0,
-			deleted: 0
-		},
-		changed: [],
-		errors: expansion.errors
-	};
-	const ops = expansion.operations;
-	const validation = validateOperations(space, ops);
-	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,
@@ -65,9 +40,8 @@ var apply = async (input, space, persisters) => {
 			conflicts
 		}
 	};
-	const draft = cloneSpace(space);
-	const outcome = applyOperations(draft, env, ops);
-	if (outcome.errors.length > 0) return {
+	const result = draftBatch(space, env, input.operations);
+	if (!result.ok) return {
 		applied: false,
 		persisted: false,
 		summary: {
@@ -76,36 +50,10 @@ var apply = async (input, space, persisters) => {
 			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)
-	};
-	const audit = auditResources(draft, ops);
-	const warnings = [...validation.warnings, ...audit.warnings];
-	if (audit.errors.length > 0) return {
-		applied: false,
-		persisted: false,
-		summary: {
-			created: 0,
-			updated: 0,
-			deleted: 0
-		},
-		changed: [],
-		errors: audit.errors,
-		warnings: noWarnings(warnings)
+		errors: result.errors,
+		warnings: noWarnings(result.warnings)
 	};
+	const { draft, outcome, warnings } = result;
 	if (input.dryRun) return {
 		applied: false,
 		dryRun: true,
@@ -119,6 +67,23 @@ var apply = async (input, space, persisters) => {
 		warnings: noWarnings(warnings)
 	};
 	let persisted = true;
+	if (outcome.changedFunctions && draft.functions) {
+		if (persisters?.saveFunctions) {
+			const saved = await persisters.saveFunctions(draft.functions.files, space.functions?.version ?? "");
+			if (!saved.ok) return {
+				applied: false,
+				persisted: false,
+				summary: {
+					created: 0,
+					updated: 0,
+					deleted: 0
+				},
+				changed: [],
+				errors: functionsErrors(saved, env),
+				warnings: noWarnings(warnings)
+			};
+		} else persisted = false;
+	}
 	if (outcome.changedSchema) {
 		if (persisters?.schema) await persisters.schema(draft.schema);
 		else persisted = false;

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

@@ -1,12 +1,13 @@
 import { operation } from "./operations/index.js";
-import { applyOperations } from "./apply/dispatch.js";
 import { validateOperations } from "./shared/validator/index.js";
+import { applyOperations } from "./apply/dispatch.js";
 import { apply, applyShape, applyTool } from "./apply/index.js";
 import { previewTool } from "./preview.js";
 import { read, readShape, readTool } from "./read.js";
 import { renderTool } from "./render.js";
 import { screenshotTool } from "./screenshot.js";
 import { search, searchShape, searchTool } from "./search.js";
+import { tryFunctionTool } from "./tryFunction.js";
 import { validate, validateShape, validateTool } from "./validate.js";
 //#region src/modules/mcp/tools/index.ts
 /** The MCP tool registry — the single source both hosts (the standalone server and the in-process AI bridge)
@@ -18,7 +19,8 @@ var tools = [
 	readTool,
 	renderTool,
 	previewTool,
-	screenshotTool
+	screenshotTool,
+	tryFunctionTool
 ];
 //#endregion
 export { apply, applyOperations, applyShape, operation, read, readShape, search, searchShape, tools, validate, validateOperations, validateShape };

package/dist/modules/mcp/tools/operations/connectors/manifest.d.ts

@@ -86,4 +86,3 @@ export declare const connectorConnection: z.ZodObject<{
     }>>>;
     projection: z.ZodOptional<z.ZodLiteral<"full">>;
 }, z.core.$strip>;
-export type ConnectorConnectionInput = z.infer<typeof connectorConnection>;

package/dist/modules/mcp/tools/operations/functions/functions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/mcp/tools/operations/functions/index.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { OpResult, Space } from '../../../helpers';
+import { Env } from '../../../types';
+export declare const upsertFunctionFileOp: z.ZodObject<{
+    type: z.ZodLiteral<"upsertFunctionFile">;
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const deleteFunctionFileOp: z.ZodObject<{
+    type: z.ZodLiteral<"deleteFunctionFile">;
+    path: z.ZodString;
+}, z.core.$strip>;
+export type UpsertFunctionFile = z.infer<typeof upsertFunctionFileOp>;
+export type DeleteFunctionFile = z.infer<typeof deleteFunctionFileOp>;
+/**
+ * The functions are one store of files, saved whole: an op edits the draft's copy, and the batch saves the files it
+ * leaves — built and checked by the platform then, which is where a problem in them is found and answered.
+ */
+export declare const upsertFunctionFile: (space: Space, env: Env, op: UpsertFunctionFile) => OpResult;
+export declare const deleteFunctionFile: (space: Space, env: Env, op: DeleteFunctionFile) => OpResult;
+export declare const functionOps: {
+    upsertFunctionFile: z.ZodObject<{
+        type: z.ZodLiteral<"upsertFunctionFile">;
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    deleteFunctionFile: z.ZodObject<{
+        type: z.ZodLiteral<"deleteFunctionFile">;
+        path: z.ZodString;
+    }, z.core.$strip>;
+};

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

@@ -0,0 +1,48 @@
+import { functionFileUri, functionsUri } from "../../../helpers/uris.js";
+import { empty, fail } from "../../../helpers/opResult.js";
+import { z } from "zod";
+//#region src/modules/mcp/tools/operations/functions/index.ts
+var upsertFunctionFileOp = z.object({
+	type: z.literal("upsertFunctionFile"),
+	path: z.string().describe("e.g. \"index.ts\", \"lib/feed.ts\""),
+	content: z.string().describe("The whole file")
+}).describe("Write one file of the space’s functions (its own server code), whole. See plitzi://guide.");
+var deleteFunctionFileOp = z.object({
+	type: z.literal("deleteFunctionFile"),
+	path: z.string()
+}).describe("Remove one file of the space’s functions.");
+var unavailable = () => fail("type", "This deployment runs no space functions", "Author the flow from the server tasks it offers instead");
+/**
+* The functions are one store of files, saved whole: an op edits the draft's copy, and the batch saves the files it
+* leaves — built and checked by the platform then, which is where a problem in them is found and answered.
+*/
+var upsertFunctionFile = (space, env, op) => {
+	if (!space.functions) return unavailable();
+	const exists = Object.hasOwn(space.functions.files, op.path);
+	space.functions.files = {
+		...space.functions.files,
+		[op.path]: op.content
+	};
+	return {
+		...empty(),
+		...exists ? { updated: 1 } : { created: 1 },
+		staleResources: [functionsUri(env), functionFileUri(env, op.path)]
+	};
+};
+var deleteFunctionFile = (space, env, op) => {
+	if (!space.functions) return unavailable();
+	if (!Object.hasOwn(space.functions.files, op.path)) return fail("path", `The functions have no file "${op.path}"`, `Read ${functionsUri(env)} for the files they have`, Object.keys(space.functions.files));
+	const { [op.path]: _removed, ...files } = space.functions.files;
+	space.functions.files = files;
+	return {
+		...empty(),
+		deleted: 1,
+		staleResources: [functionsUri(env), functionFileUri(env, op.path)]
+	};
+};
+var functionOps = {
+	upsertFunctionFile: upsertFunctionFileOp,
+	deleteFunctionFile: deleteFunctionFileOp
+};
+//#endregion
+export { deleteFunctionFile, deleteFunctionFileOp, functionOps, upsertFunctionFile, upsertFunctionFileOp };

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

@@ -187,6 +187,11 @@ export declare const documentOperation: z.ZodDiscriminatedUnion<readonly [z.ZodO
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+        whileRunning: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            parallel: "parallel";
+            queue: "queue";
+        }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
@@ -200,6 +205,11 @@ export declare const documentOperation: z.ZodDiscriminatedUnion<readonly [z.ZodO
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+    whileRunning: z.ZodOptional<z.ZodEnum<{
+        skip: "skip";
+        parallel: "parallel";
+        queue: "queue";
+    }>>;
     elementId: z.ZodOptional<z.ZodString>;
     preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -216,6 +226,8 @@ export declare const documentOperation: z.ZodDiscriminatedUnion<readonly [z.ZodO
         localStorage: "localStorage";
         sessionStorage: "sessionStorage";
     }>>;
+    transientState: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paintedState: z.ZodOptional<z.ZodArray<z.ZodString>>;
     userProvider: z.ZodOptional<z.ZodString>;
     tokenStorage: z.ZodOptional<z.ZodEnum<{
         "": "";
@@ -238,6 +250,21 @@ export declare const documentOperation: z.ZodDiscriminatedUnion<readonly [z.ZodO
         strict: "strict";
     }>>;
     sessionRevalidateSeconds: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+        access: z.ZodObject<{
+            mode: z.ZodEnum<{
+                public: "public";
+                session: "session";
+                role: "role";
+            }>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        publish: z.ZodOptional<z.ZodEnum<{
+            server: "server";
+            clients: "clients";
+        }>>;
+        presence: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>, 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]>>>;
@@ -917,6 +944,11 @@ export declare const operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+        whileRunning: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            parallel: "parallel";
+            queue: "queue";
+        }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
@@ -930,6 +962,11 @@ export declare const operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+    whileRunning: z.ZodOptional<z.ZodEnum<{
+        skip: "skip";
+        parallel: "parallel";
+        queue: "queue";
+    }>>;
     elementId: z.ZodOptional<z.ZodString>;
     preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -946,6 +983,8 @@ export declare const operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         localStorage: "localStorage";
         sessionStorage: "sessionStorage";
     }>>;
+    transientState: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paintedState: z.ZodOptional<z.ZodArray<z.ZodString>>;
     userProvider: z.ZodOptional<z.ZodString>;
     tokenStorage: z.ZodOptional<z.ZodEnum<{
         "": "";
@@ -968,6 +1007,21 @@ export declare const operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         strict: "strict";
     }>>;
     sessionRevalidateSeconds: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+        access: z.ZodObject<{
+            mode: z.ZodEnum<{
+                public: "public";
+                session: "session";
+                role: "role";
+            }>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        publish: z.ZodOptional<z.ZodEnum<{
+            server: "server";
+            clients: "clients";
+        }>>;
+        presence: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>, 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]>>>;
@@ -1720,12 +1774,17 @@ export declare const operation: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"deleteAction">;
     ref: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsertFunctionFile">;
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteFunctionFile">;
+    path: z.ZodString;
 }, z.core.$strip>], "type">;
 export type Operation = z.infer<typeof operation>;
 export type OperationType = Operation['type'];
 export declare const isStyleOp: (type: OperationType) => boolean;
-export declare const isConnectorOp: (type: OperationType) => boolean;
-export declare const isActionOp: (type: OperationType) => boolean;
 export declare const MAX_OPS = 1000;
 export declare const environment: z.ZodOptional<z.ZodString>;
 export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1914,6 +1973,11 @@ export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+        whileRunning: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            parallel: "parallel";
+            queue: "queue";
+        }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
@@ -1927,6 +1991,11 @@ export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+    whileRunning: z.ZodOptional<z.ZodEnum<{
+        skip: "skip";
+        parallel: "parallel";
+        queue: "queue";
+    }>>;
     elementId: z.ZodOptional<z.ZodString>;
     preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -1943,6 +2012,8 @@ export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject
         localStorage: "localStorage";
         sessionStorage: "sessionStorage";
     }>>;
+    transientState: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paintedState: z.ZodOptional<z.ZodArray<z.ZodString>>;
     userProvider: z.ZodOptional<z.ZodString>;
     tokenStorage: z.ZodOptional<z.ZodEnum<{
         "": "";
@@ -1965,6 +2036,21 @@ export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject
         strict: "strict";
     }>>;
     sessionRevalidateSeconds: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+        access: z.ZodObject<{
+            mode: z.ZodEnum<{
+                public: "public";
+                session: "session";
+                role: "role";
+            }>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        publish: z.ZodOptional<z.ZodEnum<{
+            server: "server";
+            clients: "clients";
+        }>>;
+        presence: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>, 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]>>>;
@@ -2717,6 +2803,13 @@ export declare const operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"deleteAction">;
     ref: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsertFunctionFile">;
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteFunctionFile">;
+    path: z.ZodString;
 }, z.core.$strip>], "type">>;
 export declare const documentOperations: z.ZodArray<z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"upsertElement">;
@@ -2904,6 +2997,11 @@ export declare const documentOperations: z.ZodArray<z.ZodDiscriminatedUnion<read
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+        whileRunning: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            parallel: "parallel";
+            queue: "queue";
+        }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>;
@@ -2917,6 +3015,11 @@ export declare const documentOperations: z.ZodArray<z.ZodDiscriminatedUnion<read
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+    whileRunning: z.ZodOptional<z.ZodEnum<{
+        skip: "skip";
+        parallel: "parallel";
+        queue: "queue";
+    }>>;
     elementId: z.ZodOptional<z.ZodString>;
     preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -2933,6 +3036,8 @@ export declare const documentOperations: z.ZodArray<z.ZodDiscriminatedUnion<read
         localStorage: "localStorage";
         sessionStorage: "sessionStorage";
     }>>;
+    transientState: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    paintedState: z.ZodOptional<z.ZodArray<z.ZodString>>;
     userProvider: z.ZodOptional<z.ZodString>;
     tokenStorage: z.ZodOptional<z.ZodEnum<{
         "": "";
@@ -2955,6 +3060,21 @@ export declare const documentOperations: z.ZodArray<z.ZodDiscriminatedUnion<read
         strict: "strict";
     }>>;
     sessionRevalidateSeconds: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+        access: z.ZodObject<{
+            mode: z.ZodEnum<{
+                public: "public";
+                session: "session";
+                role: "role";
+            }>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        publish: z.ZodOptional<z.ZodEnum<{
+            server: "server";
+            clients: "clients";
+        }>>;
+        presence: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>, 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]>>>;

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

@@ -1,5 +1,6 @@
 import { actionOps } from "./actions/index.js";
 import { connectorOps } from "./connectors/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";
@@ -50,11 +51,11 @@ var operation = z.discriminatedUnion("type", [
 	connectorOps.deleteConnector,
 	actionOps.upsertAction,
 	actionOps.patchAction,
-	actionOps.deleteAction
+	actionOps.deleteAction,
+	functionOps.upsertFunctionFile,
+	functionOps.deleteFunctionFile
 ]);
 var STYLE_OP_TYPES = new Set(Object.keys(styleOps));
-new Set(Object.keys(connectorOps));
-new Set(Object.keys(actionOps));
 var isStyleOp = (type) => STYLE_OP_TYPES.has(type);
 var MAX_OPS = 1e3;
 var environment = z.string().optional().describe("Environment; default main");

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

@@ -1,8 +1,9 @@
-import { descendantIds, findRootByRef, indexRemoveElements, resolveRef } from "../../../../helpers/space.js";
+import { findRootByRef, indexRemoveElements, resolveRef } from "../../../../helpers/space.js";
 import { pageUri } from "../../../../helpers/uris.js";
 import { empty, fail } from "../../../../helpers/opResult.js";
-import { removeFromParent } from "../write.js";
+import { descendants } from "@plitzi/sdk-schema/helpers/elementTree";
 import { z } from "zod";
+import FlatMap from "@plitzi/sdk-schema/helpers/FlatMap";
 //#region src/modules/mcp/tools/operations/schema/elements/deleteElement.ts
 var deleteElementOp = z.object({
 	type: z.literal("deleteElement"),
@@ -14,10 +15,8 @@ var deleteElement = (space, env, op) => {
 	if (!page) return fail("pageRef", `Page or layout "${op.pageRef}" not found`, "Read the pages resource for valid refs");
 	const el = resolveRef(space.schema, page, op.ref);
 	if (!el || el.id === page.id) return fail("ref", `Element "${op.ref}" not found in page "${op.pageRef}"`, "Read the page resource for valid refs");
-	const ids = [...descendantIds(space.schema, el.id), el.id];
-	const removed = ids.map((id) => space.schema.flat[id]);
-	for (const id of ids) Reflect.deleteProperty(space.schema.flat, id);
-	removeFromParent(space, el);
+	const removed = [el.id, ...descendants(space.schema.flat, el.id)].map((id) => space.schema.flat[id]);
+	new FlatMap({ flat: space.schema.flat }).removeElement(el.id);
 	indexRemoveElements(space.schema, removed);
 	return {
 		...empty(),

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

@@ -2,8 +2,9 @@ import { findRootByRef, indexInvalidateDetails, resolveRef } from "../../../../h
 import { pageUri } from "../../../../helpers/uris.js";
 import { empty, fail } from "../../../../helpers/opResult.js";
 import { position } from "../shared.js";
-import { placeChild, removeFromParent } from "../write.js";
+import { DROP_POSITION } from "../write.js";
 import { z } from "zod";
+import FlatMap from "@plitzi/sdk-schema/helpers/FlatMap";
 //#region src/modules/mcp/tools/operations/schema/elements/moveElement.ts
 var moveElementOp = z.object({
 	type: z.literal("moveElement"),
@@ -19,16 +20,7 @@ var moveElement = (space, env, op) => {
 	const anchor = resolveRef(space.schema, page, op.toParentRef);
 	if (!el || el.id === page.id) return fail("ref", `Element "${op.ref}" not found`, "Read the page resource for valid refs");
 	if (!anchor) return fail("toParentRef", `Target "${op.toParentRef}" not found`, "Read the page resource for valid refs");
-	removeFromParent(space, el);
-	let parent = anchor;
-	let index;
-	if (op.position === "before" || op.position === "after") {
-		parent = anchor.definition.parentId ? space.schema.flat[anchor.definition.parentId] ?? page : page;
-		const at = (parent.definition.items ?? []).indexOf(anchor.id);
-		index = at < 0 ? void 0 : op.position === "after" ? at + 1 : at;
-	}
-	el.definition.parentId = parent.id;
-	placeChild(parent, el.id, index);
+	if (!new FlatMap({ flat: space.schema.flat }).moveElement(el.definition.parentId ?? page.id, anchor.id, el.id, DROP_POSITION[op.position])) return fail("toParentRef", `"${op.ref}" cannot move ${op.position} "${op.toParentRef}"`, "An element cannot move inside itself or one of its own descendants, and before/after needs an anchor that has a parent.");
 	indexInvalidateDetails(space.schema);
 	return {
 		...empty(),

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

@@ -2,7 +2,7 @@ import { findRootByRef, resolveRef } from "../../../../helpers/space.js";
 import { pageUri } from "../../../../helpers/uris.js";
 import { empty, fail } from "../../../../helpers/opResult.js";
 import { elementInput, position } from "../shared.js";
-import { collectInputRefs, createElement, guardNewRef, writeInitialState } from "../write.js";
+import { DROP_POSITION, collectInputRefs, createElement, guardNewRef, writeInitialState } from "../write.js";
 import { z } from "zod";
 //#region src/modules/mcp/tools/operations/schema/elements/upsertElement.ts
 var upsertElementOp = z.object({
@@ -43,18 +43,15 @@ var upsertElement = (space, env, op) => {
 		const guard = guardNewRef(space, ref, "element.ref");
 		if (guard) return guard;
 	}
-	let parent = page;
-	let index;
+	let anchorId = page.id;
+	let drop = "inside";
 	if (op.parentRef) {
 		const anchor = resolveRef(space.schema, page, op.parentRef);
 		if (!anchor) return fail("parentRef", `Parent "${op.parentRef}" not found in page "${op.pageRef}"`, "Use an existing ref");
-		if (op.position === "before" || op.position === "after") {
-			parent = anchor.definition.parentId ? space.schema.flat[anchor.definition.parentId] : page;
-			const at = (parent.definition.items ?? []).indexOf(anchor.id);
-			index = at < 0 ? void 0 : op.position === "after" ? at + 1 : at;
-		} else parent = anchor;
+		anchorId = anchor.id;
+		drop = DROP_POSITION[op.position ?? "inside"];
 	}
-	createElement(space, page, op.element, parent, index);
+	if (!createElement(space, page, op.element, anchorId, drop)) return fail("parentRef", `"${op.element.ref}" cannot be placed ${op.position ?? "inside"} "${op.parentRef ?? op.pageRef}"`, "An element goes inside an element that holds children, or before/after one that has a parent — a page has no siblings.");
 	return {
 		...empty(),
 		created: 1,

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

@@ -11,6 +11,11 @@ export declare const patchInteractionNodeOp: z.ZodObject<{
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+    whileRunning: z.ZodOptional<z.ZodEnum<{
+        skip: "skip";
+        parallel: "parallel";
+        queue: "queue";
+    }>>;
     elementId: z.ZodOptional<z.ZodString>;
     preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;

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

@@ -5,7 +5,7 @@ import { interactionNode } from "../shared.js";
 import { resolveElement, resolveTargetRef } from "../write.js";
 import { z } from "zod";
 //#region src/modules/mcp/tools/operations/schema/interactions/patchInteractionNode.ts
-var { title, action, params, enabled, when, elementId, preview } = interactionNode.shape;
+var { title, action, params, enabled, when, whileRunning, elementId, preview } = interactionNode.shape;
 var patchInteractionNodeOp = z.object({
 	type: z.literal("patchInteractionNode"),
 	pageRef: z.string().describe("The page, by name"),
@@ -16,6 +16,7 @@ var patchInteractionNodeOp = z.object({
 	params: params.describe("Merged onto the node params: listed keys change, others are preserved"),
 	enabled,
 	when,
+	whileRunning,
 	elementId,
 	preview
 }).describe("Partially update ONE step of a flow (found by nodeId): only the fields you pass change, the order/links are untouched. This is how you DISABLE a step without removing it — { enabled: false } keeps it in the flow. deleteInteraction is for actually removing one. Fails if the node does not exist.");
@@ -32,6 +33,7 @@ var patchInteractionNode = (space, env, op) => {
 	};
 	if (op.enabled !== void 0) node.enabled = op.enabled;
 	if (op.when !== void 0) node.when = op.when;
+	if (op.whileRunning !== void 0) node.whileRunning = op.whileRunning;
 	if (op.elementId !== void 0) node.elementId = resolveTargetRef(space, op.elementId);
 	if (node.type === "utility") node.elementId = null;
 	else if (typeof node.elementId === "string" && NULLISH_ELEMENT_IDS.has(node.elementId)) node.elementId = null;