@oomol-lab/open-flow 0.1.0-beta.77 → 0.1.0-beta.78

package/dist/common/scheduler.d.ts

@@ -33,7 +33,7 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'http-request' | 'dedupe' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
+    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'http-request' | 'skip-duplicates' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
@@ -167,6 +167,7 @@ export type RunLaunch = {
 } | {
     readonly resume: {
         readonly checkpoint: unknown;
+        readonly readyWorkflowRunIds?: readonly string[];
     };
     readonly bindingValues?: never;
     readonly inputs?: never;

package/dist/common/scheduler.js

@@ -14,37 +14,6 @@ var nanoid$1 = (size = 21) => {
 	return id;
 };
 //#endregion
-//#region src/flow/common/inputValue.ts
-/** An explicit clear suppresses the default; absent mappings still inherit it. */
-function inputValue(mapping, fallback) {
-	if (mapping?.kind === "unset") return void 0;
-	return mapping?.kind === "value" ? mapping.value : fallback;
-}
-//#endregion
-//#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
-var has = Object.prototype.hasOwnProperty;
-function dequal(foo, bar) {
-	var ctor, len;
-	if (foo === bar) return true;
-	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-		if (ctor === Date) return foo.getTime() === bar.getTime();
-		if (ctor === RegExp) return foo.toString() === bar.toString();
-		if (ctor === Array) {
-			if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
-			return len === -1;
-		}
-		if (!ctor || typeof foo === "object") {
-			len = 0;
-			for (ctor in foo) {
-				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
-			}
-			return Object.keys(bar).length === len;
-		}
-	}
-	return foo !== foo && bar !== bar;
-}
-//#endregion
 //#region ../../node_modules/.bun/zod@4.6.5/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -5719,6 +5688,37 @@ function datetime(params) {
 	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
 }
 //#endregion
+//#region src/flow/common/inputValue.ts
+/** An explicit clear suppresses the default; absent mappings still inherit it. */
+function inputValue(mapping, fallback) {
+	if (mapping?.kind === "unset") return void 0;
+	return mapping?.kind === "value" ? mapping.value : fallback;
+}
+//#endregion
+//#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+		if (ctor === Array) {
+			if ((len = foo.length) === bar.length) while (len-- && dequal(foo[len], bar[len]));
+			return len === -1;
+		}
+		if (!ctor || typeof foo === "object") {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+	return foo !== foo && bar !== bar;
+}
+//#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
 	const typeofa = typeof a;
@@ -9547,11 +9547,7 @@ strictObject({
 	scope: _enum(["draft", "live"]),
 	space: string$1().regex(/^(flow|node:.+)$/)
 });
-var dedupeExecutorSchema = strictObject({
-	field: string$1().default(""),
-	mode: _enum(["new", "increasing"]).default("new"),
-	space: _enum(["node", "flow"]).default("node")
-}).extend({ kind: literal("dedupe") });
+var skipDuplicatesExecutorSchema = strictObject({ fields: array(string$1().refine((field) => field.length > 0 && field.split(".").every((part) => part.length > 0), "Use a nonempty dot-separated field path.")).refine((fields) => new Set(fields).size === fields.length, "Identity fields must be distinct.").default([]) }).extend({ kind: literal("skip-duplicates") });
 object({
 	version: literal(1),
 	scope: _enum(["draft", "live"]),
@@ -9570,13 +9566,9 @@ object({
 	})),
 	spaces: array(object({
 		space: string$1(),
-		mode: _enum(["new", "increasing"]),
 		count: number().nonnegative(),
-		watermark: union([
-			string$1(),
-			number(),
-			_null()
-		]),
+		pendingCount: number().nonnegative(),
+		reservedCount: number().nonnegative(),
 		updatedAt: number()
 	}))
 });
@@ -9935,7 +9927,7 @@ var managedFields = object({
 			revisionId: text
 		}),
 		httpRequestExecutorSchema,
