@contractspec/integration.workflow-devkit 0.1.1

package/README.md

@@ -0,0 +1,66 @@
+# @contractspec/integration.workflow-devkit
+
+Workflow DevKit compiler and runtime bridges for ContractSpec `WorkflowSpec`.
+
+## What it provides
+
+- Compile a `WorkflowSpec` into a deterministic Workflow DevKit manifest.
+- Generate Workflow, Next.js, and generic-host scaffolding.
+- Run a `WorkflowSpec` through injected Workflow DevKit primitives such as `sleep`, hooks, and webhooks.
+- Create a Workflow-backed `AgentRuntimeAdapterBundle` for `@contractspec/lib.ai-agent`.
+- Expose chat route helpers and re-export `WorkflowChatTransport` for reconnectable chat UIs.
+
+## Entry points
+
+- `@contractspec/integration.workflow-devkit`
+- `@contractspec/integration.workflow-devkit/compiler`
+- `@contractspec/integration.workflow-devkit/runtime`
+- `@contractspec/integration.workflow-devkit/chat-routes`
+- `@contractspec/integration.workflow-devkit/agent-adapter`
+- `@contractspec/integration.workflow-devkit/next`
+
+## Next.js example
+
+```ts
+import { withContractSpecWorkflow } from "@contractspec/integration.workflow-devkit/next";
+import { createWorkflowChatRoutes } from "@contractspec/module.ai-chat/core/workflow";
+
+export default withContractSpecWorkflow({
+  experimental: {},
+});
+
+const routes = createWorkflowChatRoutes({
+  workflow: async (payload) => payload,
+  getFollowUpToken({ runId }) {
+    return `chat:${runId}`;
+  },
+});
+
+export const POST = routes.start;
+```
+
+## Generic host example
+
+```ts
+import { createHook, createWebhook, sleep } from "workflow";
+import {
+  runWorkflowSpecWithWorkflowDevkit,
+  type WorkflowDevkitRuntimeBridge,
+} from "@contractspec/integration.workflow-devkit";
+import { onboardingWorkflow } from "./onboarding.workflow";
+
+export async function runOnboarding(input: Record<string, unknown>, bridge: WorkflowDevkitRuntimeBridge) {
+  "use workflow";
+
+  return runWorkflowSpecWithWorkflowDevkit({
+    spec: onboardingWorkflow,
+    initialData: input,
+    bridge,
+    primitives: {
+      sleep,
+      createHook,
+      createWebhook,
+    },
+  });
+}
+```

package/dist/agent-adapter.d.ts

@@ -0,0 +1,35 @@
+import type { AgentCheckpointEnvelope, AgentRuntimeAdapterBundle } from '@contractspec/lib.ai-agent/interop';
+import type { AgentSessionState } from '@contractspec/lib.ai-agent/types';
+import type { WorkflowApiLike } from './types';
+export interface WorkflowDevkitSuspensionState {
+    input?: string;
+    metadata?: Record<string, string>;
+    reason: string;
+    resumedAt?: Date;
+    suspendedAt: Date;
+}
+export interface WorkflowDevkitSuspensionStore {
+    clear(sessionId: string): Promise<void>;
+    get(sessionId: string): Promise<WorkflowDevkitSuspensionState | null>;
+    set(sessionId: string, state: WorkflowDevkitSuspensionState): Promise<void>;
+}
+export interface CreateWorkflowDevkitAgentRuntimeAdapterOptions {
+    checkpointStore?: InMemoryWorkflowDevkitCheckpointStore;
+    resolveSessionToken?: (sessionId: string) => string;
+    suspensionStore?: WorkflowDevkitSuspensionStore;
+    workflowApi?: Pick<WorkflowApiLike, 'resumeHook'>;
+}
+export declare class InMemoryWorkflowDevkitCheckpointStore {
+    private readonly envelopes;
+    delete(sessionId: string): Promise<void>;
+    load(sessionId: string): Promise<AgentCheckpointEnvelope | null>;
+    save(envelope: AgentCheckpointEnvelope): Promise<void>;
+}
+export declare class InMemoryWorkflowDevkitSuspensionStore implements WorkflowDevkitSuspensionStore {
+    private readonly states;
+    clear(sessionId: string): Promise<void>;
+    get(sessionId: string): Promise<WorkflowDevkitSuspensionState | null>;
+    set(sessionId: string, state: WorkflowDevkitSuspensionState): Promise<void>;
+}
+export declare function createWorkflowDevkitAgentRuntimeAdapterBundle(options?: CreateWorkflowDevkitAgentRuntimeAdapterOptions): AgentRuntimeAdapterBundle<AgentSessionState>;
+export declare function defaultWorkflowDevkitAgentToken(sessionId: string): string;

