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

package/src/control/common/errors.ts

@@ -42,6 +42,9 @@ export const controlErrorCode = {
   triggerKeyInvalid: 'trigger-key.invalid',
   triggerKeyNotFound: 'trigger-key.not-found',
   triggerNotFound: 'trigger.not-found',
+  tagInvalid: 'tag.invalid',
+  tagConflict: 'tag.conflict',
+  tagNotFound: 'tag.not-found',
   variableInvalid: 'variable.invalid',
   variableLimitReached: 'variable.limit-reached',
   variableNotFound: 'variable.not-found',
@@ -93,6 +96,9 @@ export const controlErrorMetadata = {
   [controlErrorCode.triggerKeyInvalid]: { status: 409 },
   [controlErrorCode.triggerKeyNotFound]: { status: 404 },
   [controlErrorCode.triggerNotFound]: { status: 404 },
+  [controlErrorCode.tagInvalid]: { status: 400 },
+  [controlErrorCode.tagConflict]: { status: 409 },
+  [controlErrorCode.tagNotFound]: { status: 404 },
   [controlErrorCode.variableInvalid]: { status: 400 },
   [controlErrorCode.variableLimitReached]: { status: 409 },
   [controlErrorCode.variableNotFound]: { status: 404 },

package/src/control/common/flowDecoders.ts

@@ -60,6 +60,7 @@ export function flow(value: unknown): Flow {
             revisionId: string(target.revisionId),
           },
         }),
+    tagIds: source.tagIds === undefined ? [] : strings(source.tagIds),
     createdAt: string(source.createdAt),
     ...(source.connectorTeamId == null ? {} : { connectorTeamId: string(source.connectorTeamId) }),
     draftRevisionId: string(source.draftRevisionId),

package/src/control/common/mcp.ts

@@ -5,6 +5,7 @@ import { canvasCommandSchema } from '../../canvas/common/commands.ts'
 import { runStatuses } from '../../execution/common/runLifecycle.ts'
 import { waitCommentSchema } from '../../execution/common/wait.ts'
 import { resourceNameIssue } from '../../flow/common/change.ts'
+import { stateQuerySchema, stateClearSchema, dedupeClearSchema } from '../../state/common/state.ts'
 import { authoringReadSchema, authoringSearchSchema, authoringRequestSchema, authoringSchemaQuery } from './authoringSchema.ts'
 import { resultQuerySchema } from './resultQuery.ts'
 
@@ -50,6 +51,21 @@ function tool<Args>(description: string, schema: z.ZodType<Args>, readOnly: bool
 }
 
 export const mcpTools = {
+  flow_state: tool(
+    'Inspect Flow state usage, business keys and deduplication spaces. Values are omitted unless requested. Scope is required.',
+    stateQuerySchema.extend({ flowId: flow }),
+    true,
+  ),
+  flow_state_clear: tool(
+    'Delete one business state key or clear all business values. Explicit draft/live scope is required; live changes production state immediately.',
+    stateClearSchema.extend({ flowId: flow }),
+    false,
+  ),
+  flow_dedupe_clear: tool(
+    'Clear one deduplication space (flow or node:<id>). Explicit draft/live scope is required; live changes production history immediately.',
+    dedupeClearSchema.extend({ flowId: flow }),
+    false,
+  ),
   flow_canvas: tool(
     'Broadcast a transient canvas command to connected Workbenches viewing this Flow. Success only confirms Server broadcast, not delivery or execution. No replay, session selection or Presentation save. Pan uses screen pixels (positive right/down); zoom is an absolute ratio (0.1–3); fit includes all nodes. Repeating pan moves again.',
     z.strictObject({ flowId: flow, command: canvasCommandSchema }),

package/src/control/common/requests.ts

@@ -18,6 +18,8 @@ const json: z.ZodType<JsonValue> = z.json()
 const id = z.string().min(1)
 const version = z.literal(1)
 const flowName = id.refine((value) => value == value.trim() && resourceNameIssue(value) == null, 'Flow name is invalid.')
+const tagIds = z.array(id).transform((ids) => [...new Set(ids)].toSorted())
+const tagName = id.transform((name) => name.trim()).refine((name) => resourceNameIssue(name) == null, 'Tag name is invalid.')
 const inputs = z.record(z.string(), z.record(z.string(), json))
 const trigger = z.strictObject({ nodeId: id, outputs: z.record(z.string(), json) })
 const schemas = {
@@ -31,8 +33,17 @@ const schemas = {
   createEventSource: createEventSourceSchema,
   updateEventSource: updateEventSourceSchema,
   eventSourceRevision: eventSourceRevisionSchema,
-  importFlow: z.strictObject({ file: json, name: flowName.optional(), teamId: id.optional(), version }),
-  createFlow: z.strictObject({ name: flowName, teamId: id.optional(), version }),
+  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(),
+    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 })]),
   renameFlow: z.strictObject({ name: flowName, version }),
   changeDraft: z.strictObject({ expectedRevisionId: id, operations: z.array(json).min(1), version }),
   repairDraft: z.strictObject({ expectedRevisionId: id, version }),
