@oomol-lab/open-flow 0.1.0-beta.4 → 0.1.0-beta.40

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

@@ -0,0 +1,59 @@
+import type { FlowDocument, Graph, GraphNode, InputPortDefinition, NodeSource, PortDefinition, RevisionContent, SchemaMismatch } from '../browser/flow-change.js';
+import type { Diagnostic, SemanticClosure } from './flow-semantics.js';
+export declare function isResolutionNode(node: GraphNode | undefined): node is Extract<GraphNode, {
+    readonly kind: 'approval' | 'wait';
+}>;
+export declare function nodeInputPorts(document: FlowDocument, node: GraphNode): Readonly<Record<string, InputPortDefinition>>;
+export declare function resolutionActions(node: Extract<GraphNode, {
+    readonly kind: 'approval' | 'wait';
+}>): readonly ['continue'] | readonly ['approve', 'reject'];
+export declare function resolutionOutputPorts(node: Extract<GraphNode, {
+    readonly kind: 'approval' | 'wait';
+}>): Readonly<Record<string, PortDefinition>>;
+export declare function nodeOutputPorts(document: FlowDocument, node: GraphNode): Readonly<Record<string, PortDefinition>>;
+export declare function nodeOutputDescription(document: FlowDocument, graph: Graph, nodeId: string, output: string): string | undefined;
+export declare function graphOrder(graph: Graph): readonly string[];
+export type InputSourceCheck = {
+    readonly kind: 'available';
+} | {
+    readonly kind: 'source-missing';
+} | {
+    readonly kind: 'output-missing';
+} | {
+    readonly kind: 'field-missing';
+} | {
+    readonly kind: 'not-ready';
+} | {
+    readonly kind: 'schema';
+    readonly mismatch: SchemaMismatch;
+} | {
+    readonly kind: 'schema-error';
+};
+export type InputSourceCandidateCheck = Extract<InputSourceCheck, {
+    readonly kind: 'available' | 'schema' | 'schema-error';
+}>;
+interface InputSourceFieldCandidate {
+    readonly description?: string;
+    readonly output: string;
+    readonly field: string;
+    readonly check: InputSourceCandidateCheck;
+}
+export interface InputSourceCandidate {
+    readonly description?: string;
+    readonly field?: string;
+    readonly fields?: readonly InputSourceFieldCandidate[];
+    readonly output: string;
+    readonly check: InputSourceCandidateCheck;
+}
+export interface InputSourcesCheck {
+    readonly conflict: boolean;
+    readonly sources: readonly InputSourceCheck[];
+}
+/** Check one saved binding without enumerating candidate ports. */
+export declare function checkInputSource(document: FlowDocument, graph: Graph, target: string, handle: string, source: Pick<NodeSource, 'nodeId' | 'output' | 'field'>): InputSourceCheck;
+export declare function checkInputSources(document: FlowDocument, graph: Graph, target: string, handle: string, sources: readonly Pick<NodeSource, 'nodeId' | 'output' | 'field'>[]): InputSourcesCheck;
+/** Enumerate structurally available outputs while retaining their compatibility with one input. */
+export declare function inputSourceCandidates(document: FlowDocument, graph: Graph, target: string, handle: string): Readonly<Record<string, readonly InputSourceCandidate[]>>;
+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[];
+export {};

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

@@ -0,0 +1,2 @@
+export declare const maxJsonDepth = 64;
+export declare function checkJsonDepth(value: unknown, depth?: number): void;

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

@@ -1,8 +1,17 @@
-export interface FlowCatalogEvent {
+export type FlowCatalogEvent = {
     readonly kind: 'flows.changed';
     readonly version: 1;
-}
+} | {
+    readonly kind: 'flow.created';
+    readonly flowId: string;
+    readonly version: 1;
+};
 export type FlowChangeEvent = {
+    readonly accessRevision: number;
+    readonly flowId: string;
+    readonly kind: 'access.changed';
+    readonly version: 1;
+} | {
     readonly kind: 'draft.changed';
     readonly flowId: string;
     readonly revisionId: string;

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

@@ -0,0 +1,17 @@
+import type { JsonValue, PortDefinition, SchemaMismatch } from '../browser/flow-change.js';
+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 type PortCompareResult = {
+    readonly kind: 'compatible';
+} | {
+    readonly kind: 'compare-error';
+    readonly message: string;
+} | {
+    readonly kind: 'incompatible';
+    readonly mismatch: SchemaMismatch;
+};
+export declare function comparePorts(source: PortDefinition, target: PortDefinition): PortCompareResult;
+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,12 @@
-import type { FlowDocument, Graph, JsonValue, RevisionContent, TriggerNode } from '@oomol-lab/open-flow/flow-change';
+export { connectionUsage, removeConnectionUsage } from './flow-connectionUsage.js';
+export { matchesTriggerOutputs, triggerOutputDefinitions, triggerOutputPorts } from './trigger-contract.js';
 import type { EngineContract } from './engine-contract.js';
 import type { RuntimeProgram } from './runtime-contract.js';
+import type { ConnectorActionCapability, ConnectorCapability, FlowDocument, Graph, RevisionContent, SchemaMismatch } from '../browser/flow-change.js';
+export { availableOutputs, graphOrder, nodeInputPorts } from './flow-graph.js';
+export { validateModules } from './flow-modules.js';
+export { matchesSchema, variableInputCompatible } from './flow-schema.js';
+export { agentInput, agentToolInput, agentToolSchema } from './flow-agent.js';
 export interface SemanticClosure {
     readonly dependencies: {
         readonly bindings: ReadonlySet<string>;
@@ -11,14 +17,16 @@ export interface SemanticClosure {
     };
     readonly digest: string;
 }
-export declare function flowDependencies(content: RevisionContent): SemanticClosure['dependencies'];
+export declare function flowDependencies(content: RevisionContent, triggerId?: string): 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 {
     readonly code: string;
     readonly column: number;
+    readonly fields?: readonly string[];
     readonly line: number;
     readonly message: string;
+    readonly mismatch?: SchemaMismatch;
     readonly path: string;
     readonly values?: Readonly<Record<string, string | number>>;
 }
@@ -27,12 +35,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;
@@ -52,5 +57,8 @@ export type PrepareFlowResult = {
     readonly kind: 'prepared';
     readonly validation: FlowValidation;
 };
-export declare function prepareFlow(revision: RevisionContent, engineContract: string): Promise<PrepareFlowResult>;
+export declare function prepareFlow(revision: RevisionContent, engineContract: string, triggerId?: string): Promise<PrepareFlowResult>;
 export declare function createRuntimeProgram(prepared: PreparedFlow, entryModuleId: string, engineDigest: string): RuntimeProgram | undefined;
+export declare function referencedTaskIds(flow: Pick<FlowDocument, 'graph' | 'subflows' | 'tasks'>): ReadonlySet<string>;
+export declare function agentActions(flow: Pick<PreparedFlow, 'tasks'>): readonly ConnectorActionCapability[];
+export declare function codeActions(flow: Pick<PreparedFlow, 'graph' | 'subflows'>): readonly ConnectorCapability[];