package/dist/agent-adapter.js

@@ -0,0 +1,80 @@
+// @bun
+// src/agent-adapter.ts
+class InMemoryWorkflowDevkitCheckpointStore {
+  envelopes = new Map;
+  async delete(sessionId) {
+    this.envelopes.delete(sessionId);
+  }
+  async load(sessionId) {
+    return this.envelopes.get(sessionId) ?? null;
+  }
+  async save(envelope) {
+    this.envelopes.set(envelope.sessionId, envelope);
+  }
+}
+
+class InMemoryWorkflowDevkitSuspensionStore {
+  states = new Map;
+  async clear(sessionId) {
+    this.states.delete(sessionId);
+  }
+  async get(sessionId) {
+    return this.states.get(sessionId) ?? null;
+  }
+  async set(sessionId, state) {
+    this.states.set(sessionId, state);
+  }
+}
+function createWorkflowDevkitAgentRuntimeAdapterBundle(options = {}) {
+  const checkpointStore = options.checkpointStore ?? new InMemoryWorkflowDevkitCheckpointStore;
+  const suspensionStore = options.suspensionStore ?? new InMemoryWorkflowDevkitSuspensionStore;
+  const resolveSessionToken = options.resolveSessionToken ?? defaultWorkflowDevkitAgentToken;
+  return {
+    key: "workflow-devkit",
+    checkpoint: {
+      delete(sessionId) {
+        return checkpointStore.delete(sessionId);
+      },
+      load(sessionId) {
+        return checkpointStore.load(sessionId);
+      },
+      save(envelope) {
+        return checkpointStore.save(envelope);
+      }
+    },
+    suspendResume: {
+      async resume(params) {
+        await suspensionStore.set(params.sessionId, {
+          input: params.input,
+          metadata: params.metadata,
+          reason: "resumed",
+          resumedAt: new Date,
+          suspendedAt: new Date
+        });
+        if (options.workflowApi) {
+          await options.workflowApi.resumeHook(resolveSessionToken(params.sessionId), {
+            input: params.input,
+            metadata: params.metadata,
+            sessionId: params.sessionId
+          });
+        }
+      },
+      async suspend(params) {
+        await suspensionStore.set(params.sessionId, {
+          metadata: params.metadata,
+          reason: params.reason,
+          suspendedAt: new Date
+        });
+      }
+    }
+  };
+}
+function defaultWorkflowDevkitAgentToken(sessionId) {
+  return `agent-session:${sessionId}`;
+}
+export {
+  defaultWorkflowDevkitAgentToken,
+  createWorkflowDevkitAgentRuntimeAdapterBundle,
+  InMemoryWorkflowDevkitSuspensionStore,
+  InMemoryWorkflowDevkitCheckpointStore
+};

package/dist/agent-adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/browser/agent-adapter.js

