@oomol-lab/open-flow 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/common/cron-trigger.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue, TriggerSchedule } from '../browser/project-change.js';
+import type { JsonValue, TriggerSchedule } from '../browser/flow-change.js';
 export declare function validateTriggerSchedule(rules: readonly TriggerSchedule[]): void;
 export declare function nextTriggerScheduledAt(rules: readonly TriggerSchedule[], afterMs: number): number;
 export declare function scheduledTriggerOccurrenceId(bindingId: string, runtimeVersion: number, scheduledAt: string): Promise<string>;

package/dist/common/cron-trigger.js

@@ -1,4 +1,4 @@
-//#region ../../node_modules/croner/dist/croner.js
+//#region ../../node_modules/.bun/croner@10.0.1/node_modules/croner/dist/croner.js
 function e(e) {
 	return Date.UTC(e.y, e.m - 1, e.d, e.h, e.i, e.s);
 }

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

@@ -0,0 +1,11 @@
+import type { CodeModule, FlowDocument, Graph, InputPort, JsonValue, OutputMapping, Port, RevisionContent } from '@oomol-lab/open-flow/flow-change';
+export declare const maxJsonDepth = 64;
+export declare function canonicalJsonBytes(value: JsonValue): Uint8Array;
+export declare function digestBytes(bytes: Uint8Array): Promise<string>;
+export declare function canonicalPorts(value: readonly (InputPort | Port)[]): JsonValue;
+export declare function canonicalOutputs(value: readonly (OutputMapping & Port)[]): JsonValue;
+export declare function canonicalGraph(value: Graph): JsonValue;
+export declare function canonicalTask(task: FlowDocument['tasks'][string]): JsonValue;
+export declare function canonicalDocument(document: FlowDocument): JsonValue;
+export declare function canonicalModule(module: CodeModule): JsonValue;
+export declare function encodeRevision(content: RevisionContent): Uint8Array;

package/dist/common/{project-encoding.js → flow-encoding.js}