@@ -79,6 +90,9 @@ export const controlRequests = {
   eventSourceRevision: decoder(schemas.eventSourceRevision),
   importFlow: decoder(schemas.importFlow),
   createFlow: decoder(schemas.createFlow),
+  saveTag: decoder(schemas.saveTag),
+  setFlowTags: decoder(schemas.setFlowTags),
+  updateFlow: decoder(schemas.updateFlow),
   renameFlow: decoder(schemas.renameFlow),
   changeDraft(value: unknown): { expectedRevisionId: string; operations: readonly DraftOperation[]; version: 1 } {
     const body = schemas.changeDraft.parse(value)

package/src/control/common/tags.ts

@@ -0,0 +1,20 @@
+import type { FlowQuery, Tag, TagListItem } from './api.ts'
+
+import { integer, invalidResponse, record, string } from './decoding.ts'
+
+export function normalizeFlowQuery(query: FlowQuery = {}): Required<FlowQuery> {
+  return { query: query.query?.trim().toLowerCase() ?? '', tagIds: [...new Set(query.tagIds ?? [])].toSorted(), untagged: query.untagged ?? false }
+}
+
+export function decodeTag(value: unknown): Tag {
+  const source = record(value)
+  if (source.version != 1) return invalidResponse()
+  return { tagId: string(source.tagId), name: string(source.name), version: 1 }
+}
+
+export function decodeTagListItem(value: unknown): TagListItem {
+  const source = record(value)
+  const referenceCount = integer(source.referenceCount)
+  if (referenceCount < 0) return invalidResponse()
+  return { ...decodeTag(source), referenceCount }
+}

package/src/execution/common/events.ts

@@ -23,6 +23,7 @@ const nodeKinds = new Set([
   'javascript',
   'openapi',
   'http-request',
+  'skip-duplicates',
   'llm',
   'value',
   'wait',
@@ -56,6 +57,7 @@ function nodeKind(
   | 'javascript'
   | 'openapi'
   | 'http-request'
+  | 'skip-duplicates'
   | 'llm'
   | 'value'
   | 'wait'
@@ -76,6 +78,7 @@ function nodeKind(
     | 'javascript'
     | 'openapi'
     | 'http-request'
+    | 'skip-duplicates'
     | 'llm'
     | 'value'
     | 'wait'
@@ -92,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
@@ -102,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,
@@ -181,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')
@@ -202,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),
         },
       }
     }
@@ -223,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),
         },
       }
     }
