@oomol-lab/open-flow 0.1.0-beta.71 → 0.1.0-beta.73

package/dist/browser/workbench.js

@@ -3,7 +3,7 @@ import { a as derive, i as compute, l as val } from "./dist-bO8nvHFH.js";
 import { c as useLang, l as useTranslate, o as I18nProvider, u as useVal } from "./dist-BFmpkX4P.js";
 import { br as cn, i as TooltipTrigger, n as TooltipContent, t as Tooltip, vr as Button } from "./tooltip-wZJRB9oP.js";
 import { C as resourceNameIssue, It as Input, M as mapConditionSources, N as nodeInputMappings, T as upgradeRevisionContent, _ as applyFlowChanges, a as DialogFooter, d as Field, g as FlowChangeError, gt as dequal$1, h as FieldLabel, i as DialogDescription, l as Icon, m as FieldGroup, o as DialogHeader, p as FieldError, r as DialogContent, s as DialogTitle, t as Dialog, u as Spinner, v as isTriggerNode, w as upgradeManualTrigger } from "./dialog-CUy_fwx9.js";
-import { $ as designerGraph, $t as errorNotice, At as setInputSources, Bt as Empty, C as updateWebhook, Ct as setFlowViewport, Dt as resetInputValues, Et as repairNodeNames, Fn as jsonValue, Ft as IdTooltip, G as combineSources, Gt as EmptyTitle, H as addNodeIntent, Ht as EmptyDescription, In as record, It as followWorkbenchLink, J as CacheResource, Kt as Badge, Ln as string, Lt as InputGroup, Mt as updateStartInputDefs, Nt as updateTriggerSchedule, Ot as setCodeActions, Pn as invalidResponse, Pt as WorkflowExportMenuItem, Q as connectorActionPorts, Rn as ApiError, Rt as InputGroupAddon, S as updateValue, St as setComment, Tt as setNodePositions, U as deriveAddNodeOptions, Ut as EmptyHeader, Vt as EmptyContent, Wt as EmptyMedia, X as resourceData, Xt as createI18n, Z as resourceValue, _ as updateResolution, _n as parseWorkflowFile, _t as canvasPresentationChange, a as nameCreatedNodes, b as updateTaskPorts, bt as removeComments, c as setInputVariable, ct as flowResourceReferences, d as updateCondition, dn as sampleErrorOutputs, dt as diagnosticItems, en as WorkbenchClient, f as updateNodeDescription, fn as triggerOutputDefinitions, g as updateOutputPorts, gn as encodeWorkflowFile, gt as connectionCatalog, h as updateNodeSettings, hn as connectorActionMetadata, ht as actionWithConnections, i as deleteSelection, in as decodeTriggerCatalog, it as RunStore, jn as workflowCandidate, jt as setServiceConnections, kt as setConnectorConnection, l as setTriggerConnection, lt as Latest, m as updateNodeName, mn as connection, nn as allConnectorConnectionsQuery, o as selectWebhookResponse, p as updateNodeIcon, q as scopedValue, qt as EventSourcesPage, r as applyFlowChanges$1, rt as providerIcon, s as setInputValue, st as revisionView, t as addNode, tn as randomId, u as setTriggerEventSource, un as normalizeTriggerOutputs, ut as deriveInspectorDiagnostics, v as updateTask, vn as workflowFileName, vt as commentIds, wt as setNodeContentHidden, x as updateTriggerConfig, xt as restoreCanvasPresentation, y as updateTaskAdditionalInputs, yn as workflowNameFromFile, yt as flowPresentation, zn as controlErrorCode, zt as InputGroupInput } from "./flowChanges-9Ir2rdLx.js";
+import { $ as designerGraph, $t as errorNotice, At as setInputSources, Bt as Empty, C as updateWebhook, Ct as setFlowViewport, Dt as resetInputValues, Et as repairNodeNames, Fn as jsonValue, Ft as IdTooltip, G as combineSources, Gt as EmptyTitle, H as addNodeIntent, Ht as EmptyDescription, In as record, It as followWorkbenchLink, J as CacheResource, Kt as Badge, Ln as string, Lt as InputGroup, Mt as updateStartInputDefs, Nt as updateTriggerSchedule, Ot as setCodeActions, Pn as invalidResponse, Pt as WorkflowExportMenuItem, Q as connectorActionPorts, Rn as ApiError, Rt as InputGroupAddon, S as updateValue, St as setComment, Tt as setNodePositions, U as deriveAddNodeOptions, Ut as EmptyHeader, Vt as EmptyContent, Wt as EmptyMedia, X as resourceData, Xt as createI18n, Z as resourceValue, _ as updateResolution, _n as parseWorkflowFile, _t as canvasPresentationChange, a as nameCreatedNodes, b as updateTaskPorts, bt as removeComments, c as setInputVariable, ct as flowResourceReferences, d as updateCondition, dn as sampleErrorOutputs, dt as diagnosticItems, en as WorkbenchClient, f as updateNodeDescription, fn as triggerOutputDefinitions, g as updateOutputPorts, gn as encodeWorkflowFile, gt as connectionCatalog, h as updateNodeSettings, hn as connectorActionMetadata, ht as actionWithConnections, i as deleteSelection, in as decodeTriggerCatalog, it as RunStore, jn as workflowCandidate, jt as setServiceConnections, kt as setConnectorConnection, l as setTriggerConnection, lt as Latest, m as updateNodeName, mn as connection, nn as allConnectorConnectionsQuery, o as selectWebhookResponse, p as updateNodeIcon, q as scopedValue, qt as EventSourcesPage, r as applyFlowChanges$1, rt as providerIcon, s as setInputValue, st as revisionView, t as addNode, tn as randomId, u as setTriggerEventSource, un as normalizeTriggerOutputs, ut as deriveInspectorDiagnostics, v as updateTask, vn as workflowFileName, vt as commentIds, wt as setNodeContentHidden, x as updateTriggerConfig, xt as restoreCanvasPresentation, y as updateTaskAdditionalInputs, yn as workflowNameFromFile, yt as flowPresentation, zn as controlErrorCode, zt as InputGroupInput } from "./flowChanges-CgSnSqqP.js";
 import { a as uiLanguages, i as uiLanguageNames, n as isUiLanguage, r as resolveUiLanguage, t as importedWorkflowName } from "./languages-gYzoQqCi.js";
 import { Suspense, forwardRef, lazy, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
@@ -7420,7 +7420,7 @@ var WorkbenchStore = class {
 };
 //#endregion
 //#region src/workbench/browser/runtime/openFlowWorkbench.tsx
-var FlowWorkspace = lazy(() => import("./flowWorkspace-LvZ6HuMM.js"));
+var FlowWorkspace = lazy(() => import("./flowWorkspace-Bf7H-r0t.js"));
 function OpenFlowSessionGate({ action, description, error, onSubmit, onTokenChange, pending = false, title, token, tokenLabel }) {
 	const hasToken = token != null && tokenLabel != null && onTokenChange != null;
 	const tokenValue = token ?? "";

package/dist/command/index.js

@@ -1,5 +1,5 @@
 // @bun
-var Gb=Object.defineProperty;var Hb=(e)=>e;function Qb(e,n){this[e]=Hb.bind(null,n)}var no=(e,n)=>{for(var t in n)Gb(e,t,{get:n[t],enumerable:!0,configurable:!0,set:Qb.bind(n,t)})};var Iu="0.1.0-beta.71";var rs=["en","zh-CN","zh-TW","ja","ko","ru","fr"],Cu="en";var ts=new Map(rs.map((e)=>[e.toLowerCase(),e])),Xb=new Set(["hk","mo","tw"]);function Ou(e){return typeof e=="string"&&ts.get(e.toLowerCase())==e}function to(e,n="en"){for(let t of e){let r=t==null?void 0:ew(t);if(r!=null)return r}return n}function ew(e){let n=e.trim().toLowerCase();if(n.length==0)return;let t=ts.get(n);if(t!=null)return t;let r=n.split("-");if(r[0]=="zh"){if(r.includes("hant"))return"zh-TW";if(r.includes("hans"))return"zh-CN";return r.some((o)=>Xb.has(o))?"zh-TW":"zh-CN"}return ts.get(r[0])}function Eu(e){return{en:"Imported workflow","zh-CN":"\u5BFC\u5165\u7684\u5DE5\u4F5C\u6D41","zh-TW":"\u532F\u5165\u7684\u5DE5\u4F5C\u6D41",ja:"\u30A4\u30F3\u30DD\u30FC\u30C8\u3057\u305F\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC",ko:"\uAC00\uC838\uC628 \uC6CC\uD06C\uD50C\uB85C",fr:"Workflow import\xE9",ru:"\u0418\u043C\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u043F\u0440\u043E\u0446\u0435\u0441\u0441"}[e]}import{spawn as IC}from"child_process";import{readFile as CC}from"fs/promises";import{setTimeout as OC}from"timers/promises";var ro="open-flow-engine/v7";var nw={waitAutoContinue:!0,webhookResponses:!0,platformExports:new Set(["engineContract","identity"]),platformModule:"open-flow:platform",platformSource:`export const engineContract = ${JSON.stringify("open-flow-engine/v7")}
+var Gb=Object.defineProperty;var Hb=(e)=>e;function Qb(e,n){this[e]=Hb.bind(null,n)}var no=(e,n)=>{for(var t in n)Gb(e,t,{get:n[t],enumerable:!0,configurable:!0,set:Qb.bind(n,t)})};var Iu="0.1.0-beta.73";var rs=["en","zh-CN","zh-TW","ja","ko","ru","fr"],Cu="en";var ts=new Map(rs.map((e)=>[e.toLowerCase(),e])),Xb=new Set(["hk","mo","tw"]);function Ou(e){return typeof e=="string"&&ts.get(e.toLowerCase())==e}function to(e,n="en"){for(let t of e){let r=t==null?void 0:ew(t);if(r!=null)return r}return n}function ew(e){let n=e.trim().toLowerCase();if(n.length==0)return;let t=ts.get(n);if(t!=null)return t;let r=n.split("-");if(r[0]=="zh"){if(r.includes("hant"))return"zh-TW";if(r.includes("hans"))return"zh-CN";return r.some((o)=>Xb.has(o))?"zh-TW":"zh-CN"}return ts.get(r[0])}function Eu(e){return{en:"Imported workflow","zh-CN":"\u5BFC\u5165\u7684\u5DE5\u4F5C\u6D41","zh-TW":"\u532F\u5165\u7684\u5DE5\u4F5C\u6D41",ja:"\u30A4\u30F3\u30DD\u30FC\u30C8\u3057\u305F\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC",ko:"\uAC00\uC838\uC628 \uC6CC\uD06C\uD50C\uB85C",fr:"Workflow import\xE9",ru:"\u0418\u043C\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u043F\u0440\u043E\u0446\u0435\u0441\u0441"}[e]}import{spawn as IC}from"child_process";import{readFile as CC}from"fs/promises";import{setTimeout as OC}from"timers/promises";var ro="open-flow-engine/v7";var nw={waitAutoContinue:!0,webhookResponses:!0,platformExports:new Set(["engineContract","identity"]),platformModule:"open-flow:platform",platformSource:`export const engineContract = ${JSON.stringify("open-flow-engine/v7")}
 export function identity(value) { return value }
 `},AC={...nw,builtinModules:new Set(["assert","assert/strict","buffer","console","constants","crypto","events","fs","fs/promises","os","path","path/posix","process","punycode","querystring","stream","stream/promises","stream/web","string_decoder","timers","timers/promises","url","util","zlib"].flatMap((e)=>[e,`node:${e}`])),platformSource:`export const engineContract = ${JSON.stringify("open-flow-engine/v7/nodejs-compat-v1")}
 export function identity(value) { return value }

package/dist/common/control-api.js

@@ -11520,11 +11520,16 @@ function readResult(value, query = {}) {
 		offset,
 		value: selected
 	};
-	if (offset == 0 && (query.limit == null || description.length == null || description.length <= limit) && bytes(whole) <= maxBytes) return whole;
+	if (offset == 0 && (query.limit == null || description.length == null || description.length <= limit) && (typeof selected != "string" || selected.length <= maxBytes) && bytes(whole) <= maxBytes) return whole;
 	const root = description;
 	if (typeof selected == "string") {
 		let length = 0;
-		for (const _ of selected) length++;
+		let start = 0;
+		for (let index = 0; index < selected.length; length++) {
+			if (length == offset) start = index;
+			const point = selected.codePointAt(index);
+			index += point > 65535 ? 2 : 1;
+		}
 		if (offset >= length) throw new Error("Result offset is out of range.");
 		const budget = maxBytes - bytes({
 			...root,
@@ -11534,17 +11539,23 @@ function readResult(value, query = {}) {
 			nextOffset: length
 		});
 		let used = 0;
-		let text = "";
+		let cursor = start;
 		let end = offset;
-		let position = 0;
-		for (const char of selected) {
-			if (position++ < offset) continue;
-			const size = bytes(char) - 2;
+		while (cursor < selected.length) {
+			const point = selected.codePointAt(cursor);
+			let size;
+			if (point == 34 || point == 92 || point == 8 || point == 9 || point == 10 || point == 12 || point == 13) size = 2;
+			else if (point < 32 || point >= 55296 && point <= 57343) size = 6;
+			else if (point < 128) size = 1;
+			else if (point < 2048) size = 2;
+			else if (point <= 65535) size = 3;
+			else size = 4;
 			if (used + size > budget) break;
-			text += char;
+			cursor += point > 65535 ? 2 : 1;
 			used += size;
 			end++;
 		}
+		const text = selected.slice(start, cursor);
 		if (end == offset) throw new Error("Result byte budget cannot fit a string character and page metadata.");
 		return {
 			...root,
@@ -11559,6 +11570,13 @@ function readResult(value, query = {}) {
 	const keys = Object.keys(selected);
 	if (offset >= keys.length) throw new Error("Result offset is out of range.");
 	const entries = [];
+	const overhead = bytes({
+		...root,
+		offset,
+		entries: [],
+		nextOffset: keys.length
+	});
+	let used = overhead;
 	for (const key of keys.slice(offset, offset + limit)) {
 		const path = `${pointer}/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`;
 		const item = Array.isArray(selected) ? selected[Number(key)] : selected[key];
@@ -11568,19 +11586,12 @@ function readResult(value, query = {}) {
 			complete: true,
 			value: item
 		};
-		const next = bytes({
-			...root,
-			offset,
-			entries: [full],
-			nextOffset: keys.length
-		}) <= maxBytes ? full : metadata;
-		if (bytes({
-			...root,
-			offset,
-			entries: [...entries, next],
-			nextOffset: keys.length
-		}) > maxBytes) break;
+		const fullBytes = bytes(full);
+		const next = overhead + fullBytes <= maxBytes ? full : metadata;
+		const size = (next === full ? fullBytes : bytes(metadata)) + (entries.length == 0 ? 0 : 1);
+		if (used + size > maxBytes) break;
 		entries.push(next);
+		used += size;
 	}
 	if (entries.length == 0) throw new Error("Result property name exceeds the preview limit. Download the full result.");
 	const end = offset + entries.length;

package/dist/common/scheduler-checkpoint.d.ts

@@ -0,0 +1,42 @@
+import type { Graph, JsonValue } from '../browser/flow-change.js';
+import type { DependenciesCheckpoint } from './scheduler-dependencies.js';
+import type { ExecutableNode } from './scheduler-node-execution.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
+export interface PendingWait {
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly value: JsonValue;
+    readonly waitId: string;
+    readonly pending?: JsonValue;
+}
+export interface PendingWorkflowCall {
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly childRunId: string;
+    readonly input: Readonly<Record<string, JsonValue>>;
+}
+export interface FlowRunCheckpoint {
+    readonly calls?: readonly PendingWorkflowCall[];
+    readonly bindingValues: Readonly<Record<string, string>>;
+    readonly inputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+    readonly results: Readonly<Record<string, {
+        readonly handled?: true;
+        readonly jobId: string;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
+        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
+    }>>;
+    readonly counts: Readonly<Record<string, Readonly<Record<string, number>>>>;
+    readonly dependencies: DependenciesCheckpoint;
+    readonly version: 6;
+    readonly waits: readonly PendingWait[];
+    readonly agents: Readonly<Record<string, {
+        readonly invocationId: string;
+        readonly input: Readonly<Record<string, JsonValue>>;
+        readonly remainingMs?: number;
+        readonly checkpoint: AgentCheckpoint;
+    }>>;
+}
+export declare function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint;
+export declare function validateCheckpoint(target: {
+    readonly graph: Graph;
+}, checkpoint: FlowRunCheckpoint, resolveInputs: (nodeId: string, node: ExecutableNode) => Readonly<Record<string, JsonValue>>): void;

package/dist/common/scheduler-dependencies.d.ts

@@ -0,0 +1,80 @@
+import type { Graph, JsonValue } from '../browser/flow-change.js';
+import { z } from 'zod';
+export interface DependenciesCheckpoint {
+    nextId: number;
+    iterations: Record<string, number>;
+    nodes: Record<string, DependencyState>;
+}
+interface DependencyState {
+    id: number;
+    status: 'pending' | 'running' | 'completed' | 'skipped';
+    input: Record<string, {
+        readonly execution: number;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
+        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
+    }>;
+    systemOutputs?: Readonly<Record<string, JsonValue>>;
+    output?: Readonly<Record<string, JsonValue>>;
+    previous: string[];
+    released: string[];
+    jobId?: string;
+    seeded: boolean;
+}
+type InputSnapshot = DependenciesCheckpoint['nodes'][string]['input'];
+export declare function dependencyValues(input: InputSnapshot): Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+export declare const dependenciesSchema: z.ZodObject<{
+    nextId: z.ZodNumber;
+    iterations: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodNumber;
+        status: z.ZodEnum<{
+            completed: "completed";
+            pending: "pending";
+            running: "running";
+            skipped: "skipped";
+        }>;
+        input: z.ZodRecord<z.ZodString, z.ZodObject<{
+            execution: z.ZodNumber;
+            outputs: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            systemOutputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        }, z.core.$strict>>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        systemOutputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        previous: z.ZodArray<z.ZodString>;
+        released: z.ZodArray<z.ZodString>;
+        jobId: z.ZodOptional<z.ZodString>;
+        seeded: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Dependency completion belongs to an invocation, never to a Run-wide latest-result table. */
+export declare class Dependencies {
+    readonly state: DependenciesCheckpoint;
+    private readonly forward;
+    private readonly loops;
+    private readonly innerLoopsFirst;
+    private readonly outgoing;
+    private readonly incoming;
+    private readonly candidates;
+    private readonly frames;
+    private readonly graph;
+    constructor(graph: Graph, saved?: DependenciesCheckpoint);
+    private fresh;
+    private validate;
+    start(nodeId: string, outputs: Readonly<Record<string, JsonValue>>): void;
+    private edge;
+    private edgeResult;
+    input(nodeId: string, sourceId: string): InputSnapshot[string] | undefined;
+    private snapshot;
+    private collectInputs;
+    private loopSettled;
+    private blockedByLoop;
+    private continuationPending;
+    private selectedIncoming;
+    private readyAcyclic;
+    /** Resolve skips and iteration boundaries before admitting another invocation. */
+    ready(): string[];
+    begin(nodeId: string, jobId: string): void;
+    release(nodeId: string, outputs: Readonly<Record<string, JsonValue>>, handles: readonly string[], complete: boolean, systemOutputs?: Readonly<Record<string, JsonValue>>): void;
+    get incomplete(): boolean;
+}
+export {};

package/dist/common/scheduler-node-execution.d.ts

@@ -0,0 +1,75 @@
+import type { AgentConfig } from './flow-agent.js';
+import type { Graph, GraphNode, JsonValue, TriggerNode } from '../browser/flow-change.js';
+import type { WebhookResponseSnapshot } from './webhook-response.js';
+import type { FlowRunCheckpoint } from './scheduler-checkpoint.js';
+import type { Dependencies } from './scheduler-dependencies.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
+import type { FlowRunOptions, SchedulerEvent, SchedulerFailure } from './scheduler.js';
+import * as Effect from 'effect/Effect';
+import { z } from 'zod';
+interface NodeExecutionContext {
+    readonly createId: FlowRunOptions['createId'];
+    readonly emit: (event: SchedulerEvent) => Effect.Effect<void, Error>;
+    readonly invokeTask: FlowRunOptions['invokeTask'];
+    readonly projectFailure: FlowRunOptions['projectFailure'];
+}
+export declare class PortValidationError extends Error {
+}
+export type ExecutableNode = Exclude<GraphNode, TriggerNode>;
+export declare function usesPending(graph: Graph, nodeId: string): boolean;
+export declare class NodeValidationError extends PortValidationError {
+    readonly code: 'node.input-invalid' | 'node.output-invalid' | 'webhook.response-status-invalid' | 'webhook.response-headers-invalid';
+    constructor(code: NodeValidationError['code'], error: unknown);
+}
+export declare function nodeFailure(error: unknown, project: FlowRunOptions['projectFailure']): SchedulerFailure;
+export declare function nodeTitle(node: GraphNode): string | undefined;
+export declare function jsonValue(value: unknown, description: string, depth?: number): JsonValue;
+export declare const agentCheckpointSchema: z.ZodObject<{
+    state: z.ZodJSONSchema;
+    callId: z.ZodString;
+    toolId: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    rounds: z.ZodNumber;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>;
+export declare function jsonEqual(left: JsonValue, right: JsonValue): boolean;
+export declare function outputRecord(value: unknown, nodeId: string): Readonly<Record<string, JsonValue>>;
+export declare function agentConfig(node: ExecutableNode): AgentConfig | undefined;
+export declare function agentNotice(node: ExecutableNode, values: Readonly<Record<string, JsonValue>>): {
+    messageHandle: string;
+    input: {
+        [k: string]: JsonValue;
+    };
+} | undefined;
+export declare function agentApproval(config: AgentConfig, checkpoint: AgentCheckpoint, inputs: Readonly<Record<string, JsonValue>>): JsonValue;
+export declare function validateOutputs(nodeId: string, node: ExecutableNode, value: unknown): Readonly<Record<string, JsonValue>>;
+export type NodeResult = {
+    readonly kind: 'calling';
+    readonly childRunId: string;
+    readonly input: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly kind: 'completed';
+    readonly releasedHandles?: readonly string[];
+    readonly outputs: Readonly<Record<string, JsonValue>>;
+    readonly response?: WebhookResponseSnapshot;
+} | {
+    readonly kind: 'suspended';
+    readonly value: JsonValue;
+    readonly agent: FlowRunCheckpoint['agents'][string];
+};
+export declare function resolveNodeInputs(nodeId: string, node: ExecutableNode, dependencies: Pick<Dependencies, 'input'>, bindingValues: Readonly<Record<string, string>>, launchInputs?: Readonly<Record<string, JsonValue>>): Readonly<Record<string, JsonValue>>;
+export declare function executeNode(context: NodeExecutionContext, input: {
+    readonly nodeId: string;
+    readonly node: ExecutableNode;
+    readonly jobId: string;
+    readonly nodeInputs: Readonly<Record<string, JsonValue>>;
+    readonly flowId: string;
+    readonly runId: string;
+    readonly graph: Graph;
+    readonly dependencies: Pick<Dependencies, 'input'>;
+    readonly previousIds: readonly string[];
+    readonly saved?: FlowRunCheckpoint['agents'][string];
+    readonly workflowRunId?: string;
+    readonly resolution?: 'approve' | 'reject';
+}): Effect.Effect<NodeResult, Error>;
+export {};

package/dist/common/scheduler.d.ts

@@ -2,8 +2,13 @@ import type { ConnectorCapability, JsonValue, WaitAction, WaitAutoContinue } fro
 import type { PreparedFlow } from './flow-semantics.js';
 import type { WebhookResponseSnapshot } from './webhook-response.js';
 import type { PreviousNode } from '../index.js';
+import type { FlowRunCheckpoint } from './scheduler-checkpoint.js';
 import type { AgentCheckpoint } from './runtime-contract.js';
 import * as Effect from 'effect/Effect';
+export type { DependenciesCheckpoint } from './scheduler-dependencies.js';
+export type { FlowRunCheckpoint, PendingWait, PendingWorkflowCall } from './scheduler-checkpoint.js';
+export { decodeFlowRunCheckpoint } from './scheduler-checkpoint.js';
+export { PortValidationError } from './scheduler-node-execution.js';
 export declare const withWaitNotificationMessage: (value: JsonValue) => JsonValue;
 export declare const normalizeWaitComment: (value?: string | null) => string | null;
 export declare const waitAutoContinueAt: (config: WaitAutoContinue, waitingSince: number) => number;
@@ -12,8 +17,6 @@ export interface WaitResolution {
     readonly resolvedAt: string;
     readonly comment: string | null;
 }
-export declare class PortValidationError extends Error {
-}
 export type SchedulerEvent = {
     readonly flowId: string;
     readonly parentJobId?: string;
@@ -81,13 +84,6 @@ export interface FlowRunResult {
         readonly outputs: Readonly<Record<string, JsonValue>>;
     }[];
 }
-export interface PendingWait {
-    readonly jobId: string;
-    readonly nodeId: string;
-    readonly value: JsonValue;
-    readonly waitId: string;
-    readonly pending?: JsonValue;
-}
 export interface WaitRequest {
     readonly autoContinue?: WaitAutoContinue;
     readonly jobId: string;
@@ -115,53 +111,6 @@ export interface WaitHost {
     readonly resolutions: (waitIds: readonly string[], block: boolean) => Effect.Effect<Readonly<Record<string, WaitResolution>>, Error>;
 }
 export declare const waitRetentionMs = 120000;
-export interface DependenciesCheckpoint {
-    nextId: number;
-    iterations: Record<string, number>;
-    nodes: Record<string, DependencyState>;
-}
-interface DependencyState {
-    id: number;
-    status: 'pending' | 'running' | 'completed' | 'skipped';
-    input: Record<string, {
-        readonly execution: number;
-        readonly outputs: Readonly<Record<string, JsonValue>>;
-        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
-    }>;
-    systemOutputs?: Readonly<Record<string, JsonValue>>;
-    output?: Readonly<Record<string, JsonValue>>;
-    previous: string[];
-    released: string[];
-    jobId?: string;
-    seeded: boolean;
-}
-export interface PendingWorkflowCall {
-    readonly jobId: string;
-    readonly nodeId: string;
-    readonly childRunId: string;
-    readonly input: Readonly<Record<string, JsonValue>>;
-}
-export interface FlowRunCheckpoint {
-    readonly calls?: readonly PendingWorkflowCall[];
-    readonly bindingValues: Readonly<Record<string, string>>;
-    readonly inputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
-    readonly results: Readonly<Record<string, {
-        readonly handled?: true;
-        readonly jobId: string;
-        readonly outputs: Readonly<Record<string, JsonValue>>;
-        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
-    }>>;
-    readonly counts: Readonly<Record<string, Readonly<Record<string, number>>>>;
-    readonly dependencies: DependenciesCheckpoint;
-    readonly version: 6;
-    readonly waits: readonly PendingWait[];
-    readonly agents: Readonly<Record<string, {
-        readonly invocationId: string;
-        readonly input: Readonly<Record<string, JsonValue>>;
-        readonly remainingMs?: number;
-        readonly checkpoint: AgentCheckpoint;
-    }>>;
-}
 export type FlowRunOutcome = FlowRunResult | {
     readonly checkpoint: FlowRunCheckpoint;
     readonly kind: 'waiting';
@@ -223,6 +172,4 @@ export type RunLaunch = {
     readonly inputs?: never;
     readonly trigger?: never;
 };
-export declare function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint;
 export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunOutcome, Error>;
-export {};