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

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/canvas-commands.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const canvasMinZoom = 0.1;
+export declare const canvasMaxZoom = 3;
+/** Transient operations on each connected canvas's own viewport. */
+export declare const canvasCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"focus">;
+    nodeId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"zoom">;
+    zoom: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"pan">;
+    dx: z.ZodNumber;
+    dy: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"fit">;
+}, z.core.$strict>], "type">;
+export type CanvasCommand = z.infer<typeof canvasCommandSchema>;
+export type CanvasCommandSubscriber = (execute: (command: CanvasCommand) => void) => () => void;

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({
@@ -11429,6 +11468,26 @@ var ControlClient = class {
 			method: "POST"
 		}));
 	}
+	async broadcastCanvas(flowId, command) {
+		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/canvas`, {
+			method: "POST",
+			body: JSON.stringify({
+				version: 1,
+				command
+			})
+		}));
+		exact(source, [
+			"version",
+			"flowId",
+			"broadcast"
+		]);
+		if (source.version != 1 || source.broadcast !== true || source.flowId !== flowId) return invalidResponse();
+		return {
+			version: 1,
+			flowId: string(source.flowId),
+			broadcast: true
+		};
+	}
 	async getFlow(flowId) {
 		return flow(await this.request(`/v1/flows/${segment(flowId)}`));
 	}
@@ -12107,6 +12166,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

@@ -1,3 +1,5 @@
+import type { CanvasCommand } from './canvas-commands.js';
+export type { CanvasCommand, CanvasCommandSubscriber } from './canvas-commands.js';
 import type { LiveDetails } from './liveDetails.js';
 export { liveEntries } from './liveDetails.js';
 export type { LiveDetails, LiveEntry } from './liveDetails.js';
@@ -22,12 +24,19 @@ 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';
 export type { RunStatus } from './run-lifecycle.js';
 export { ApiError, controlErrorCode, controlErrorMetadata, type ControlErrorCode } from './control-api-errors.js';
 export type { FlowCatalogEvent, FlowChangeEvent } from './flow-notifications.js';
+export interface CanvasBroadcast {
+    readonly version: 1;
+    readonly flowId: string;
+    readonly broadcast: true;
+}
 export type ControlRequest = (path: string, init?: RequestInit) => Promise<Response>;
 export interface ErrorListener {
     readonly flowId: string;
@@ -782,7 +791,14 @@ 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>;
+    broadcastCanvas(flowId: string, command: CanvasCommand): Promise<CanvasBroadcast>;
     getFlow(flowId: string): Promise<Flow>;
     getErrorListeners(flowId: string, signal?: AbortSignal): Promise<readonly ErrorListener[]>;
     renameFlow(flowId: string, name: string): Promise<Flow>;

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({
@@ -12085,6 +12124,26 @@ var ControlClient = class {
 			method: "POST"
 		}));
 	}
+	async broadcastCanvas(flowId, command) {
+		const source = record(await this.request(`/v1/flows/${segment(flowId)}/canvas`, {
+			method: "POST",
+			body: JSON.stringify({
+				version: 1,
+				command
+			})
+		}));
+		exact(source, [
+			"version",
+			"flowId",
+			"broadcast"
+		]);
+		if (source.version != 1 || source.broadcast !== true || source.flowId !== flowId) return invalidResponse();
+		return {
+			version: 1,
+			flowId: string(source.flowId),
+			broadcast: true
+		};
+	}
 	async getFlow(flowId) {
 		return flow(await this.request(`/v1/flows/${segment(flowId)}`));
 	}

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

@@ -1,3 +1,4 @@
+export { canvasCommandSchema } from './canvas-commands.js';
 export * from './authoring.js';
 import type { JsonValue } from '../browser/flow-change.js';
 import type { DraftOperation } from './draftOperations.js';
@@ -9,6 +10,22 @@ export declare const waitActionBodySchema: {
     };
 };
 export declare const controlRequests: {
+    canvas: (value: unknown) => {
+        command: {
+            type: "focus";
+            nodeId: string;
+        } | {
+            type: "zoom";
+            zoom: number;
+        } | {
+            type: "pan";
+            dx: number;
+            dy: number;
+        } | {
+            type: "fit";
+        };
+        version: 1;
+    };
     authoringCheck: (value: unknown) => {
         revisionId: string;
     };
@@ -162,6 +179,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;