@@ -232,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: {
@@ -255,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,6 +109,7 @@ function nodeKind(
   | 'javascript'
   | 'openapi'
   | 'http-request'
+  | 'skip-duplicates'
   | 'llm'
   | 'value'
   | 'wait'
@@ -301,6 +302,7 @@ export function executeNode(
     readonly node: ExecutableNode
     readonly jobId: string
     readonly nodeInputs: Readonly<Record<string, JsonValue>>
+    readonly launchInputs?: Readonly<Record<string, JsonValue>>
     readonly flowId: string
     readonly runId: string
     readonly graph: Graph
@@ -368,6 +370,7 @@ export function executeNode(
               if (additional.has(handle)) return false
               const task = 'executor' in node.task ? node.task : undefined
               if (task == null || !['openapi', 'http-request'].includes(task.executor.kind)) return true
+              if (Object.hasOwn(input.launchInputs ?? {}, handle)) return true
               const mapping = node.inputs[handle]
               return (
                 mapping?.kind != 'unset' &&

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,6 +71,7 @@ export type SchedulerEvent =
         | 'javascript'
         | 'openapi'
         | 'http-request'
+        | 'skip-duplicates'
         | 'llm'
         | 'value'
         | 'wait'
@@ -216,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
@@ -249,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* () {
@@ -291,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])
@@ -344,6 +348,7 @@ function runGraph(
           node,
           jobId,
           nodeInputs,
+          launchInputs: launch[nodeId],
           resolution,
           flowId: target.flowId,
           runId,
@@ -544,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)
@@ -590,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)
@@ -629,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 =
@@ -690,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,6 +167,7 @@ export interface ConditionNode extends GraphNodeBase {
 
 export type ManagedTaskExecutor =
   | import('../../http/common/httpRequest.ts').HttpRequestExecutor
+  | import('../../state/common/state.ts').SkipDuplicatesExecutor
   | WorkflowExecutor
   | import('../../decision/common/decision.ts').DecisionExecutor
   | import('../../openapi/common/openapi.ts').OpenApiExecutor
@@ -397,7 +398,7 @@ export interface FlowDocument {
 
 export interface RevisionContent {
   readonly document: FlowDocument
-  readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | typeof currentFlowModelVersion
+  readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | typeof currentFlowModelVersion
   readonly modules: Readonly<Record<string, CodeModule>>
 }
 

package/src/flow/common/changeSchema.ts

@@ -6,6 +6,7 @@ import { limitDecisionTask } from '../../decision/common/decision.ts'
 import { assertHttpAuthBindings } from '../../http/common/authBindings.ts'
 import { isHttpHost, maxHttpHosts } from '../../http/common/hosts.ts'
 import { httpRequestExecutorSchema } from '../../http/common/httpRequest.ts'
+import { skipDuplicatesExecutorSchema } from '../../state/common/state.ts'
 import { checkJsonDepth } from './json.ts'
 import { retryConfigurationSchema } from './retry.ts'
 import { triggerScheduleSchema } from './triggerScheduleSchema.ts'
@@ -13,7 +14,7 @@ import { waitAutoContinueDraftSchema, waitAutoContinueSchema } from './wait.ts'
 import { webhookMethods } from './webhookMethod.ts'
 import { webhookResponseTimeout } from './webhookResponse.ts'
 
-export const currentFlowModelVersion = 12
+export const currentFlowModelVersion = 13
 const text = z.string()
 const actionConnection = text.describe(
   'Account selection: omit while unconfigured; use an account ID to select it; use "" to explicitly defer configuration. Deferred Actions fail if called; deferred Agent tools are excluded from the callable tool set. Not supported by Triggers.',
@@ -129,6 +130,7 @@ const managedFields = z.object({
     }),
     z.strictObject({ kind: z.literal('workflow'), flowId: text, revisionId: text }),
     httpRequestExecutorSchema,
+    skipDuplicatesExecutorSchema,
   ]),
 })
 
@@ -318,6 +320,7 @@ const revision = z.object({
     z.literal(9),
     z.literal(10),
     z.literal(11),
+    z.literal(12),
     z.literal(currentFlowModelVersion),
   ]),
   document,
@@ -723,6 +726,13 @@ export function changeOperationsSchema(kind?: string): JsonValue {
 }
 
 function checkModelVersion(content: RevisionContent): void {
+  if (
+    content.modelVersion < 13 &&
+    Object.values(content.document.graph.nodes).some(
+      (candidateNode) => candidateNode.kind === 'task' && 'executor' in candidateNode.task && candidateNode.task.executor.kind === 'skip-duplicates',
+    )
+  )
+    throw new Error('Skip Duplicates requires Flow model v13.')
   if (
     content.modelVersion < 12 &&
     Object.values(content.document.graph.nodes).some(

package/src/flow/common/errorHandling.ts

@@ -26,7 +26,7 @@ export const nodeErrorSchema = {
 } as const
 
 export function supportsNodeErrorHandling(node: GraphNode): boolean {
-  return supportsNodeRetry(node)
+  return supportsNodeRetry(node) || (node.kind === 'task' && 'executor' in node.task && node.task.executor.kind === 'skip-duplicates')
 }
 
 export function nodeSystemOutputPorts(node: GraphNode): Readonly<Record<string, PortDefinition>> {

package/src/flow/common/semantics.ts

@@ -2,6 +2,7 @@ import { dequal } from 'dequal/lite'
 import { decisionTaskIssues } from '../../decision/common/decision.ts'
 import { httpRequestIssues, httpAuthHandles, httpRequestTask, httpRequestUrl } from '../../http/common/httpRequest.ts'
 import { openApiIssues, authHandles } from '../../openapi/common/openapi.ts'
+import { skipDuplicatesTask } from '../../state/common/state.ts'
 import { isTriggerNode } from './change.ts'
 import { nodeWorkflowReferences } from './workflowReferences.ts'
 export { renderPrompt } from './promptTemplate.ts'
@@ -273,6 +274,20 @@ export async function validateFlow(revision: RevisionContent, engine: EngineCont
       })
     for (const message of openApiIssues(task))
       checked.diagnostics.push({ code: 'openapi.config-invalid', column: 0, line: 1, message, path: `/document/graph/nodes/${nodeId}/task/executor` })
+    if (task.executor.kind === 'skip-duplicates') {
+      const expected = skipDuplicatesTask(task.executor)
+      if (
+        !dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) ||
+        !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))
+      )
+        checked.diagnostics.push({
+          code: 'skip-duplicates.ports-invalid',
+          column: 0,
+          line: 1,
+          message: 'Deduplication ports must match the fixed contract.',
+          path: `/document/graph/nodes/${nodeId}/task`,
+        })
+    }
     if (task.executor.kind == 'http-request') {
       for (const issue of httpRequestIssues(task.executor))
         checked.diagnostics.push({
@@ -440,6 +455,13 @@ const httpPortContracts = (ports: import('./change.ts').ManagedTaskDefinition['i
 export async function prepareFlow(revision: RevisionContent, engineContract: string, triggerId?: string): Promise<PrepareFlowResult> {
   const engine = findEngineContract(engineContract)
   if (engine == null) return { kind: 'engine-unsupported' }
+  if (
+    !engine.flowState &&
+    Object.values(revision.document.graph.nodes).some(
+      (node) => node.kind === 'task' && 'executor' in node.task && node.task.executor.kind === 'skip-duplicates',
+    )
+  )
+    return { kind: 'engine-unsupported' }
   if (
     !engine.httpRequests &&
     Object.values(revision.document.graph.nodes).some((node) => node.kind == 'task' && 'executor' in node.task && node.task.executor.kind == 'http-request')
@@ -507,11 +529,15 @@ export async function prepareFlow(revision: RevisionContent, engineContract: str
 
 export function createRuntimeProgram(prepared: PreparedFlow, entryModuleId: string, engineDigest: string): RuntimeProgram | undefined {
   if (!Object.hasOwn(prepared.modules, entryModuleId)) return
+  const modules = new Set([entryModuleId])
+  for (const id of modules) {
+    for (const imported of prepared.modules[id]!.imports) modules.add(imported)
+  }
   return {
     engineContract: prepared.engineContract,
     engineDigest,
     entryModuleId,
-    modules: prepared.modules,
+    modules: Object.fromEntries([...modules].map((id) => [id, prepared.modules[id]!])),
   }
 }
 

package/src/runtime/common/engineContract.ts

@@ -9,10 +9,11 @@ export interface EngineContract {
   readonly httpRequests?: boolean
   /** Code may call `context.fetch` for hosts declared by its `http` Capability. */
   readonly codeFetch?: boolean
+  readonly flowState?: boolean
 }
 
-/** v9 is a single contract: the Node compatibility builtins, `context.fetch`, and no `context.egress`. */
-export const currentEngineContract = 'open-flow-engine/v9'
+/** v10 adds persistent Flow State to the published v9 Node compatibility and fetch contract. */
+export const currentEngineContract = 'open-flow-engine/v10'
 /** The published v8 Node compatibility contract, retained for existing Publications and Runs. */
 export const nodejsEngineContract = 'open-flow-engine/v8/nodejs-compat-v1'
 
@@ -63,10 +64,12 @@ const nodejsContract: EngineContract = {
   platformSource: platformSource(nodejsEngineContract),
 }
 
-const currentContract: EngineContract = { ...nodejsContract, codeFetch: true, platformSource: platformSource(currentEngineContract) }
+const v9Contract: EngineContract = { ...nodejsContract, codeFetch: true, platformSource: platformSource('open-flow-engine/v9') }
+const currentContract: EngineContract = { ...v9Contract, flowState: true, platformSource: platformSource(currentEngineContract) }
 
 export function findEngineContract(contract: string): EngineContract | undefined {
   if (contract == currentEngineContract) return currentContract
+  if (contract == 'open-flow-engine/v9') return v9Contract
   if (contract == 'open-flow-engine/v8') return v8Contract
   if (contract == nodejsEngineContract) return nodejsContract
   if (contract == 'open-flow-engine/v7' || contract == 'open-flow-engine/v7/nodejs-compat-v1')