@oomol-lab/open-flow 0.1.0-beta.85 → 0.1.0-beta.86

package/dist/common/workflow.js

@@ -22,7 +22,7 @@ function dequal(foo, bar) {
 	return foo !== foo && bar !== bar;
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/util.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
 	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
@@ -347,6 +347,17 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
 	return typeof message === "string" ? message : message?.message;
 }
+/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
+function sizeCaps(defChecks) {
+	const caps = [];
+	for (const ch of defChecks ?? []) {
+		const d = ch._zod.def;
+		if (!/_(length|size)$|_equals$/.test(d.check)) break;
+		const max = d.maximum ?? d.length ?? d.size;
+		if (max >= 0) caps.push([max, ch]);
+	}
+	return caps;
+}
 function attachSchema(issues, start, inst) {
 	var _a;
 	for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);
@@ -563,7 +574,7 @@ function constantCatch(value) {
 	return fn;
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/core.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/core.js
 var _a$1;
 var _zodDesc = {
 	value: void 0,
@@ -669,7 +680,7 @@ function config(newConfig) {
 	return globalConfig;
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/errors.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/errors.js
 function _getMessage() {
 	const internals = this._zod;
 	internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
@@ -785,7 +796,7 @@ function formatError(error, mapper = (issue) => issue.message) {
 	return fieldErrors;
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/parse.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/parse.js
 function finalizeParams(callee, params) {
 	return {
 		callee: params?.callee ?? callee,
@@ -988,7 +999,7 @@ var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 	return _safeParseAsync(_Err)(schema, value, _ctx);
 };
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/regexes.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/regexes.js
 /**
 * @deprecated CUID v1 is deprecated by its authors due to information leakage
 * (timestamps embedded in the id). Use {@link cuid2} instead.
@@ -1061,7 +1072,7 @@ var _null$2 = /^null$/i;
 var lowercase = /^[^A-Z]*$/;
 var uppercase = /^[^a-z]*$/;
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/checks.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/checks.js
 var $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def) => {
 	var _a;
 	inst._zod ?? (inst._zod = {});
@@ -1357,7 +1368,7 @@ var $ZodCheckOverwrite = /*@__PURE__*/ $constructor("$ZodCheckOverwrite", (inst,
 	};
 });
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/doc.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/doc.js
 var Doc = class {
 	constructor(args = [], closed = {}) {
 		this.content = [];
@@ -1391,14 +1402,14 @@ var Doc = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/versions.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/versions.js
 var version = {
 	major: 4,
 	minor: 6,
-	patch: 5
+	patch: 7
 };
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/schemas.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/schemas.js
 var $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
 	var _a;
 	inst ?? (inst = {});
@@ -1911,6 +1922,26 @@ var $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def) => {
 		return payload;
 	};
 });
+function capSize(inst, size) {
+	const caps = sizeCaps(inst._zod.def.checks);
+	if (!caps.length) return;
+	const cap = Math.min(...caps.map((c) => c[0]));
+	const parse = inst._zod.parse;
+	inst._zod.parse = (payload, ctx) => {
+		const n = size(payload.value);
+		if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+			for (const [max, ch] of sizeCaps(inst._zod.def.checks)) if (n > max && ch._zod.def.when(payload)) {
+				const start = payload.issues.length;
+				ch._zod.check(payload);
+				payload.issues[start].continue = false;
+				attachSchema(payload.issues, start, inst);
+				return payload;
+			}
+		}
+		return parse(payload, ctx);
+	};
+}
+var arraySize = (input) => Array.isArray(input) ? input.length : -1;
 function handleArrayResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
@@ -1948,6 +1979,7 @@ var $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def) => {
 		if (proms.length) return Promise.all(proms).then(() => payload);
 		return payload;
 	};
+	capSize(inst, arraySize);
 });
 function handlePropertyResult(result, final, key, input, optin, optout) {
 	const isPresent = key in input;
@@ -2799,7 +2831,7 @@ function handleRefineResult(result, payload, input, inst) {
 	}
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/memoizer.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/memoizer.js
 var $ZodCyclicError = class extends Error {
 	constructor() {
 		super(`Cannot parse a reference cycle that closes through a transform`);
@@ -3052,7 +3084,7 @@ function isBackEdge(ctx, value) {
 	return backEdges !== void 0 && isRef(value) && backEdges.has(value);
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/locales/en.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/locales/en.js
 var error = () => {
 	const Sizable = {
 		string: {
@@ -3160,7 +3192,7 @@ function en_default() {
 	return { localeError: error() };
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/registries.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/registries.js
 var _a;
 var $ZodRegistry = class {
 	constructor() {
@@ -3207,7 +3239,7 @@ function registry() {
 (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
 var globalRegistry = globalThis.__zod_globalRegistry;
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/api.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/api.js
 function snapshotChecks(def) {
 	if (def.checks) def.checks = [...def.checks];
 	return def;
@@ -3723,7 +3755,7 @@ function _check(fn, params) {
 	return ch;
 }
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/to-json-schema.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/to-json-schema.js
 function assignProps(target, ...sources) {
 	for (const source of sources) for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProp(target, key, source[key]);
 	return target;
@@ -4167,7 +4199,7 @@ var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) =
 	return finalize(ctx, schema);
 };
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/json-schema-processors.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/json-schema-processors.js
 var narrowMin = (agg, key, value) => {
 	if (agg[key] === void 0 || value > agg[key]) agg[key] = value;
 };
@@ -4628,7 +4660,7 @@ var lazyProcessor = (schema, ctx, _json, params) => {
 	seen.ref = innerType;
 };
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/errors.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/classic/errors.js
 var _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
 function _lazyMethod(proto, key, make) {
 	Object.defineProperty(proto, key, {
@@ -4678,7 +4710,7 @@ var initializer = (inst, issues) => {
 };
 var ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/parse.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/classic/parse.js
 var parse = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -4692,7 +4724,7 @@ var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
 var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 //#endregion
-//#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/classic/schemas.js
+//#region ../../node_modules/.bun/zod@4.6.7/node_modules/zod/v4/classic/schemas.js
 function _ensureDefaultLocale() {
 	if (!globalConfig.localeError) config(en_default());
 }

package/dist/common/workflowAuthoring.d.ts

@@ -0,0 +1,411 @@
+import type { JsonValue } from './flow-change.js';
+import type { WorkflowFile } from './flow-workflowFile.js';
+import type { ControlClient } from './control-api.js';
+import type { AuthoringHost, AuthoringRead, AuthoringRequest, AuthoringSearch, AuthoringType } from './authoring.js';
+export interface WorkflowAuthoringOptions {
+    /** Flow API metadata is already normalized; no Connector catalog adapter runs here. */
+    readonly client?: ControlClient;
+    readonly locale?: string;
+    readonly engineContract?: string;
+    /** Override only for callers that own their deterministic node/module identity scope. */
+    readonly id?: AuthoringHost['id'];
+}
+/** File objects in, file objects out. Persistence and transport belong to the caller. */
+export declare function createWorkflowAuthoring(options?: WorkflowAuthoringOptions): {
+    create(metadata?: Omit<WorkflowFile, 'kind' | 'version' | 'content'>): WorkflowFile;
+    read(file: WorkflowFile, query?: AuthoringRead): Promise<{
+        revision: string;
+        data: {
+            text: {
+                node: string;
+                field: "code" | "prompt";
+                start: number;
+                lines: number;
+                content: string;
+                totalLines: number;
+                nextStart?: number | undefined;
+                truncated: boolean;
+            };
+            nodes?: undefined;
+            edges?: undefined;
+        } | {
+            text?: undefined;
+            nodes: {
+                ref: string;
+                type: "agent" | "approval" | "code" | "condition" | "connector" | "connector-proxy" | "cron" | "decision" | "error" | "http-request" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "skip-duplicates" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow";
+                name: string;
+                readOnly: boolean;
+                description?: string | undefined;
+                icon?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxExecutions?: number | undefined;
+                onError?: "error" | "stop" | undefined;
+                retry?: import("./flow-model.js").RetryConfiguration | undefined;
+                config: JsonValue;
+                texts: {
+                    [k: string]: {
+                        lines: number;
+                        characters: number;
+                    };
+                };
+                inputs: unknown;
+                inputPorts: {
+                    [k: string]: {
+                        schema: JsonValue;
+                        nullable: boolean;
+                        description?: string | undefined;
+                        default?: JsonValue | undefined;
+                    };
+                };
+                systemOutputs?: {
+                    [k: string]: {
+                        schema: JsonValue;
+                        nullable: boolean;
+                        description?: string | undefined;
+                        default?: JsonValue | undefined;
+                    };
+                } | undefined;
+                outputPorts: {
+                    [k: string]: {
+                        schema: JsonValue;
+                        nullable: boolean;
+                        description?: string | undefined;
+                        default?: JsonValue | undefined;
+                    };
+                };
+                authenticationChoices?: ({
+                    label: string;
+                } & ({
+                    error: string | undefined;
+                    authentication?: undefined;
+                } | {
+                    error?: undefined;
+                    authentication: {
+                        schemes: string[];
+                    };
+                }))[] | undefined;
+                incoming: ({
+                    source: string;
+                    target: string;
+                    branch?: undefined;
+                } | {
+                    source: string;
+                    target: string;
+                    branch: string;
+                })[];
+                outgoing: ({
+                    source: string;
+                    target: string;
+                    branch?: undefined;
+                } | {
+                    source: string;
+                    target: string;
+                    branch: string;
+                })[];
+            }[];
+            edges?: undefined;
+        } | {
+            text?: undefined;
+            nodes: {
+                ref: string;
+                type: "agent" | "approval" | "code" | "condition" | "connector" | "connector-proxy" | "cron" | "decision" | "error" | "http-request" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "skip-duplicates" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow";
+                name: string;
+                readOnly: boolean;
+                inputHandles: string[];
+                outputHandles: string[];
+                inputs: unknown;
+                texts: {
+                    [k: string]: {
+                        lines: number;
+                        characters: number;
+                    };
+                };
+            }[];
+            edges: ({
+                source: string;
+                target: string;
+                branch?: undefined;
+            } | {
+                source: string;
+                target: string;
+                branch: string;
+            })[];
+        };
+    }>;
+    search(file: WorkflowFile, query: AuthoringSearch): Promise<{
+        revision: string;
+        data: {
+            matches: {
+                node?: string;
+                field: string;
+                line?: number;
+                excerpt: string;
+            }[];
+            total: number;
+            nextOffset?: number | undefined;
+        };
+    }>;
+    schema(query?: {
+        readonly type?: AuthoringType;
+        readonly action?: string;
+    }): Promise<{
+        action: string;
+        name: string;
+        inputs: Readonly<Record<string, import("./flow-model.js").InputPortDefinition>>;
+        outputs: Readonly<Record<string, import("../index.js").PortDefinition>>;
+        version: 1;
+    } | {
+        types: readonly ["start", "outputs", "webhook-response", "workflow", "webhook", "cron", "error", "poll", "integration", "code", "connector", "connector-proxy", "agent", "llm", "decision", "openapi", "http-request", "skip-duplicates", "condition", "value", "wait", "approval"];
+        request: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            baseRevision: import("zod").ZodString;
+            requestId: import("zod").ZodString;
+            edits: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.add">;
+                as: import("zod").ZodString;
+                type: import("zod").ZodEnum<{
+                    agent: "agent";
+                    approval: "approval";
+                    code: "code";
+                    condition: "condition";
+                    connector: "connector";
+                    "connector-proxy": "connector-proxy";
+                    cron: "cron";
+                    decision: "decision";
+                    error: "error";
+                    "http-request": "http-request";
+                    integration: "integration";
+                    llm: "llm";
+                    openapi: "openapi";
+                    outputs: "outputs";
+                    poll: "poll";
+                    "skip-duplicates": "skip-duplicates";
+                    start: "start";
+                    value: "value";
+                    wait: "wait";
+                    webhook: "webhook";
+                    "webhook-response": "webhook-response";
+                    workflow: "workflow";
+                }>;
+                name: import("zod").ZodString;
+                onError: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    error: "error";
+                    stop: "stop";
+                }>>;
+                retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                    maxRetries: import("zod").ZodNumber;
+                    intervalMs: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strict>>;
+                config: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodJSONSchema>>;
+                inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"output">;
+                    node: import("zod").ZodString;
+                    port: import("zod").ZodOptional<import("zod").ZodString>;
+                    field: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"system">;
+                    node: import("zod").ZodString;
+                    port: import("zod").ZodLiteral<"error">;
+                    field: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"variable">;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"value">;
+                    value: import("zod").ZodJSONSchema;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"unset">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"default">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"sources">;
+                    sources: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"output">;
+                        node: import("zod").ZodString;
+                        port: import("zod").ZodOptional<import("zod").ZodString>;
+                        field: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"system">;
+                        node: import("zod").ZodString;
+                        port: import("zod").ZodLiteral<"error">;
+                        field: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"variable">;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>]>>;
+                }, import("zod/v4/core").$strict>]>>>;
+                code: import("zod").ZodOptional<import("zod").ZodString>;
+                prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.update">;
+                node: import("zod").ZodString;
+                set: import("zod").ZodOptional<import("zod").ZodObject<{
+                    onError: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        error: "error";
+                        stop: "stop";
+                    }>>;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    description: import("zod").ZodOptional<import("zod").ZodString>;
+                    icon: import("zod").ZodOptional<import("zod").ZodString>;
+                    maxExecutions: import("zod").ZodOptional<import("zod").ZodInt>;
+                    timeoutMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    retry: import("zod").ZodOptional<import("zod").ZodObject<{
+                        maxRetries: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        intervalMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strict>>;
+                    config: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodJSONSchema>>;
+                }, import("zod/v4/core").$strict>>;
+                clear: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodString>>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.refresh">;
+                node: import("zod").ZodString;
+                tool: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"node.remove">;
+                node: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"input.set">;
+                node: import("zod").ZodString;
+                input: import("zod").ZodString;
+                source: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"output">;
+                    node: import("zod").ZodString;
+                    port: import("zod").ZodOptional<import("zod").ZodString>;
+                    field: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"system">;
+                    node: import("zod").ZodString;
+                    port: import("zod").ZodLiteral<"error">;
+                    field: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"variable">;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"value">;
+                    value: import("zod").ZodJSONSchema;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"unset">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"default">;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"sources">;
+                    sources: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"output">;
+                        node: import("zod").ZodString;
+                        port: import("zod").ZodOptional<import("zod").ZodString>;
+                        field: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"system">;
+                        node: import("zod").ZodString;
+                        port: import("zod").ZodLiteral<"error">;
+                        field: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                        kind: import("zod").ZodLiteral<"variable">;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core").$strict>]>>;
+                }, import("zod/v4/core").$strict>]>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodEnum<{
+                    "edge.connect": "edge.connect";
+                    "edge.disconnect": "edge.disconnect";
+                }>;
+                source: import("zod").ZodString;
+                target: import("zod").ZodString;
+                branch: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"text.edit">;
+                node: import("zod").ZodString;
+                field: import("zod").ZodEnum<{
+                    code: "code";
+                    prompt: "prompt";
+                }>;
+                oldText: import("zod").ZodString;
+                newText: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                op: import("zod").ZodLiteral<"text.set">;
+                node: import("zod").ZodString;
+                field: import("zod").ZodEnum<{
+                    code: "code";
+                    prompt: "prompt";
+                }>;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>], "op">>;
+        }, import("zod/v4/core").$strict>>;
+        guidance: string;
+        type?: undefined;
+        onError?: undefined;
+        retry?: undefined;
+        inputSources?: undefined;
+        extensibleInputs?: undefined;
+        example?: undefined;
+        configuration?: undefined;
+        texts?: undefined;
+        action?: undefined;
+        name?: undefined;
+        inputs?: undefined;
+        outputs?: undefined;
+        version: 1;
+    } | {
+        types?: undefined;
+        request?: undefined;
+        type: "agent" | "approval" | "code" | "condition" | "connector" | "connector-proxy" | "cron" | "decision" | "error" | "http-request" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "skip-duplicates" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow";
+        onError: boolean | {
+            enum: string[];
+        };
+        retry: boolean | import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{
+            maxRetries: import("zod").ZodNumber;
+            intervalMs: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strict>>;
+        inputSources: string[];
+        extensibleInputs: boolean;
+        guidance: string;
+        example: {
+            op: string;
+            as: string;
+            type: "agent" | "approval" | "code" | "condition" | "connector" | "connector-proxy" | "cron" | "decision" | "error" | "http-request" | "integration" | "llm" | "openapi" | "outputs" | "poll" | "skip-duplicates" | "start" | "value" | "wait" | "webhook" | "webhook-response" | "workflow";
+            name: string;
+        };
+        configuration: import("zod/v4/core").ZodStandardJSONSchemaPayload<import("zod").ZodObject<{}, import("zod/v4/core").$strict>>;
+        texts: string[];
+        action?: undefined;
+        name?: undefined;
+        inputs?: undefined;
+        outputs?: undefined;
+        version: 1;
+    }>;
+    edit(file: WorkflowFile, request: AuthoringRequest): Promise<{
+        file: {
+            kind: 'open-flow-workflow';
+            version: 1;
+            name?: string;
+            icon?: string;
+            description?: string;
+            presentation?: Readonly<Record<string, JsonValue>>;
+            content: import("./flow-change.js").RevisionContent;
+        };
+        revision: string;
+        nodes: Record<string, string>;
+        validation: {
+            status: "invalid" | "valid";
+            diagnostics: {
+                code: string;
+                message: string;
+                nodes: string[];
+                field: string;
+                line?: number | undefined;
+                column?: number | undefined;
+            }[];
+        };
+    }>;
+    check: (file: WorkflowFile) => Promise<{
+        revision: string;
+        valid: boolean;
+        diagnostics: {
+            code: string;
+            message: string;
+            nodes: string[];
+            field: string;
+            line?: number | undefined;
+            column?: number | undefined;
+        }[];
+    }>;
+};

package/dist/render/browser/licenses.md

@@ -3973,7 +3973,7 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-## zod - 4.6.5 (MIT)
+## zod - 4.6.7 (MIT)
 
 MIT License