-		dedupeExecutorSchema
+		skipDuplicatesExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -10598,7 +10590,7 @@ var nodeErrorSchema = {
 	}
 };
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe";
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "skip-duplicates";
 }
 function nodeSystemOutputPorts(node) {
 	return supportsNodeErrorHandling(node) && node.onError == "error" ? { error: {
@@ -11997,6 +11989,8 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 		const changes = yield* Queue.unbounded();
 		let remainingMs = context.remainingMs;
 		let measuredAt = yield* Clock.currentTimeMillis;
+		let nextCallCheckAt = measuredAt + (resume == null ? 1e3 : 0);
+		let readyWorkflowRunIds = resume?.readyWorkflowRunIds;
 		let idleSince;
 		const agents = { ...resume?.checkpoint.agents };
 		const resolveInputs = (nodeId, node) => resolveNodeInputs(nodeId, node, dependencies, context.bindingValues, launch[nodeId]);
@@ -12214,10 +12208,17 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 				return yield* Effect.failCause(firstCause);
 			}
 			if (pendingWaits.size > 0 && context.waits != null) applyResolutions(yield* context.waits.resolutions([...pendingWaits.values()].map((wait) => wait.waitId), false), now);
-			for (const call of pendingCalls.values()) yield* observe(call.nodeId, call.jobId, Effect.gen(function* () {
-				const result = yield* execute(call.nodeId, target.graph.nodes[call.nodeId], call.jobId, call.input);
-				yield* settleNode(call.nodeId, call.jobId, result);
-			})).pipe(Effect.catch(() => Effect.void));
+			if (pendingCalls.size > 0 && now >= nextCallCheckAt) {
+				for (const call of pendingCalls.values()) {
+					if (readyWorkflowRunIds != null && !readyWorkflowRunIds.has(call.childRunId)) continue;
+					yield* observe(call.nodeId, call.jobId, Effect.gen(function* () {
+						const result = yield* execute(call.nodeId, target.graph.nodes[call.nodeId], call.jobId, call.input);
+						yield* settleNode(call.nodeId, call.jobId, result);
+					})).pipe(Effect.catch(() => Effect.void));
+				}
+				readyWorkflowRunIds = void 0;
+				nextCallCheckAt = (yield* Clock.currentTimeMillis) + 1e3;
+			}
 			const ready = dependencies.ready();
 			for (const nodeId of ready) executeReady(nodeId);
 			const running = yield* FiberSet.size(active);
@@ -12252,7 +12253,7 @@ function runGraph(context, target, runId, launchInputs = {}, trigger, resume) {
 			const activity = Queue.take(changes).pipe(Effect.as({}));
 			const decision = pendingWaits.size == 0 || context.waits == null ? Effect.never : context.waits.resolutions([...pendingWaits.values()].map((wait) => wait.waitId), true);
 			let next = Effect.raceFirst(activity, decision);
-			if (pendingCalls.size > 0) next = Effect.raceFirst(next, Effect.sleep(1e3).pipe(Effect.as({})));
+			if (pendingCalls.size > 0) next = Effect.raceFirst(next, Effect.sleep(Math.max(0, nextCallCheckAt - (yield* Clock.currentTimeMillis))).pipe(Effect.as({})));
 			if (left != null) next = Effect.raceFirst(next, Effect.sleep(Math.max(0, left)).pipe(Effect.as({})));
 			applyResolutions(yield* next, yield* Clock.currentTimeMillis);
 		}
@@ -12290,6 +12291,8 @@ function runFlow(prepared, options) {
 	return Effect.gen(function* () {
 		if (options.resume != null && (options.inputs != null || options.trigger != null || options.bindingValues != null)) return yield* Effect.fail(/* @__PURE__ */ new Error("A resumed Flow Run cannot accept launch inputs, binding values, or a Trigger seed."));
 		const decoded = options.resume == null ? void 0 : decodeFlowRunCheckpoint(options.resume.checkpoint);
+		const readyWorkflowRunIds = options.resume?.readyWorkflowRunIds === void 0 ? void 0 : new Set(array(string$1().min(1)).parse(options.resume.readyWorkflowRunIds));
+		if (readyWorkflowRunIds != null && [...readyWorkflowRunIds].some((id) => !decoded?.calls?.some((call) => call.childRunId == id))) return yield* Effect.fail(/* @__PURE__ */ new Error("Ready workflow Run is not present in the checkpoint."));
 		const outputs = (nodeId, value) => isResolutionNode(prepared.graph.nodes[nodeId]) && value.pending != null ? {
 			...value,
 			pending: withWaitNotificationMessage(value.pending)
@@ -12340,7 +12343,10 @@ function runFlow(prepared, options) {
 			inputDefs: prepared.inputDefs,
 			outputDefs: prepared.outputDefs,
 			outputMappings: prepared.outputMappings
-		}, options.runId, options.inputs, trigger, checkpoint == null ? void 0 : { checkpoint });
+		}, options.runId, options.inputs, trigger, checkpoint == null ? void 0 : {
+			checkpoint,
+			readyWorkflowRunIds
+		});
 	});
 }
 //#endregion

