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

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.72";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/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 {};