@@ -1,4 +1,4 @@
-//#region src/project/common/encoding.ts
+//#region src/flow/common/encoding.ts
 var e = new TextEncoder(), t = 64;
 function n(e) {
 	if (e == null || typeof e == "boolean" || typeof e == "string" || typeof e == "number") return JSON.stringify(e);
@@ -19,13 +19,14 @@ function a(e) {
 function o(e) {
 	return {
 		...e.description == null ? {} : { description: e.description },
+		handle: e.handle,
 		jsonSchema: e.jsonSchema,
 		nullable: e.nullable,
 		...Object.hasOwn(e, "value") ? { value: e.value } : {}
 	};
 }
 function s(e) {
-	return Object.fromEntries(a(e).map(([e, t]) => [e, o(t)]));
+	return e.map(o);
 }
 function c(e) {
 	switch (e.kind) {
@@ -43,18 +44,20 @@ function l(e) {
 	return Object.fromEntries(a(e).map(([e, t]) => [e, c(t)]));
 }
 function u(e) {
-	return Object.fromEntries(a(e).map(([e, t]) => [e, {
-		...t.description == null ? {} : { description: t.description },
-		jsonSchema: t.jsonSchema,
-		nullable: t.nullable,
-		sources: t.sources.map((e) => ({ ...e }))
-	}]));
+	return e.map((e) => ({
+		...e.description == null ? {} : { description: e.description },
+		handle: e.handle,
+		jsonSchema: e.jsonSchema,
+		nullable: e.nullable,
+		sources: e.sources.map((e) => ({ ...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),
 		...e.name == null ? {} : { name: e.name },
 		...e.timeoutMs == null ? {} : { timeoutMs: e.timeoutMs }
@@ -172,6 +175,7 @@ function _(e) {
 function v(e) {
 	let t = (t) => ({
 		...e.description == null ? {} : { description: e.description },
+		...e.icon == null ? {} : { icon: e.icon },
 		kind: t,
 		name: e.name
 	});
@@ -206,10 +210,7 @@ function v(e) {
 function y(e) {
 	return {
 		bindings: Object.fromEntries(a(e.bindings)),
-		flows: Object.fromEntries(a(e.flows).map(([e, t]) => [e, {
-			graph: f(t.graph),
-			name: t.name
-		}])),
+		graph: f(e.graph),
 		subflows: Object.fromEntries(a(e.subflows).map(([e, t]) => [e, {
 			graph: f(t.graph),
 			inputs: s(t.inputs),
@@ -229,7 +230,7 @@ function b(e) {
 function x(e) {
 	return {
 		document: y(e.document),
-		kind: "open-flow-project-revision",
+		kind: "open-flow-flow-revision",
 		modelVersion: e.modelVersion,
 		modules: Object.fromEntries(a(e.modules).map(([e, t]) => [e, b(t)])),
 		version: 1

package/dist/common/{project-notifications.d.ts → flow-notifications.d.ts}

@@ -1,12 +1,15 @@
-export type ProjectChangeEvent = {
+export interface FlowCatalogEvent {
+    readonly kind: 'flows.changed';
+    readonly version: 1;
+}
+export type FlowChangeEvent = {
     readonly kind: 'draft.changed';
-    readonly projectId: string;
+    readonly flowId: string;
     readonly revisionId: string;
     readonly version: 1;
 } | {
     readonly flowId: string;
     readonly kind: 'run.created';
-    readonly projectId: string;
     readonly runId: string;
     readonly version: 1;
 };

package/dist/common/{project-semantics.d.ts → flow-semantics.d.ts}

@@ -1,4 +1,4 @@
-import type { JsonValue, ProjectDocument, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/project-change';
+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';
 export interface SemanticClosure {
@@ -11,7 +11,7 @@ export interface SemanticClosure {
     };
     readonly digest: string;
 }
-export declare function flowClosure(content: RevisionContent, flowId: string): Promise<SemanticClosure | undefined>;
+export declare function flowClosure(content: RevisionContent): Promise<SemanticClosure>;
 export interface Diagnostic {
     readonly code: string;
     readonly column: number;
@@ -26,30 +26,27 @@ export interface FlowValidation {
 }
 export declare function triggerPayloadSchema(trigger: TriggerNode): JsonValue;
 export declare function matchesSchema(value: JsonValue, schema: JsonValue): boolean;
-export type FlowInputsValidation = 'flow-not-found' | 'invalid' | 'valid';
-export declare function validateFlowInputs(revision: RevisionContent, flowId: string, value: unknown): FlowInputsValidation;
+export type FlowInputsValidation = 'invalid' | 'valid';
+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, flowId: string, engine: EngineContract): Promise<FlowValidation | undefined>;
+export declare function validateFlow(revision: RevisionContent, engine: EngineContract): Promise<FlowValidation>;
 export interface PreparedFlow {
     readonly closureDigest: string;
     readonly engineContract: string;
-    readonly flow: ProjectDocument['flows'][string];
-    readonly flowId: string;
+    readonly graph: Graph;
     readonly modules: RevisionContent['modules'];
-    readonly subflows: ProjectDocument['subflows'];
-    readonly tasks: ProjectDocument['tasks'];
+    readonly subflows: FlowDocument['subflows'];
+    readonly tasks: FlowDocument['tasks'];
 }
 export type PrepareFlowResult = {
     readonly kind: 'engine-unsupported';
 } | {
     readonly kind: 'flow-invalid';
     readonly validation: FlowValidation;
-} | {
-    readonly kind: 'flow-not-found';
 } | {
     readonly flow: PreparedFlow;
     readonly kind: 'prepared';
     readonly validation: FlowValidation;
 };
-export declare function prepareFlow(revision: RevisionContent, flowId: string, engineContract: string): Promise<PrepareFlowResult>;
+export declare function prepareFlow(revision: RevisionContent, engineContract: string): Promise<PrepareFlowResult>;
 export declare function createRuntimeProgram(prepared: PreparedFlow, entryModuleId: string, engineDigest: string): RuntimeProgram | undefined;