package/dist/common/state-conformance.d.ts

@@ -1,11 +1,11 @@
 import type { JsonValue } from './flow-model.js';
-import type { DedupeConfig } from './flow-state.js';
+import type { SkipDuplicatesConfig } from './flow-state.js';
 export interface StateConformanceHarness {
     readonly maxIdentities: number;
     /** Executes Code on the same initially empty Flow and scope on every call; returns its `result` output. */
     run(source: string): Promise<JsonValue>;
-    /** Executes the same dedupe node across Runs, updating its business config and items. */
-    dedupe(config: DedupeConfig, items: JsonValue[]): Promise<{
+    /** Executes the same Skip Duplicates node across Runs, updating its business config and items. */
+    skipDuplicates(config: SkipDuplicatesConfig, items: JsonValue[]): Promise<{
         items: JsonValue[];
         duplicates: JsonValue[];
     }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oomol-lab/open-flow",
-  "version": "0.1.0-beta.77",
+  "version": "0.1.0-beta.78",
   "description": "TypeScript contracts and Browser runtime for Open Flow.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/src/control/common/api.ts

@@ -149,6 +149,11 @@ export interface PublicationPresentation {
   readonly presentation: Presentation | null
 }
 
+export interface FlowCreationOptions {
+  readonly tagIds?: readonly string[]
+  readonly presentation?: Readonly<Record<string, JsonValue>>
+}
+
 export interface Presentation {
   readonly revision: number
   readonly updatedAt: string
@@ -703,7 +708,7 @@ export function decodeRunEvent(value: unknown) {
             nodeKind !== 'decision' &&
             nodeKind !== 'openapi' &&
             nodeKind !== 'http-request' &&
-            nodeKind !== 'dedupe' &&
+            nodeKind !== 'skip-duplicates' &&
             nodeKind !== 'llm' &&
             nodeKind !== 'agent' &&
             nodeKind !== 'value' &&
@@ -941,10 +946,22 @@ export class ControlClient {
     )
   }
 
-  async createFlow(name: string, idempotencyKey = `flow-${randomId()}`, teamId?: string, tagIds?: readonly string[]): Promise<Flow> {
+  async createFlow(
+    name: string,
+    idempotencyKey = `flow-${randomId()}`,
+    teamId?: string,
+    tagIds?: readonly string[],
+    initialPresentation?: Readonly<Record<string, JsonValue>>,
+  ): Promise<Flow> {
     return flow(
       await this.request('/v1/flows', {
-        body: JSON.stringify({ name, ...(teamId == null ? {} : { teamId }), ...(tagIds == null ? {} : { tagIds }), version: 1 }),
+        body: JSON.stringify({
+          name,
+          ...(teamId == null ? {} : { teamId }),
+          ...(tagIds == null ? {} : { tagIds }),
+          ...(initialPresentation == null ? {} : { presentation: initialPresentation }),
+          version: 1,
+        }),
         headers: { 'idempotency-key': idempotencyKey },
         method: 'POST',
       }),

package/src/control/common/authoring.ts

@@ -43,7 +43,7 @@ import {
 } from '../../flow/common/nodeChanges.ts'
 import { retryConfigurationSchema } from '../../flow/common/retry.ts'
 import { httpRequestTask, httpRequestConfigSchema, httpRequestInputs } from '../../http/common/httpRequest.ts'
-import { dedupeConfigSchema, dedupeTask } from '../../state/common/state.ts'
+import { skipDuplicatesConfigSchema, skipDuplicatesTask } from '../../state/common/state.ts'
 import { withWorkflowTask, workflowTask, workflowSelectionTask, workflowCapability, workflowAgentTool } from '../../workflow/common/workflow.ts'
 import { conditionConfigurationView, prepareConditionConfiguration } from './authoringCondition.ts'
 import { authoringDiagnosticField } from './authoringDiagnosticFields.ts'
@@ -147,7 +147,7 @@ export function authoringNode(content: RevisionContent, ref: string) {
         ),
       }
     else if (task.executor.kind == 'workflow') config = { flowId: task.executor.flowId }
-    else if (task.executor.kind == 'http-request' || task.executor.kind == 'dedupe') {
+    else if (task.executor.kind == 'http-request' || task.executor.kind == 'skip-duplicates') {
       const { kind: _kind, ...settings } = task.executor
       config = settings
     } else if (task.executor.kind == 'openapi') {
@@ -522,7 +522,8 @@ export async function compileAuthoring(base: RevisionContent, request: Authoring
           task = { ...before, name: String(update.name), executor: { ...executor, ...config } } as ManagedTaskDefinition
         } else task = await connectorTask(config, String(update.name))
       } else if (type == 'decision') task = decisionTask(config.questions as Parameters<typeof decisionTask>[0], String(update.name))
-      else if (type == 'dedupe') task = { ...before, name: String(update.name), executor: { kind: 'dedupe', ...dedupeConfigSchema.parse(config) } }
+      else if (type == 'skip-duplicates')
+        task = { ...before, name: String(update.name), executor: { kind: 'skip-duplicates', ...skipDuplicatesConfigSchema.parse(config) } }
       else if (type == 'http-request') {
         task = httpRequestTask(httpRequestConfigSchema.parse(config), String(update.name), before)
         next = { ...next, inputs: httpRequestInputs(node.inputs, before, task) } as GraphNode
@@ -776,8 +777,8 @@ export async function compileAuthoring(base: RevisionContent, request: Authoring
             case 'connector':
               changes = createManagedTask(identity, await connectorTask(config, name))
               break
-            case 'dedupe':
-              changes = createManagedTask(identity, dedupeTask(dedupeConfigSchema.parse(config), name))
+            case 'skip-duplicates':
+              changes = createManagedTask(identity, skipDuplicatesTask(skipDuplicatesConfigSchema.parse(config), name))
               break
             case 'http-request':
               changes = createManagedTask(identity, httpRequestTask(httpRequestConfigSchema.parse(config), name))

package/src/control/common/authoringExamples.ts

@@ -13,7 +13,7 @@ import {
 } from '../../flow/common/nodeChanges.ts'
 import { httpRequestTask } from '../../http/common/httpRequest.ts'
 import { openApiTask, selectOperation } from '../../openapi/common/openapi.ts'
-import { dedupeTask } from '../../state/common/state.ts'
+import { skipDuplicatesTask } from '../../state/common/state.ts'
 
 const descriptions = {
   'start': 'A Start node with a required message parameter. Supply it through trigger.outputs.',
@@ -24,7 +24,8 @@ const descriptions = {
   'poll': 'Gmail polling by key; replace CONNECTION_ID with an active Gmail connection.',
   'integration': 'Telegram webhook integration by key; replace CONNECTION_ID with an active Telegram connection.',
   'decision': 'AI Decision evaluates named questions against target and returns a complete answer object per output. Configure target before running.',
-  'dedupe': 'Filter items using persistent history. Records immediately, including when downstream work fails. Empty field uses each scalar item as identity.',
+  'skip-duplicates':
+    'Skip items already recorded by successful Runs. Configure identity fields; an empty list uses each string or numeric item. History is private to the node and only commits after Run success.',
   'http-request': 'A single HTTP request. Bind url and request inputs; outputs are body, statusCode and headers.',
   'openapi': 'A fixed JSON API operation. Replace the example document and URL before running.',
   'connector':
@@ -59,10 +60,10 @@ export function authoringExample(name: string): { version: 1; operations: readon
         { name: 'needs_support', type: 'noul', instructions: 'Does the customer need support?' },
       ])
       break
-    case 'dedupe':
+    case 'skip-duplicates':
       operations = [
-        ...createManagedTask({ nodeId: 'dedupe' }, dedupeTask()),
-        { kind: 'graph.node.input.set', nodeId: 'dedupe', handle: 'items', value: { kind: 'value', value: ['a', 'b', 'a'] } },
+        ...createManagedTask({ nodeId: 'skip-duplicates' }, skipDuplicatesTask()),
+        { kind: 'graph.node.input.set', nodeId: 'skip-duplicates', handle: 'items', value: { kind: 'value', value: ['a', 'b', 'a'] } },
       ]
       break
     case 'http-request':

package/src/control/common/authoringSchema.ts

@@ -12,7 +12,7 @@ import {
 import { retryConfigurationSchema, retryNodeTypes } from '../../flow/common/retry.ts'
 import { httpRequestConfigSchema } from '../../http/common/httpRequest.ts'
 import { currentEngineContract, findEngineContract } from '../../runtime/common/engineContract.ts'
-import { dedupeConfigSchema } from '../../state/common/state.ts'
+import { skipDuplicatesConfigSchema } from '../../state/common/state.ts'
 import { authoringLlmConfiguration } from './authoringLlm.ts'
 import { authoringOpenApiSchema } from './authoringOpenApi.ts'
 
@@ -36,7 +36,7 @@ export const authoringTypes = [
   'decision',
   'openapi',
   'http-request',
-  'dedupe',
+  'skip-duplicates',
   'condition',
   'value',
   'wait',
@@ -120,7 +120,7 @@ export const authoringConfigurations = {
   'connector': definitions.connector.omit({ outputMode: true }).strict(),
   'openapi': authoringOpenApiSchema,
   'http-request': httpRequestConfigSchema,
-  'dedupe': dedupeConfigSchema,
+  'skip-duplicates': skipDuplicatesConfigSchema,
   'agent': definitions.agent
     .omit({ prompt: true, tools: true })
     .extend({
@@ -286,7 +286,7 @@ export function authoringSchema(kind?: AuthoringType) {
       }
     : {
         type: kind,
-        onError: kind == 'dedupe' || retryNodeTypes.some((nodeType) => nodeType == kind) ? { enum: ['stop', 'error'] } : false,
+        onError: kind == 'skip-duplicates' || retryNodeTypes.some((nodeType) => nodeType == kind) ? { enum: ['stop', 'error'] } : false,
         retry: retryNodeTypes.some((nodeType) => nodeType == kind) ? z.toJSONSchema(retryConfigurationSchema) : false,
         inputSources: ['poll', 'integration'].includes(kind)
           ? ['value', 'unset', 'default']
@@ -309,8 +309,8 @@ export function authoringSchema(kind?: AuthoringType) {
                       ? 'Configure static parameters with node.add.inputs or input.set. Definitions come from the selected Trigger key; execution output and variable sources are unavailable.'
                       : kind == 'llm'
                         ? 'Configure model settings, message templates and history as defaults. Input bindings with the same names override these defaults; named business inputs can be bound directly. Template strings interpolate {{name}}.'
-                        : kind == 'dedupe'
-                          ? 'Bind an items array. Configure field (dot-separated identity path, empty for scalar items), mode (new or increasing), and space (node or flow). Outputs are items and duplicates. History persists immediately; downstream failures do not roll it back. Increasing mode accepts finite numbers or RFC 3339 timestamps, never mixed types.'
+                        : kind == 'skip-duplicates'
+                          ? 'Bind an items array. Configure fields as dot-separated identity paths; an empty list uses each scalar item. Outputs are items and duplicates. History belongs to this node and commits only when the Run completes successfully. Fields accept strings or finite numbers; missing or complex values reject the batch.'
                           : kind == 'http-request'
                             ? 'Configure method, query/headers modes and names, bodyFormat, authentication, responseFormat and statusPolicy. Bind url, query.<name>/header.<name> or whole query/headers objects, body and auth.token (Basic: auth.username/auth.password). Credentials accept variables or upstream outputs only. Outputs: body, statusCode, headers. Authentication is replaced as a complete choice.'
                             : kind == 'openapi'
@@ -335,7 +335,7 @@ export function authoringSchema(kind?: AuthoringType) {
               'connector': { config: { action: '<Action ID>', connectionId: '<Connection ID>' } },
               'poll': { config: { key: '<Trigger key>', schedule: [{ type: 'every', unit: 'minute', value: 5 }] } },
               'integration': { config: { key: '<Trigger key>' } },
-              'dedupe': { config: { field: 'id', mode: 'new', space: 'node' }, inputs: { items: { kind: 'value', value: [{ id: 'a' }, { id: 'b' }] } } },
+              'skip-duplicates': { config: { fields: ['id'] }, inputs: { items: { kind: 'value', value: [{ id: 'a' }, { id: 'b' }] } } },
               'http-request': { config: {}, inputs: { url: { kind: 'value', value: 'https://example.com' } } },
               'openapi': { config: { sourceUrl: 'https://example.com/openapi.json', path: '/items', method: 'get' } },
               'code': { code: 'export default ({value}) => ({result:value})', inputs: { value: { kind: 'value', value: 'Hello' } } },

package/src/control/common/requests.ts

@@ -34,7 +34,13 @@ const schemas = {
   updateEventSource: updateEventSourceSchema,
   eventSourceRevision: eventSourceRevisionSchema,
   importFlow: z.strictObject({ file: json, name: flowName.optional(), teamId: id.optional(), tagIds: tagIds.optional(), version }),
-  createFlow: z.strictObject({ name: flowName, teamId: id.optional(), tagIds: tagIds.optional(), version }),
+  createFlow: z.strictObject({
+    name: flowName,
+    teamId: id.optional(),
+    tagIds: tagIds.optional(),
+    presentation: z.record(z.string(), json).optional(),
+    version,
+  }),
   saveTag: z.strictObject({ name: tagName, version }),
   setFlowTags: z.strictObject({ tagIds, version }),
   updateFlow: z.union([z.strictObject({ name: flowName, tagIds: tagIds.optional(), version }), z.strictObject({ name: flowName.optional(), tagIds, version })]),

package/src/execution/common/events.ts

@@ -23,7 +23,7 @@ const nodeKinds = new Set([
   'javascript',
   'openapi',
   'http-request',
-  'dedupe',
+  'skip-duplicates',
   'llm',
   'value',
   'wait',
@@ -57,7 +57,7 @@ function nodeKind(
   | 'javascript'
   | 'openapi'
   | 'http-request'
-  | 'dedupe'
+  | 'skip-duplicates'
   | 'llm'
   | 'value'
   | 'wait'
@@ -78,7 +78,7 @@ function nodeKind(
     | 'javascript'
     | 'openapi'
     | 'http-request'
-    | 'dedupe'
+    | 'skip-duplicates'
     | 'llm'
     | 'value'
     | 'wait'
@@ -95,6 +95,7 @@ function nodeContext(
   event: Record<string, unknown>,
   flows: ReadonlyMap<string, string>,
   platformRunId: string,
+  identify: typeof opaqueId,
 ): {
   readonly executionId: Promise<string>
   readonly flowId: string
@@ -105,7 +106,7 @@ function nodeContext(
   const flowId = flows.get(rawRunId)
   if (flowId == null) throw new TypeError('Runtime node event preceded its run.started event.')
   return {
-    executionId: projectExecutionId(platformRunId, rawRunId, string(event.jobId, 'Runtime node event jobId')),
+    executionId: identify('execution', platformRunId, rawRunId, string(event.jobId, 'Runtime node event jobId')),
     flowId,
     nodeId: string(event.nodeId, 'Runtime node event nodeId'),
     rawRunId,
@@ -184,6 +185,17 @@ export function createEventProjector(platformRunId: string, nodeFailureCodes: Re
   const jobs = new Map<string, string>()
   const nodeProgressBuckets = new Map<string, number>()
   const runProgressBuckets = new Map<string, number>()
+  // Every event of a scope or execution repeats its identity, so each digest is computed once per projector.
+  const identities = new Map<string, Promise<string>>()
+  const identify: typeof opaqueId = (prefix, ...parts) => {
+    const key = JSON.stringify([prefix, ...parts])
+    let identity = identities.get(key)
+    if (identity == null) {
+      identity = opaqueId(prefix, ...parts)
+      identities.set(key, identity)
+    }
+    return identity
+  }
   return async (value) => {
     const event = object(value, 'Runtime event')
     const type = string(event.type, 'Runtime event type')
@@ -205,8 +217,8 @@ export function createEventProjector(platformRunId: string, nodeFailureCodes: Re
         kind: 'run.started',
         payload: {
           flowId,
-          ...(parentRunId === undefined ? {} : { parentScopeId: await opaqueId('scope', platformRunId, parentRunId) }),
-          scopeId: await opaqueId('scope', platformRunId, rawRunId),
+          ...(parentRunId === undefined ? {} : { parentScopeId: await identify('scope', platformRunId, parentRunId) }),
+          scopeId: await identify('scope', platformRunId, rawRunId),
         },
       }
     }
@@ -226,7 +238,7 @@ export function createEventProjector(platformRunId: string, nodeFailureCodes: Re
         payload: {
           flowId,
           progress: event.progress,
-          scopeId: await opaqueId('scope', platformRunId, rawRunId),
+          scopeId: await identify('scope', platformRunId, rawRunId),
         },
       }
     }
@@ -235,7 +247,7 @@ export function createEventProjector(platformRunId: string, nodeFailureCodes: Re
       const rawRunId = runId(event)
       if (type == 'run.failed' && rawRunId == platformRunId && event.failure != null) {
         const failure = object(event.failure, 'Runtime terminal failure')
-        const context = nodeContext(failure, flows, platformRunId)
+        const context = nodeContext(failure, flows, platformRunId, identify)
         return {
           kind: 'node.failed',
           payload: {
@@ -258,13 +270,13 @@ export function createEventProjector(platformRunId: string, nodeFailureCodes: Re
       type == 'node.completed' ||
       type == 'node.failed'
     ) {
-      const context = nodeContext(event, flows, platformRunId)
+      const context = nodeContext(event, flows, platformRunId, identify)
       const executionId = await context.executionId
       const payload = {
         executionId,
         flowId: context.flowId,
         nodeId: context.nodeId,
-        scopeId: await opaqueId('scope', platformRunId, context.rawRunId),
+        scopeId: await identify('scope', platformRunId, context.rawRunId),
         ...(event.systemOutputs === undefined ? {} : { systemOutputs: object(event.systemOutputs, 'Runtime system outputs') }),
         ...(event.handled === true ? { handled: true } : {}),
       }

package/src/execution/common/node-execution.ts

@@ -109,7 +109,7 @@ function nodeKind(
   | 'javascript'
   | 'openapi'
   | 'http-request'
-  | 'dedupe'
+  | 'skip-duplicates'
   | 'llm'
   | 'value'
   | 'wait'

package/src/execution/common/scheduler.ts

@@ -13,6 +13,7 @@ import * as Effect from 'effect/Effect'
 import * as FiberSet from 'effect/FiberSet'
 import * as Queue from 'effect/Queue'
 import { nanoid } from 'nanoid'
+import { z } from 'zod'
 import { isTriggerNode } from '../../flow/common/change.ts'
 import { nodeInputMappings } from '../../flow/common/condition.ts'
 import { nodeSystemOutputPorts, supportsNodeErrorHandling } from '../../flow/common/errorHandling.ts'
@@ -70,7 +71,7 @@ export type SchedulerEvent =
         | 'javascript'
         | 'openapi'
         | 'http-request'
-        | 'dedupe'
+        | 'skip-duplicates'
         | 'llm'
         | 'value'
         | 'wait'
@@ -217,7 +218,7 @@ export type RunLaunch =
       readonly resume?: never
     }
   | {
-      readonly resume: { readonly checkpoint: unknown }
+      readonly resume: { readonly checkpoint: unknown; readonly readyWorkflowRunIds?: readonly string[] }
       readonly bindingValues?: never
       readonly inputs?: never
       readonly trigger?: never
@@ -250,7 +251,7 @@ function runGraph(
   runId: string,
   launchInputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>> = {},
   trigger?: TriggerSeed,
-  resume?: { readonly checkpoint: FlowRunCheckpoint },
+  resume?: { readonly checkpoint: FlowRunCheckpoint; readonly readyWorkflowRunIds?: ReadonlySet<string> },
 ): Effect.Effect<FlowRunOutcome, Error> {
   return Effect.scoped(
     Effect.gen(function* () {
@@ -292,6 +293,8 @@ function runGraph(
       const changes = yield* Queue.unbounded<void>()
       let remainingMs = context.remainingMs
       let measuredAt = yield* Clock.currentTimeMillis
+      let nextCallCheckAt = measuredAt + (resume == null ? 1000 : 0)
+      let readyWorkflowRunIds = resume?.readyWorkflowRunIds
       let idleSince: number | undefined
       const agents: Record<string, FlowRunCheckpoint['agents'][string]> = { ...resume?.checkpoint.agents }
       const resolveInputs = (nodeId: string, node: ExecutableNode) => resolveNodeInputs(nodeId, node, dependencies, context.bindingValues, launch[nodeId])
@@ -546,15 +549,20 @@ function runGraph(
             ),
             now,
           )
-        for (const call of pendingCalls.values()) {
-          yield* observe(
-            call.nodeId,
-            call.jobId,
-            Effect.gen(function* () {
-              const result = yield* execute(call.nodeId, target.graph.nodes[call.nodeId] as ExecutableNode, call.jobId, call.input)
-              yield* settleNode(call.nodeId, call.jobId, result)
-            }),
-          ).pipe(Effect.catch(() => Effect.void))
+        if (pendingCalls.size > 0 && now >= nextCallCheckAt) {
+          for (const call of pendingCalls.values()) {
+            if (readyWorkflowRunIds != null && !readyWorkflowRunIds.has(call.childRunId)) continue
+            yield* observe(
+              call.nodeId,
+              call.jobId,
+              Effect.gen(function* () {
+                const result = yield* execute(call.nodeId, target.graph.nodes[call.nodeId] as ExecutableNode, call.jobId, call.input)
+                yield* settleNode(call.nodeId, call.jobId, result)
+              }),
+            ).pipe(Effect.catch(() => Effect.void))
+          }
+          readyWorkflowRunIds = undefined
+          nextCallCheckAt = (yield* Clock.currentTimeMillis) + 1000
         }
         const ready = dependencies.ready()
         for (const nodeId of ready) executeReady(nodeId)
@@ -592,7 +600,8 @@ function runGraph(
                 true,
               )
         let next = Effect.raceFirst(activity, decision)
-        if (pendingCalls.size > 0) next = Effect.raceFirst(next, Effect.sleep(1000).pipe(Effect.as({})))
+        if (pendingCalls.size > 0)
+          next = Effect.raceFirst(next, Effect.sleep(Math.max(0, nextCallCheckAt - (yield* Clock.currentTimeMillis))).pipe(Effect.as({})))
         if (left != null) next = Effect.raceFirst(next, Effect.sleep(Math.max(0, left)).pipe(Effect.as({})))
         const resolutions = yield* next
         applyResolutions(resolutions, yield* Clock.currentTimeMillis)
@@ -631,6 +640,11 @@ export function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect
       return yield* Effect.fail(new Error('A resumed Flow Run cannot accept launch inputs, binding values, or a Trigger seed.'))
     }
     const decoded = options.resume == null ? undefined : decodeFlowRunCheckpoint(options.resume.checkpoint)
+    const readyWorkflowRunIds =
+      options.resume?.readyWorkflowRunIds === undefined ? undefined : new Set(z.array(z.string().min(1)).parse(options.resume.readyWorkflowRunIds))
+    if (readyWorkflowRunIds != null && [...readyWorkflowRunIds].some((id) => !decoded?.calls?.some((call) => call.childRunId == id))) {
+      return yield* Effect.fail(new Error('Ready workflow Run is not present in the checkpoint.'))
+    }
     const outputs = (nodeId: string, value: Readonly<Record<string, JsonValue>>) =>
       isResolutionNode(prepared.graph.nodes[nodeId]) && value.pending != null ? { ...value, pending: withWaitNotificationMessage(value.pending) } : value
     const checkpoint =
@@ -692,7 +706,7 @@ export function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect
       options.runId,
       options.inputs,
       trigger,
-      checkpoint == null ? undefined : { checkpoint },
+      checkpoint == null ? undefined : { checkpoint, readyWorkflowRunIds },
     )
   })
   return program

package/src/flow/common/change.ts

@@ -167,7 +167,7 @@ export interface ConditionNode extends GraphNodeBase {
 
 export type ManagedTaskExecutor =
   | import('../../http/common/httpRequest.ts').HttpRequestExecutor
-  | import('../../state/common/state.ts').DedupeExecutor
+  | import('../../state/common/state.ts').SkipDuplicatesExecutor
   | WorkflowExecutor
   | import('../../decision/common/decision.ts').DecisionExecutor
   | import('../../openapi/common/openapi.ts').OpenApiExecutor