@@ -0,0 +1,79 @@
+// src/agent-adapter.ts
+class InMemoryWorkflowDevkitCheckpointStore {
+  envelopes = new Map;
+  async delete(sessionId) {
+    this.envelopes.delete(sessionId);
+  }
+  async load(sessionId) {
+    return this.envelopes.get(sessionId) ?? null;
+  }
+  async save(envelope) {
+    this.envelopes.set(envelope.sessionId, envelope);
+  }
+}
+
+class InMemoryWorkflowDevkitSuspensionStore {
+  states = new Map;
+  async clear(sessionId) {
+    this.states.delete(sessionId);
+  }
+  async get(sessionId) {
+    return this.states.get(sessionId) ?? null;
+  }
+  async set(sessionId, state) {
+    this.states.set(sessionId, state);
+  }
+}
+function createWorkflowDevkitAgentRuntimeAdapterBundle(options = {}) {
+  const checkpointStore = options.checkpointStore ?? new InMemoryWorkflowDevkitCheckpointStore;
+  const suspensionStore = options.suspensionStore ?? new InMemoryWorkflowDevkitSuspensionStore;
+  const resolveSessionToken = options.resolveSessionToken ?? defaultWorkflowDevkitAgentToken;
+  return {
+    key: "workflow-devkit",
+    checkpoint: {
+      delete(sessionId) {
+        return checkpointStore.delete(sessionId);
+      },
+      load(sessionId) {
+        return checkpointStore.load(sessionId);
+      },
+      save(envelope) {
+        return checkpointStore.save(envelope);
+      }
+    },
+    suspendResume: {
+      async resume(params) {
+        await suspensionStore.set(params.sessionId, {
+          input: params.input,
+          metadata: params.metadata,
+          reason: "resumed",
+          resumedAt: new Date,
+          suspendedAt: new Date
+        });
+        if (options.workflowApi) {
+          await options.workflowApi.resumeHook(resolveSessionToken(params.sessionId), {
+            input: params.input,
+            metadata: params.metadata,
+            sessionId: params.sessionId
+          });
+        }
+      },
+      async suspend(params) {
+        await suspensionStore.set(params.sessionId, {
+          metadata: params.metadata,
+          reason: params.reason,
+          suspendedAt: new Date
+        });
+      }
+    }
+  };
+}
+function defaultWorkflowDevkitAgentToken(sessionId) {
+  return `agent-session:${sessionId}`;
+}
+export {
+  defaultWorkflowDevkitAgentToken,
+  createWorkflowDevkitAgentRuntimeAdapterBundle,
+  InMemoryWorkflowDevkitSuspensionStore,
+  InMemoryWorkflowDevkitCheckpointStore
+};

package/dist/browser/chat-routes.js

@@ -0,0 +1,100 @@
+// src/chat-routes.ts
+import { createUIMessageStreamResponse } from "ai";
+import { getRun, resumeHook, start } from "workflow/api";
+var WORKFLOW_RUN_ID_HEADER = "x-workflow-run-id";
+var WORKFLOW_STREAM_TAIL_INDEX_HEADER = "x-workflow-stream-tail-index";
+function createWorkflowDevkitStartRoute(options) {
+  const workflowApi = options.workflowApi ?? { start };
+  return async (request) => {
+    const body = await request.json();
+    const args = await options.buildArgs(body, request);
+    const run = await workflowApi.start(options.workflow, args);
+    if (options.createResponse) {
+      return options.createResponse({ body, run });
+    }
+    if (!run.readable) {
+      return new Response(JSON.stringify({ runId: run.runId }), {
+        headers: {
+          "Content-Type": "application/json",
+          [WORKFLOW_RUN_ID_HEADER]: run.runId
+        }
+      });
+    }
+    return createUIMessageStreamResponse({
+      headers: {
+        [WORKFLOW_RUN_ID_HEADER]: run.runId
+      },
+      stream: run.readable
+    });
+  };
+}
+function createWorkflowDevkitFollowUpRoute(options) {
+  const workflowApi = options.workflowApi ?? { resumeHook };
+  return async (request, context) => {
+    const runId = context.params.runId ?? context.params.id;
+    if (!runId) {
+      return new Response(JSON.stringify({ error: "Missing run id" }), {
+        status: 400
+      });
+    }
+    const body = await request.json();
+    const token = options.resolveToken({ body, request, runId });
+    const payload = options.buildPayload ? await options.buildPayload(body, request) : body;
+    await workflowApi.resumeHook(token, payload);
+    return new Response(JSON.stringify({ ok: true }), {
+      headers: {
+        "Content-Type": "application/json",
+        [WORKFLOW_RUN_ID_HEADER]: runId
+      }
+    });
+  };
+}
+function createWorkflowDevkitStreamRoute(options = {}) {
+  const workflowApi = options.workflowApi ?? { getRun };
+  return async (request, context) => {
+    const runId = context.params.runId ?? context.params.id;
+    if (!runId) {
+      return new Response(JSON.stringify({ error: "Missing run id" }), {
+        status: 400
+      });
+    }
+    const run = workflowApi.getRun(runId);
+    if (!run) {
+      return new Response(JSON.stringify({ error: "Workflow run not found" }), {
+        status: 404
+      });
+    }
+    const startIndex = readStartIndex(request.url);
+    const readable = run.getReadable ? run.getReadable({ startIndex }) : run.readable;
+    if (!readable) {
+      return new Response(JSON.stringify({ error: "Run has no readable stream" }), {
+        status: 404
+      });
+    }
+    const tailIndex = await readable.getTailIndex?.();
+    return createUIMessageStreamResponse({
+      headers: {
+        ...tailIndex !== undefined ? {
+          [WORKFLOW_STREAM_TAIL_INDEX_HEADER]: String(tailIndex)
+        } : {}
+      },
+      stream: readable
+    });
+  };
+}
+function readStartIndex(url) {
+  const parsed = new URL(url);
+  const rawStartIndex = parsed.searchParams.get("startIndex");
+  if (!rawStartIndex) {
+    return;
+  }
+  const parsedStartIndex = Number(rawStartIndex);
+  return Number.isFinite(parsedStartIndex) ? parsedStartIndex : undefined;
+}
+export {
+  createWorkflowDevkitStreamRoute,
+  createWorkflowDevkitStartRoute,
+  createWorkflowDevkitFollowUpRoute,
+  WORKFLOW_STREAM_TAIL_INDEX_HEADER,
+  WORKFLOW_RUN_ID_HEADER
+};

