@oomol-lab/open-flow 0.1.0-beta.62 → 0.1.0-beta.63

package/dist/common/authoringSchema.d.ts

@@ -209,6 +209,7 @@ export declare const authoringConfigurations: {
         notification: z.ZodOptional<z.ZodObject<{
             action: z.ZodString;
             connectionId: z.ZodOptional<z.ZodString>;
+            outputMode: z.ZodOptional<z.ZodLiteral<"value">>;
             messageHandle: z.ZodString;
             inputs: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"value">;

package/dist/common/connector-action.d.ts

@@ -24,3 +24,4 @@ export interface ConnectorRuntimeInputPort {
 }
 export declare function connectorActionPorts(inputSchema: unknown, outputSchema: unknown): ConnectorActionPorts;
 export declare function normalizeConnectorRuntimeInputs<Value>(ports: readonly ConnectorRuntimeInputPort[], inputs: Readonly<Record<string, Value>>): Readonly<Record<string, Value>>;
+export declare function connectorOutputMode(schema: unknown): 'fields' | 'value';

package/dist/common/connector-action.js

@@ -43,24 +43,27 @@ function inputPorts(schema) {
 		};
 	});
 }
-function outputPorts(schema) {
+function connectorOutputMode(schema) {
 	const root = toPlainObject(schema);
 	const properties = toPlainObject(root?.properties);
-	if (root != null && (root.type == "object" || properties != null)) {
-		if (properties == null) return [];
-		const required = stringSet(root.required);
-		return Object.entries(properties).map(([handle, propertySchema]) => ({
-			description: schemaDescription(root, propertySchema),
-			handle,
-			json_schema: propertySchemaWithDefinitions(root, propertySchema),
-			nullable: !required.has(handle) || schemaAllowsNull(propertySchema, root)
-		}));
-	} else return [{
+	return properties != null && Object.keys(properties).length > 0 || root?.type == "object" && root.additionalProperties === false ? "fields" : "value";
+}
+function outputPorts(schema) {
+	const root = toPlainObject(schema);
+	if (connectorOutputMode(schema) == "value") return [{
 		description: schemaDescription(root, schema),
 		handle: "output",
 		json_schema: schema,
 		nullable: schemaAllowsNull(schema)
 	}];
+	const properties = toPlainObject(root?.properties) ?? {};
+	const required = stringSet(root?.required);
+	return Object.entries(properties).map(([handle, propertySchema]) => ({
+		description: schemaDescription(root, propertySchema),
+		handle,
+		json_schema: propertySchemaWithDefinitions(root, propertySchema),
+		nullable: !required.has(handle) || schemaAllowsNull(propertySchema, root)
+	}));
 }
 function propertySchemaWithDefinitions(root, schema) {
 	const property = toPlainObject(schema);
@@ -124,4 +127,4 @@ function resolveLocalReference(root, reference) {
 	return current;
 }
 //#endregion
-export { connectorActionPorts, normalizeConnectorRuntimeInputs };
+export { connectorActionPorts, connectorOutputMode, normalizeConnectorRuntimeInputs };

package/dist/common/control-api-conformance.js

@@ -6684,10 +6684,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -6700,7 +6700,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -7095,7 +7095,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -7685,7 +7685,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -8251,7 +8251,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }
@@ -8716,7 +8716,8 @@ var managedFields = object({
 		object({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional()
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object({
 			kind: literal("openapi"),
@@ -9314,7 +9315,7 @@ var authoringConfigurations = {
 		outputs: outputFields,
 		capabilities: authoringDefinitionSchemas.capabilities.optional()
 	}),
-	connector: authoringDefinitionSchemas.connector.strict(),
+	connector: authoringDefinitionSchemas.connector.omit({ outputMode: true }).strict(),
 	openapi: authoringOpenApiSchema,
 	agent: authoringDefinitionSchemas.agent.omit({
 		prompt: true,
@@ -10034,6 +10035,24 @@ function providerIconAppearance(metadata, position) {
 		}
 	};
 }
+//#endregion
+//#region src/flow/common/workflowFile.ts
+var envelope = strictObject({
+	kind: literal("open-flow-workflow"),
+	version: literal(1),
+	name: string$1().optional(),
+	content: unknown(),
+	presentation: record$3(string$1(), json$4()).optional()
+});
+/** Structural decoding only: incomplete drafts are supported, repair is never attempted. */
+function decodeWorkflowFile(value) {
+	checkJsonDepth(value, -1);
+	const file = envelope.parse(value);
+	return {
+		...file,
+		content: decodeRevisionContent(file.content)
+	};
+}
 new TextEncoder();
 //#endregion
 //#region src/control/common/providerAccess.ts
@@ -11418,6 +11437,26 @@ var ControlClient = class {
 		exact(source, ["version"]);
 		if (source.version != 1) return invalidResponse();
 	}
+	async exportFlow(flowId) {
+		const value = await this.request(`/v1/flows/${segment(flowId)}/export`);
+		try {
+			return decodeWorkflowFile(value);
+		} catch {
+			return invalidResponse();
+		}
+	}
+	async importFlow(file, options = {}) {
+		return flow(await this.request("/v1/flows/import", {
+			method: "POST",
+			headers: { "Idempotency-Key": options.idempotencyKey ?? `flow-${randomId()}` },
+			body: JSON.stringify({
+				file,
+				name: options.name,
+				teamId: options.teamId,
+				version: 1
+			})
+		}));
+	}
 	async createFlow(name, idempotencyKey = `flow-${randomId()}`, teamId) {
 		return flow(await this.request("/v1/flows", {
 			body: JSON.stringify({
@@ -12107,6 +12146,66 @@ function liveRunRequest(harness, publicationId, key) {
 	});
 }
 var controlApiConformanceCases = [
+	{
+		name: "imports workflow files atomically and exports a new unpublished draft with its Presentation",
+		async verify(harness) {
+			const api = new ControlClient((url, init) => harness.request(new Request(new URL(url, harness.origin), init)));
+			const file = {
+				kind: "open-flow-workflow",
+				version: 1,
+				name: "Portable flow",
+				content: {
+					modelVersion: 6,
+					modules: {},
+					document: {
+						bindings: {},
+						graph: {
+							nodes: { start: {
+								kind: "manual",
+								name: "Start"
+							} },
+							edges: []
+						}
+					}
+				},
+				presentation: { viewport: {
+					x: 10,
+					y: 20,
+					zoom: 1
+				} }
+			};
+			const idempotencyKey = crypto.randomUUID();
+			const created = await api.importFlow(file, { idempotencyKey });
+			equal(dequal(await api.importFlow(file, { idempotencyKey }), created), true, "Import retry must return the same Flow.");
+			equal(dequal(await api.exportFlow(created.flowId), file), true, "Export must retain the graph and Presentation.");
+			const editor = await api.getEditor(created.flowId);
+			equal(editor.live.publication == null, true, "Import must not publish.");
+			equal(editor.draft.parentRevisionId == null, true, "Import must create an initial Revision.");
+			equal(dequal(editor.presentation.value, file.presentation), true, "Import must atomically save Presentation.");
+			await error(await request(harness, "/v1/flows/import", {
+				method: "POST",
+				headers: { "idempotency-key": idempotencyKey },
+				body: JSON.stringify({
+					file,
+					name: "Changed",
+					version: 1
+				})
+			}), 409, "flow.conflict", "Reject changed import retry");
+			const before = await api.listFlows();
+			await error(await request(harness, "/v1/flows/import", {
+				method: "POST",
+				headers: { "idempotency-key": crypto.randomUUID() },
+				body: JSON.stringify({
+					file: {
+						...file,
+						version: 99
+					},
+					version: 1
+				})
+			}), 400, "flow.invalid", "Reject unsupported file");
+			equal(dequal((await api.listFlows()).flows, before.flows), true, "Rejected import left an empty Flow.");
+		}
+	},
 	{
 		name: "authors nodes atomically with public views, fixed reads and replay before CAS",
 		async verify(harness) {

package/dist/common/control-api.d.ts

@@ -22,6 +22,8 @@ import type { ResultQuery } from './run-results.js';
 import { decodeResultList, decodeResultRead } from './run-results.js';
 export { readResult, parseResultQuery, decodeResultList, decodeResultRead, type ResultCall, type ResultInfo, type ResultPage, type ResultQuery, } from './run-results.js';
 import type { RunStatus } from './run-lifecycle.js';
+import type { WorkflowFile } from './flow-workflowFile.js';
+export type { WorkflowFile, WorkflowCleanupSummary } from './flow-workflowFile.js';
 import type { InputPortDefinition, JsonValue, PortDefinition, RevisionContent, TriggerKeySnapshot, WaitAction } from '../browser/flow-change.js';
 import type { FlowResourceReferences } from './flow-semantics.js';
 export type { JsonValue, TriggerKeySnapshot, WaitAction } from '../browser/flow-change.js';
@@ -782,6 +784,12 @@ export declare class ControlClient {
     getVariable(name: string): Promise<Variable>;
     putVariable(name: string, value: string): Promise<Variable>;
     deleteVariable(name: string): Promise<void>;
+    exportFlow(flowId: string): Promise<WorkflowFile>;
+    importFlow(file: WorkflowFile, options?: {
+        readonly name?: string;
+        readonly teamId?: string;
+        readonly idempotencyKey?: string;
+    }): Promise<Flow>;
     createFlow(name: string, idempotencyKey?: string, teamId?: string): Promise<Flow>;
     getFlow(flowId: string): Promise<Flow>;
     getErrorListeners(flowId: string, signal?: AbortSignal): Promise<readonly ErrorListener[]>;

package/dist/common/control-api.js

@@ -6711,10 +6711,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -6727,7 +6727,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -7122,7 +7122,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -7712,7 +7712,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -8278,7 +8278,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }
@@ -8743,7 +8743,8 @@ var managedFields = object({
 		object({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional()
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object({
 			kind: literal("openapi"),
@@ -9341,7 +9342,7 @@ var authoringConfigurations = {
 		outputs: outputFields,
 		capabilities: authoringDefinitionSchemas.capabilities.optional()
 	}),
-	connector: authoringDefinitionSchemas.connector.strict(),
+	connector: authoringDefinitionSchemas.connector.omit({ outputMode: true }).strict(),
 	openapi: authoringOpenApiSchema,
 	agent: authoringDefinitionSchemas.agent.omit({
 		prompt: true,
@@ -10164,6 +10165,24 @@ function providerIconAppearance(metadata, position) {
 	};
 }
 //#endregion
+//#region src/flow/common/workflowFile.ts
+var envelope = strictObject({
+	kind: literal("open-flow-workflow"),
+	version: literal(1),
+	name: string$1().optional(),
+	content: unknown(),
+	presentation: record$2(string$1(), json$3()).optional()
+});
+/** Structural decoding only: incomplete drafts are supported, repair is never attempted. */
+function decodeWorkflowFile(value) {
+	checkJsonDepth(value, -1);
+	const file = envelope.parse(value);
+	return {
+		...file,
+		content: decodeRevisionContent(file.content)
+	};
+}
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder$1 = new TextEncoder();
 function canonicalText(value) {
@@ -12074,6 +12093,26 @@ var ControlClient = class {
 		exact(source, ["version"]);
 		if (source.version != 1) return invalidResponse();
 	}
+	async exportFlow(flowId) {
+		const value = await this.request(`/v1/flows/${segment(flowId)}/export`);
+		try {
+			return decodeWorkflowFile(value);
+		} catch {
+			return invalidResponse();
+		}
+	}
+	async importFlow(file, options = {}) {
+		return flow(await this.request("/v1/flows/import", {
+			method: "POST",
+			headers: { "Idempotency-Key": options.idempotencyKey ?? `flow-${randomId()}` },
+			body: JSON.stringify({
+				file,
+				name: options.name,
+				teamId: options.teamId,
+				version: 1
+			})
+		}));
+	}
 	async createFlow(name, idempotencyKey = `flow-${randomId()}`, teamId) {
 		return flow(await this.request("/v1/flows", {
 			body: JSON.stringify({

package/dist/common/control-requests.d.ts

@@ -162,6 +162,12 @@ export declare const controlRequests: {
         version: 1;
         expectedRevision: number;
     };
+    importFlow: (value: unknown) => {
+        file: JsonValue;
+        name?: string | undefined;
+        teamId?: string | undefined;
+        version: 1;
+    };
     createFlow: (value: unknown) => {
         name: string;
         teamId?: string | undefined;

package/dist/common/control-requests.js

@@ -8360,10 +8360,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -8376,7 +8376,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -8771,7 +8771,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -9361,7 +9361,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -9927,7 +9927,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }
@@ -10464,7 +10464,8 @@ var managedFields = object$1({
 		object$1({
 			kind: literal("connector"),
 			action: text$1,
-			connectionId: text$1.optional()
+			connectionId: text$1.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object$1({
 			kind: literal("openapi"),
@@ -11613,7 +11614,7 @@ var authoringConfigurations = {
 		outputs: outputFields,
 		capabilities: authoringDefinitionSchemas.capabilities.optional()
 	}),
-	connector: authoringDefinitionSchemas.connector.strict(),
+	connector: authoringDefinitionSchemas.connector.omit({ outputMode: true }).strict(),
 	openapi: authoringOpenApiSchema,
 	agent: authoringDefinitionSchemas.agent.omit({
 		prompt: true,
@@ -12019,6 +12020,13 @@ var authoringSearchResponse = object$1({
 	version: literal(1)
 });
 //#endregion
+//#region src/connector/common/actionSchema.ts
+function connectorOutputMode(schema) {
+	const root = toPlainObject(schema);
+	const properties = toPlainObject(root?.properties);
+	return properties != null && Object.keys(properties).length > 0 || root?.type == "object" && root.additionalProperties === false ? "fields" : "value";
+}
+//#endregion
 //#region src/trigger/common/contract.ts
 var errorOutputs = [
 	{
@@ -12920,6 +12928,9 @@ function authoringNode(content, ref) {
 				const { inputDefinitions: _definitions, ...noticeSettings } = notification;
 				config.notification = noticeSettings;
 			}
+		} else if (task.executor.kind == "connector") {
+			const { kind: _kind, outputMode: _outputMode, ...settings } = task.executor;
+			config = settings;
 		} else if (task.executor.kind == "llm") config = {
 			...llmConfigurationView(task),
 			inputs: fieldsView([...task.inputs, ...node.kind == "task" ? node.additionalInputs ?? [] : []].filter((port) => !("handle" in port) || !llmReservedInputs.includes(port.handle)))
@@ -13168,7 +13179,8 @@ async function compileAuthoring(base, request, host) {
 			executor: {
 				kind: "connector",
 				action: action.actionId,
-				...config.connectionId == null ? {} : { connectionId: String(config.connectionId) }
+				...config.connectionId == null ? {} : { connectionId: String(config.connectionId) },
+				...action.outputSchema !== void 0 && connectorOutputMode(action.outputSchema) == "value" ? { outputMode: "value" } : {}
 			},
 			inputs: Object.entries(action.inputs).map(([handle, port]) => Object.assign({ handle }, port)),
 			outputs: Object.entries(action.outputs).map(([handle, port]) => Object.assign({ handle }, port))
@@ -13236,15 +13248,19 @@ async function compileAuthoring(base, request, host) {
 		} else if (node.kind == "task" && "executor" in node.task) {
 			const before = node.task;
 			let task;
-			if (type == "connector") task = config.action == (before.executor.kind == "connector" ? before.executor.action : "") ? {
-				...before,
-				name: String(update.name),
-				executor: {
-					kind: "connector",
-					...config
-				}
-			} : await connectorTask(config, String(update.name));
-			else if (type == "decision") task = decisionTask(config.questions, String(update.name));
+			if (type == "connector") {
+				if (before.executor.kind == "connector" && config.action == before.executor.action) {
+					const { connectionId: _connectionId, ...executor } = before.executor;
+					task = {
+						...before,
+						name: String(update.name),
+						executor: {
+							...executor,
+							...config
+						}
+					};
+				} else task = await connectorTask(config, String(update.name));
+			} else if (type == "decision") task = decisionTask(config.questions, String(update.name));
 			else if (type == "openapi") task = await prepareOpenApiTask(config, before, (url) => host.openapi(url), String(update.name), {
 				authentication: explicit("authentication"),
 				serverUrl: explicit("serverUrl")
@@ -14008,6 +14024,12 @@ var schemas = {
 	createEventSource: createEventSourceSchema,
 	updateEventSource: updateEventSourceSchema,
 	eventSourceRevision: eventSourceRevisionSchema,
+	importFlow: strictObject({
+		file: json,
+		name: flowName.optional(),
+		teamId: id.optional(),
+		version
+	}),
 	createFlow: strictObject({
 		name: flowName,
 		teamId: id.optional(),
@@ -14110,6 +14132,7 @@ var controlRequests = {
 	createEventSource: decoder(schemas.createEventSource),
 	updateEventSource: decoder(schemas.updateEventSource),
 	eventSourceRevision: decoder(schemas.eventSourceRevision),
+	importFlow: decoder(schemas.importFlow),
 	createFlow: decoder(schemas.createFlow),
 	renameFlow: decoder(schemas.renameFlow),
 	changeDraft(value) {

package/dist/common/decision.js

@@ -6711,7 +6711,8 @@ var managedFields = object({
 		object({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional()
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object({
 			kind: literal("openapi"),
@@ -8096,10 +8097,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -8112,7 +8113,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -8507,7 +8508,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -9097,7 +9098,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -9663,7 +9664,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }

package/dist/common/flow-connectionUsage.d.ts

@@ -10,3 +10,4 @@ export interface ConnectionUsage {
 }
 export declare function connectionUsage(document: FlowDocument): readonly ConnectionUsage[];
 export declare function removeConnectionUsage(content: RevisionContent, connectionId: string): RevisionContent;
+export declare function clearNodeConnections(graph: FlowDocument['graph'], connectionId?: string): FlowDocument['graph'];

package/dist/common/flow-encoding.d.ts

@@ -1,4 +1,5 @@
 import type { CodeModule, FlowDocument, Graph, Group, InputPort, JsonValue, ManagedTaskDefinition, Port, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
+export * from './flow-workflowFile.js';
 export { maxJsonDepth } from './flow-json.js';
 export { decodeFlowDocument, decodeRevisionContent } from '../browser/flow-change-schema.js';
 export declare function canonicalJsonBytes(value: JsonValue): Uint8Array;