@oomol-lab/open-flow 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/common/engine-contract.d.ts

@@ -3,5 +3,5 @@ export interface EngineContract {
     readonly platformModule: string;
     readonly platformSource: string;
 }
-export declare const currentEngineContract = "open-flow-engine/v1";
+export declare const currentEngineContract = "open-flow-engine/v2";
 export declare function findEngineContract(contract: string): EngineContract | undefined;

package/dist/common/flow-encoding.js

@@ -58,7 +58,6 @@ function u(e) {
 function d(e) {
 	if (!("inputs" in e)) return v(e);
 	let t = {
-		concurrency: e.concurrency,
 		...e.description == null ? {} : { description: e.description },
 		...e.icon == null ? {} : { icon: e.icon },
 		inputs: l(e.inputs),
@@ -89,24 +88,46 @@ function d(e) {
 			kind: e.kind,
 			subflowId: e.subflowId
 		};
-		case "task": return e.task == null ? {
-			...t,
-			kind: e.kind,
-			taskId: e.taskId
-		} : {
+		case "task": {
+			let n = e.task == null ? Object.assign({}, t, {
+				kind: e.kind,
+				taskId: e.taskId
+			}) : Object.assign({}, t, {
+				kind: e.kind,
+				task: m(e.task)
+			});
+			return e.additionalInputs != null && (n.additionalInputs = s(e.additionalInputs)), n;
+		}
+		case "value": return {
 			...t,
 			kind: e.kind,
-			task: m(e.task)
+			values: s(e.values)
 		};
-		case "value": return {
+		case "wait": return {
 			...t,
+			actions: e.actions,
+			input: {
+				handle: e.input.handle,
+				...o(e.input)
+			},
 			kind: e.kind,
-			values: s(e.values)
+			...e.notification == null ? {} : { notification: {
+				inputs: l(e.notification.inputs),
+				messageHandle: e.notification.messageHandle,
+				taskId: e.notification.taskId
+			} },
+			prompt: e.prompt
 		};
 	}
 }
 function f(e) {
-	return { nodes: Object.fromEntries(a(e.nodes).map(([e, t]) => [e, d(t)])) };
+	return {
+		edges: e.edges.map((e) => ({ ...e })).toSorted((e, t) => {
+			let r = n(e), i = n(t);
+			return r < i ? -1 : +(r > i);
+		}),
+		nodes: Object.fromEntries(a(e.nodes).map(([e, t]) => [e, d(t)]))
+	};
 }
 function p(e) {
 	return {
@@ -118,11 +139,7 @@ function p(e) {
 }
 function m(e) {
 	return {
-		...e.capabilities == null ? {} : { capabilities: e.capabilities.map(({ action: e, connectionId: t, kind: n }) => ({
-			action: e,
-			connectionId: t,
-			kind: n
-		})) },
+		...e.capabilities == null ? {} : { capabilities: e.capabilities },
 		inputs: s(e.inputs),
 		moduleId: e.moduleId,
 		name: e.name,
@@ -183,6 +200,7 @@ function v(e) {
 		name: e.name
 	});
 	switch (e.kind) {
+		case "manual": return t(e.kind);
 		case "webhook": return {
 			...t(e.kind),
 			inputsDef: e.inputsDef.map((e) => ({

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

@@ -0,0 +1,6 @@
+import type { FlowDocument, Graph, GraphNode, InputPortDefinition, RevisionContent } from '../browser/flow-change.js';
+import type { Diagnostic, SemanticClosure } from './flow-semantics.js';
+export declare function nodeInputPorts(document: FlowDocument, node: GraphNode): Readonly<Record<string, InputPortDefinition>>;
+export declare function graphOrder(graph: Graph): readonly string[];
+export declare function availableOutputs(document: FlowDocument, graph: Graph, target: string, handle?: string): Readonly<Record<string, readonly string[]>>;
+export declare function validateFlowGraph(revision: RevisionContent, closure: SemanticClosure): readonly Diagnostic[];

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

@@ -0,0 +1,20 @@
+import type { EngineContract } from './engine-contract.js';
+import type { RevisionContent } from '../browser/flow-change.js';
+import type { Diagnostic } from './flow-semantics.js';
+interface ImportReference {
+    readonly column: number;
+    readonly imported: readonly string[];
+    readonly line: number;
+    readonly specifier: string;
+}
+interface ModuleAnalysis {
+    readonly exports: ReadonlySet<string>;
+    readonly imports: readonly ImportReference[];
+}
+export declare function compareDiagnostics(left: Diagnostic, right: Diagnostic): number;
+export declare function validateModuleGraph(revision: RevisionContent, moduleIds: readonly string[], engine: EngineContract): {
+    readonly analysis: ReadonlyMap<string, ModuleAnalysis>;
+    readonly diagnostics: Diagnostic[];
+};
+export declare function validateModules(revision: RevisionContent, moduleIds: readonly string[], engine: EngineContract): readonly Diagnostic[];
+export {};

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

@@ -12,4 +12,9 @@ export type FlowChangeEvent = {
     readonly kind: 'run.created';
     readonly runId: string;
     readonly version: 1;
+} | {
+    readonly flowId: string;
+    readonly kind: 'run.changed';
+    readonly runId: string;
+    readonly version: 1;
 };

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

@@ -0,0 +1,8 @@
+import type { JsonValue, PortDefinition, TriggerNode } from '../browser/flow-change.js';
+export declare function triggerPayloadSchema(trigger: TriggerNode): JsonValue;
+export declare function schemaObject(schema: JsonValue): Readonly<Record<string, JsonValue>> | undefined;
+export declare function schemaList(value: JsonValue | undefined): readonly JsonValue[] | undefined;
+export declare function matchesSchema(value: JsonValue, schema: JsonValue): boolean;
+export declare function portsAssignable(source: PortDefinition, target: PortDefinition): boolean;
+export declare function variableInputCompatible(jsonSchema: JsonValue): boolean;
+export declare function hasRetiredRef(value: unknown): boolean;

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

@@ -1,6 +1,9 @@
-import type { FlowDocument, Graph, JsonValue, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
 import type { EngineContract } from './engine-contract.js';
 import type { RuntimeProgram } from './runtime-contract.js';
+import type { ConnectorCapability, FlowDocument, Graph, RevisionContent } from '../browser/flow-change.js';
+export { availableOutputs, graphOrder, nodeInputPorts } from './flow-graph.js';
+export { validateModules } from './flow-modules.js';
+export { matchesSchema, triggerPayloadSchema, variableInputCompatible } from './flow-schema.js';
 export interface SemanticClosure {
     readonly dependencies: {
         readonly bindings: ReadonlySet<string>;
@@ -11,6 +14,7 @@ export interface SemanticClosure {
     };
     readonly digest: string;
 }
+export declare function flowDependencies(content: RevisionContent): SemanticClosure['dependencies'];
 export declare function flowClosure(content: RevisionContent): Promise<SemanticClosure>;
 export declare function variableBindings(revision: RevisionContent, bindingIds: Iterable<string>): Readonly<Record<string, string>>;
 export interface Diagnostic {
@@ -26,12 +30,9 @@ export interface FlowValidation {
     readonly diagnostics: readonly Diagnostic[];
     readonly valid: boolean;
 }
-export declare function triggerPayloadSchema(trigger: TriggerNode): JsonValue;
-export declare function matchesSchema(value: JsonValue, schema: JsonValue): boolean;
-export declare function variableInputCompatible(jsonSchema: JsonValue): boolean;
 export type FlowInputsValidation = 'invalid' | 'valid';
+export declare function validRunTrigger(revision: RevisionContent, value: unknown): boolean;
 export declare function validateFlowInputs(revision: RevisionContent, value: unknown): FlowInputsValidation;
-export declare function validateModules(revision: RevisionContent, moduleIds: readonly string[], engine: EngineContract): readonly Diagnostic[];
 export declare function validateFlow(revision: RevisionContent, engine: EngineContract): Promise<FlowValidation>;
 export interface PreparedFlow {
     readonly closureDigest: string;
@@ -53,3 +54,4 @@ export type PrepareFlowResult = {
 };
 export declare function prepareFlow(revision: RevisionContent, engineContract: string): Promise<PrepareFlowResult>;
 export declare function createRuntimeProgram(prepared: PreparedFlow, entryModuleId: string, engineDigest: string): RuntimeProgram | undefined;
+export declare function codeActions(flow: Pick<PreparedFlow, 'graph' | 'subflows'>): readonly ConnectorCapability[];