package/dist/browser/compiler.js

@@ -0,0 +1,177 @@
+// src/helpers.ts
+import { evaluateExpression } from "@contractspec/lib.contracts-spec/workflow";
+function inferWorkflowDevkitBehavior(step) {
+  return step.runtime?.workflowDevkit?.behavior ?? step.type;
+}
+function resolveWorkflowDevkitEntryStepId(spec) {
+  const entryStepId = spec.definition.entryStepId ?? spec.definition.steps[0]?.id;
+  if (!entryStepId) {
+    throw new Error(`Workflow ${spec.meta.key}.v${spec.meta.version} does not define an entry step.`);
+  }
+  return entryStepId;
+}
+function resolveWorkflowDevkitRunIdentity(spec, runIdentity) {
+  if (runIdentity) {
+    return runIdentity;
+  }
+  const strategy = spec.runtime?.workflowDevkit?.runIdentity?.strategy ?? "meta-key-version";
+  const prefix = spec.runtime?.workflowDevkit?.runIdentity?.prefix;
+  const baseIdentity = strategy === "meta-key-version" ? `${spec.meta.key}.v${spec.meta.version}` : `${spec.meta.key}.v${spec.meta.version}`;
+  return prefix ? `${prefix}:${baseIdentity}` : baseIdentity;
+}
+function resolveWorkflowDevkitWaitToken(spec, step, runIdentity) {
+  const runtime = step.runtime?.workflowDevkit;
+  if (!runtime) {
+    return;
+  }
+  const explicitToken = runtime.hookWait?.token ?? runtime.webhookWait?.token ?? runtime.approvalWait?.token ?? runtime.streamSession?.followUpToken;
+  if (explicitToken) {
+    return explicitToken;
+  }
+  const tokenStrategy = spec.runtime?.workflowDevkit?.hookTokens?.strategy ?? "deterministic";
+  const prefix = spec.runtime?.workflowDevkit?.hookTokens?.prefix ?? spec.meta.key;
+  const stableStepId = sanitizeIdentifier(step.id);
+  if (tokenStrategy === "session-scoped") {
+    const resolvedRunIdentity = sanitizeIdentifier(resolveWorkflowDevkitRunIdentity(spec, runIdentity));
+    return `${prefix}:${resolvedRunIdentity}:${stableStepId}`;
+  }
+  if (tokenStrategy === "step-scoped") {
+    return `${prefix}:v${spec.meta.version}:${stableStepId}`;
+  }
+  return `${prefix}:${stableStepId}`;
+}
+function resolveWorkflowDevkitNextStepId(spec, step, data, input, output) {
+  const transitions = spec.definition.transitions.filter((transition) => transition.from === step.id);
+  for (const transition of transitions) {
+    if (evaluateExpression(transition.condition, {
+      data,
+      input,
+      output
+    })) {
+      return transition.to;
+    }
+  }
+  return null;
+}
+function mergeWorkflowDevkitData(current, input, output) {
+  const next = { ...current };
+  if (isRecord(input)) {
+    Object.assign(next, input);
+  }
+  if (isRecord(output)) {
+    Object.assign(next, output);
+  }
+  return next;
+}
+function sanitizeIdentifier(value) {
+  return value.replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/compiler.ts
+function compileWorkflowSpecToWorkflowDevkit(spec) {
+  return {
+    entryStepId: resolveWorkflowDevkitEntryStepId(spec),
+    hostTarget: spec.runtime?.workflowDevkit?.hostTarget ?? "generic",
+    hookTokenStrategy: spec.runtime?.workflowDevkit?.hookTokens?.strategy ?? "deterministic",
+    integrationMode: spec.runtime?.workflowDevkit?.integrationMode ?? "manual",
+    runIdentityStrategy: spec.runtime?.workflowDevkit?.runIdentity?.strategy ?? "meta-key-version",
+    specKey: spec.meta.key,
+    specVersion: spec.meta.version,
+    steps: spec.definition.steps.map((step) => ({
+      behavior: inferWorkflowDevkitBehavior(step),
+      id: step.id,
+      label: step.label,
+      operationRef: step.action?.operation ? `${step.action.operation.key}.v${step.action.operation.version}` : undefined,
+      runtime: step.runtime?.workflowDevkit,
+      transitions: spec.definition.transitions.filter((transition) => transition.from === step.id).map((transition) => ({
+        condition: transition.condition,
+        to: transition.to
+      })),
+      type: step.type,
+      waitToken: resolveWorkflowDevkitWaitToken(spec, step)
+    }))
+  };
+}
+function generateWorkflowDevkitArtifacts(spec, options) {
+  const compilation = compileWorkflowSpecToWorkflowDevkit(spec);
+  const workflowFunctionName = options.workflowFunctionName ?? `${sanitizeIdentifier(options.exportName)}WorkflowDevkit`;
+  return {
+    genericBootstrap: createGenericBootstrapTemplate(options.exportName, workflowFunctionName),
+    manifest: JSON.stringify(compilation, null, 2),
+    nextFollowUpRoute: createFollowUpRouteTemplate(workflowFunctionName),
+    nextStartRoute: createStartRouteTemplate(workflowFunctionName),
+    nextStreamRoute: createStreamRouteTemplate(),
+    workflowModule: createWorkflowModuleTemplate(options.exportName, options.specImportPath, workflowFunctionName)
+  };
+}
+function createGenericBootstrapTemplate(exportName, workflowFunctionName) {
+  return `import { ${workflowFunctionName} } from "./${sanitizeIdentifier(exportName)}.workflow-devkit";
+
+export const ${sanitizeIdentifier(exportName)}WorkflowDevkitBootstrap = {
+  workflow: ${workflowFunctionName},
+  createBridge() {
+    return {
+      executeAutomationStep: async () => {
+        throw new Error("Provide executeAutomationStep in your generic host bridge.");
+      },
+    };
+  },
+};
+`;
+}
+function createStartRouteTemplate(workflowFunctionName) {
+  return `import { createWorkflowDevkitStartRoute } from "@contractspec/integration.workflow-devkit";
+import { ${workflowFunctionName} } from "./workflow";
+
+export const POST = createWorkflowDevkitStartRoute({
+  workflow: ${workflowFunctionName},
+  async buildArgs(body) {
+    return [body];
+  },
+});
+`;
+}
+function createFollowUpRouteTemplate(workflowFunctionName) {
+  return `import { createWorkflowDevkitFollowUpRoute } from "@contractspec/integration.workflow-devkit";
+
+export const POST = createWorkflowDevkitFollowUpRoute({
+  resolveToken({ runId }) {
+    return \`${workflowFunctionName}:\${runId}\`;
+  },
+});
+`;
+}
+function createStreamRouteTemplate() {
+  return `import { createWorkflowDevkitStreamRoute } from "@contractspec/integration.workflow-devkit";
+
+export const GET = createWorkflowDevkitStreamRoute();
+`;
+}
+function createWorkflowModuleTemplate(exportName, specImportPath, workflowFunctionName) {
+  return `import { createHook, createWebhook, sleep } from "workflow";
+import { runWorkflowSpecWithWorkflowDevkit } from "@contractspec/integration.workflow-devkit";
+import { ${exportName} } from "${specImportPath}";
+
+export async function ${workflowFunctionName}(input = {}, bridge = {}) {
+  "use workflow";
+
+  return runWorkflowSpecWithWorkflowDevkit({
+    spec: ${exportName},
+    initialData: input,
+    bridge,
+    primitives: {
+      sleep,
+      createHook,
+      createWebhook,
+    },
+  });
+}
+`;
+}
+export {
+  generateWorkflowDevkitArtifacts,
+  compileWorkflowSpecToWorkflowDevkit
+};

package/dist/browser/helpers.js

@@ -0,0 +1,80 @@
+// src/helpers.ts
+import { evaluateExpression } from "@contractspec/lib.contracts-spec/workflow";
+function inferWorkflowDevkitBehavior(step) {
+  return step.runtime?.workflowDevkit?.behavior ?? step.type;
+}
+function resolveWorkflowDevkitEntryStepId(spec) {
+  const entryStepId = spec.definition.entryStepId ?? spec.definition.steps[0]?.id;
+  if (!entryStepId) {
+    throw new Error(`Workflow ${spec.meta.key}.v${spec.meta.version} does not define an entry step.`);
+  }
+  return entryStepId;
+}
+function resolveWorkflowDevkitRunIdentity(spec, runIdentity) {
+  if (runIdentity) {
+    return runIdentity;
+  }
+  const strategy = spec.runtime?.workflowDevkit?.runIdentity?.strategy ?? "meta-key-version";
+  const prefix = spec.runtime?.workflowDevkit?.runIdentity?.prefix;
+  const baseIdentity = strategy === "meta-key-version" ? `${spec.meta.key}.v${spec.meta.version}` : `${spec.meta.key}.v${spec.meta.version}`;
+  return prefix ? `${prefix}:${baseIdentity}` : baseIdentity;
+}
+function resolveWorkflowDevkitWaitToken(spec, step, runIdentity) {
+  const runtime = step.runtime?.workflowDevkit;
+  if (!runtime) {
+    return;
+  }
+  const explicitToken = runtime.hookWait?.token ?? runtime.webhookWait?.token ?? runtime.approvalWait?.token ?? runtime.streamSession?.followUpToken;
+  if (explicitToken) {
+    return explicitToken;
+  }
+  const tokenStrategy = spec.runtime?.workflowDevkit?.hookTokens?.strategy ?? "deterministic";
+  const prefix = spec.runtime?.workflowDevkit?.hookTokens?.prefix ?? spec.meta.key;
+  const stableStepId = sanitizeIdentifier(step.id);
+  if (tokenStrategy === "session-scoped") {
+    const resolvedRunIdentity = sanitizeIdentifier(resolveWorkflowDevkitRunIdentity(spec, runIdentity));
+    return `${prefix}:${resolvedRunIdentity}:${stableStepId}`;
+  }
+  if (tokenStrategy === "step-scoped") {
+    return `${prefix}:v${spec.meta.version}:${stableStepId}`;
+  }
+  return `${prefix}:${stableStepId}`;
+}
+function resolveWorkflowDevkitNextStepId(spec, step, data, input, output) {
+  const transitions = spec.definition.transitions.filter((transition) => transition.from === step.id);
+  for (const transition of transitions) {
+    if (evaluateExpression(transition.condition, {
+      data,
+      input,
+      output
+    })) {
+      return transition.to;
+    }
+  }
+  return null;
+}
+function mergeWorkflowDevkitData(current, input, output) {
+  const next = { ...current };
+  if (isRecord(input)) {
+    Object.assign(next, input);
+  }
+  if (isRecord(output)) {
+    Object.assign(next, output);
+  }
+  return next;
+}
+function sanitizeIdentifier(value) {
+  return value.replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+export {
+  sanitizeIdentifier,
+  resolveWorkflowDevkitWaitToken,
+  resolveWorkflowDevkitRunIdentity,
+  resolveWorkflowDevkitNextStepId,
+  resolveWorkflowDevkitEntryStepId,
+  mergeWorkflowDevkitData,
+  inferWorkflowDevkitBehavior
+};