@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/ast/types.d.ts

@@ -87,14 +87,6 @@ export type TWorkflowAST = {
     ui?: {
         disablePan?: boolean;
         disableZoom?: boolean;
-        startNode?: {
-            x?: number;
-            y?: number;
-        };
-        exitNode?: {
-            x?: number;
-            y?: number;
-        };
         instances?: TNodeUI[];
         nodeTypes?: TNodeTypeUI[];
         /** In-memory only: stage transformation matrix (not persisted to file) */
@@ -235,6 +227,34 @@ export type TNodeTypeAST = {
     executeWhen: TExecuteWhen;
     /** Whether the function is declared async */
     isAsync: boolean;
+    /** Engine appends the execution AbortSignal after declared node inputs. */
+    receivesAbortSignal?: boolean;
+    /** Engine appends the execution-scoped node runtime after declared inputs. */
+    receivesRuntime?: boolean;
+    /** Explicit compiler-known durable gate boundary. */
+    durableGate?: 'approval' | 'input' | 'agent' | 'timer';
+    /** Explicit effect adapter contract, never inferred from a function name. */
+    durableEffect?: boolean;
+    /**
+     * Compiler analysis of an authored durable-effect callable. Runtime-provided
+     * external node descriptors omit this because their implementation is not
+     * available to the TypeScript compiler.
+     */
+    durableEffectContract?: {
+        /** Whether the callable satisfies the operation-key, envelope, and output contract. */
+        valid: boolean;
+        /** Stable author-facing diagnostics collected from TypeScript type metadata. */
+        diagnostics: string[];
+    };
+    /** Compiler-reviewed pure or orchestration node for gated workflows. */
+    durablePure?: boolean;
+    /** Statically declared retry/fallback behavior implemented inside the node adapter. */
+    resilience?: {
+        /** Number of retries performed after the initial provider attempt. */
+        retries?: number;
+        /** Named fallback provider or strategy used after retry exhaustion. */
+        fallback?: string;
+    };
     /** Default configuration for instances */
     defaultConfig?: TNodeTypeDefaultConfig;
     /** Single scope name (e.g., 'iteration' for forEach) */
@@ -253,10 +273,6 @@ export type TNodeTypeAST = {
     label?: string;
     /** Description from JSDoc */
     description?: string;
-    /** X position hint */
-    x?: number;
-    /** Y position hint */
-    y?: number;
     /** Source code location */
     sourceLocation?: TSourceLocation;
     /** Original function source text (main function only) */
@@ -343,8 +359,6 @@ export type TNodeInstanceConfig = {
      * Allows instances to customize port behavior
      */
     portConfigs?: TPortConfig[];
-    x?: number;
-    y?: number;
     color?: string;
     icon?: string;
     tags?: TNodeTagAST[];
@@ -388,11 +402,13 @@ export type TNodeInstanceAST = {
     sourceLocation?: TSourceLocation;
     /** Reserved for plugin extensibility */
     metadata?: TNodeMetadata;
-    /** CI/CD job group this node belongs to (from [job: "name"] attribute). */
-    job?: string;
-    /** CI/CD environment for this node's job (from [environment: "name"] attribute). */
-    environment?: string;
-    /** Per-target deploy config contributed by packs (e.g., deploy['cicd'].job) */
+    /**
+     * Generic `[key: "value"]` bracket attributes from `@node`, kept verbatim.
+     * Core stores them but gives them no meaning; a pack reads them and decides
+     * what they do. This is the `@node`-attribute extension point.
+     */
+    attributes?: Record<string, string>;
+    /** Per-target deploy config contributed by packs (e.g., deploy['<pack>'].key) */
     deploy?: Record<string, Record<string, unknown>>;
 };
 /**
@@ -413,8 +429,32 @@ export type TTypeCompatibility = {
 };
 /**
  * Workflow-level options parsed from JSDoc annotations.
+ *
+ * Declared as an `interface` so packs can contribute domain-specific option
+ * fields via module augmentation (a pack augments this with its own typed
+ * field). Core carries only generic options plus the `deploy` escape hatch.
+ * Vendor and domain vocabularies live in their packs.
  */
-export type TWorkflowOptions = {
+/**
+ * One HTTP route a workflow answers on, from `@http METHOD /path [mode=…] [auth=…] [callback]`.
+ *
+ * The route is the workflow's own declaration that it is an endpoint: `fw serve`
+ * and the embeddable server mount exactly these, with the workflow's `params`
+ * as the request contract (path params by name, then the query string for
+ * GET, the JSON body otherwise) and its return ports as the response.
+ */
+export interface THttpRoute {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /** Absolute, may carry `:name` segments that bind to params of that name. */
+    path: string;
+    /** `sync` (default) answers when the first segment ends; `async` answers at once with the run. */
+    mode?: 'sync' | 'async';
+    /** `bearer` (default) needs the server's token; `none` is public. */
+    auth?: 'bearer' | 'none';
+    /** Accept a `callbackUrl` and POST the final response there when the run ends. */
+    callback?: boolean;
+}
+export interface TWorkflowOptions {
     /** When true, type incompatibilities are errors instead of warnings */
     strictTypes?: boolean;
     /** When true, connections are auto-wired based on node declaration order */
@@ -424,7 +464,9 @@ export type TWorkflowOptions = {
         event?: string;
         cron?: string;
     };
-    /** Cancellation configuration — cancel on matching external event */
+    /** The HTTP routes this workflow is served on (`@http`), in declaration order */
+    http?: THttpRoute[];
+    /** Cancellation configuration: cancel on matching external event */
     cancelOn?: {
         event: string;
         match?: string;
@@ -439,201 +481,13 @@ export type TWorkflowOptions = {
         limit: number;
         period?: string;
     };
-    /** CI/CD pipeline configuration from @secret, @cache, @artifact, etc. */
-    cicd?: TCICDOptions;
-    /** Target-specific config (e.g., deploy['github-actions'].runner) */
+    /**
+     * Namespaced deploy config. Pack tag handlers populate `deploy[namespace]`
+     * (e.g. `deploy['github-actions'].runner`). Packs may additionally surface a
+     * typed convenience field via module augmentation.
+     */
     deploy?: Record<string, Record<string, unknown>>;
-};
-/**
- * CI/CD domain options — shared across all CI/CD export targets.
- * Populated from @secret, @runner, @cache, @artifact, @environment,
- * @matrix, @service, @concurrency, @job, @stage, @variables,
- * @before_script, @tags, @includes annotations.
- */
-export type TCICDOptions = {
-    /** Secret declarations for CI/CD pipelines */
-    secrets?: TCICDSecret[];
-    /** Default runner environment for CI/CD jobs */
-    runner?: string;
-    /** Cache configurations for CI/CD */
-    caches?: TCICDCache[];
-    /** Artifact declarations for CI/CD */
-    artifacts?: TCICDArtifact[];
-    /** Deployment environment configurations */
-    environments?: TCICDEnvironment[];
-    /** Matrix strategy for multi-version/OS testing */
-    matrix?: TCICDMatrix;
-    /** Sidecar service containers */
-    services?: TCICDService[];
-    /** Concurrency control */
-    concurrency?: {
-        group: string;
-        cancelInProgress?: boolean;
-    };
-    /** Extended CI/CD triggers (push, PR, dispatch, tag) */
-    triggers?: TCICDTrigger[];
-    /** Per-job configuration from @job annotations */
-    jobs?: TCICDJobConfig[];
-    /** Workflow-level default variables from @variables */
-    variables?: Record<string, string>;
-    /** Workflow-level before_script commands from @before_script */
-    beforeScript?: string[];
-    /** Workflow-level runner tags from @tags */
-    tags?: string[];
-    /** GitLab template includes from @includes */
-    includes?: TCICDInclude[];
-    /** Pipeline stage declarations from @stage */
-    stages?: TCICDStage[];
-};
-/** Secret declaration from @secret annotation */
-export type TCICDSecret = {
-    /** Secret name (e.g., NPM_TOKEN) */
-    name: string;
-    /** Human-readable description */
-    description?: string;
-    /** Platform restriction (default: all) */
-    platform?: 'github' | 'gitlab' | 'all';
-    /** Which job scope uses this secret */
-    scope?: string;
-};
-/** Cache configuration from @cache annotation */
-export type TCICDCache = {
-    /** Cache strategy name (e.g., npm, pip, custom) */
-    strategy: string;
-    /** Cache path override (comma-separated for multiple paths) */
-    path?: string;
-    /** Cache key file (e.g., package-lock.json) */
-    key?: string;
-    /** Cache policy (pull, push, pull-push) */
-    policy?: string;
-    /** Files to use for cache key generation */
-    files?: string[];
-};
-/** Artifact declaration from @artifact annotation */
-export type TCICDArtifact = {
-    /** Artifact name */
-    name: string;
-    /** Path(s) to include */
-    path: string;
-    /** Retention in days */
-    retention?: number;
-};
-/** Deployment environment from @environment annotation */
-export type TCICDEnvironment = {
-    /** Environment name (e.g., production, staging) */
-    name: string;
-    /** Environment URL */
-    url?: string;
-    /** Number of required reviewers */
-    reviewers?: number;
-};
-/** Matrix strategy from @matrix annotation */
-export type TCICDMatrix = {
-    /** Dimension name → values (e.g., { "node": ["18","20","22"] }) */
-    dimensions: Record<string, string[]>;
-    /** Explicit include entries */
-    include?: Record<string, string>[];
-    /** Explicit exclude entries */
-    exclude?: Record<string, string>[];
-};
-/** Service container from @service annotation */
-export type TCICDService = {
-    /** Service name */
-    name: string;
-    /** Docker image */
-    image: string;
-    /** Environment variables */
-    env?: Record<string, string>;
-    /** Port mappings (host:container) */
-    ports?: string[];
-};
-/** CI/CD trigger from extended @trigger annotation */
-export type TCICDTrigger = {
-    /** Trigger type */
-    type: 'push' | 'pull_request' | 'schedule' | 'dispatch' | 'tag';
-    /** Branch filters */
-    branches?: string[];
-    /** Path filters */
-    paths?: string[];
-    /** Path ignore filters */
-    pathsIgnore?: string[];
-    /** Tag pattern (for tag triggers) */
-    pattern?: string;
-    /** PR event types (e.g., opened, synchronize) */
-    types?: string[];
-    /** Cron expression (for schedule triggers) */
-    cron?: string;
-    /** Dispatch inputs */
-    inputs?: Record<string, {
-        description?: string;
-        required?: boolean;
-        default?: string;
-        type?: string;
-    }>;
-};
-/** Per-job configuration from @job annotation */
-export type TCICDJobConfig = {
-    /** Job identifier (must match a [job: "name"] on @node declarations) */
-    id: string;
-    /** Maximum retry count on failure */
-    retry?: number;
-    /** Whether this job can fail without failing the pipeline */
-    allowFailure?: boolean;
-    /** Job-level timeout duration (e.g., "30m", "1h") */
-    timeout?: string;
-    /** Key-value environment variables */
-    variables?: Record<string, string>;
-    /** Runner selection tags */
-    tags?: string[];
-    /** Setup commands run before the main script */
-    beforeScript?: string[];
-    /** Conditional execution rules */
-    rules?: TCICDJobRule[];
-    /** Coverage regex pattern */
-    coverage?: string;
-    /** Test/coverage report declarations */
-    reports?: TCICDReport[];
-    /** Per-job runner override */
-    runner?: string;
-    /** GitLab template to extend */
-    extends?: string;
-};
-/** Conditional execution rule for a CI/CD job */
-export type TCICDJobRule = {
-    /** Condition expression (e.g., '$CI_COMMIT_BRANCH == "main"') */
-    if?: string;
-    /** When to run: always, never, manual, delayed */
-    when?: 'always' | 'never' | 'manual' | 'delayed';
-    /** Whether failure is allowed when this rule matches */
-    allowFailure?: boolean;
-    /** Variables to set when this rule matches */
-    variables?: Record<string, string>;
-    /** Changed file patterns that trigger this rule */
-    changes?: string[];
-};
-/** Report declaration for a CI/CD job */
-export type TCICDReport = {
-    /** Report type (junit, cobertura, codequality, sast, etc.) */
-    type: string;
-    /** Report file path */
-    path: string;
-};
-/** GitLab include directive from @includes annotation */
-export type TCICDInclude = {
-    /** Include type */
-    type: 'local' | 'project' | 'remote' | 'template';
-    /** File path or URL */
-    file: string;
-    /** Project path (for type=project) */
-    project?: string;
-    /** Git ref (for type=project) */
-    ref?: string;
-};
-/** Pipeline stage declaration from @stage annotation */
-export type TCICDStage = {
-    /** Stage name */
-    name: string;
-};
+}
 /**
  * Connection AST - A link between two ports.
  *
@@ -654,6 +508,19 @@ export type TConnectionAST = {
     typeCompatibility?: TTypeCompatibility;
     /** Explicit type coercion for this connection (e.g., 'number' wraps value with Number()) */
     coerce?: TCoerceTargetType;
+    /**
+     * Set when the connection was not written as `@connect` but derived from an
+     * `[expr: port="..."]` binding on the target instance that references
+     * `from.node`'s port. The expression is the value source. The connection
+     * records the data dependency so ordering, cycle detection, queries and
+     * the editor see it. Derived connections are never emitted as `@connect`,
+     * are exempt from the one-source and type-compatibility rules (the
+     * expression transforms the value), and cannot be removed on their own.
+     */
+    derived?: {
+        kind: 'expression';
+        expression: string;
+    };
 };
 /**
  * Port Reference - Identifies a specific port on a node.
@@ -1009,82 +876,6 @@ export type TWorkFlowFunctionUI = {
     /** In-memory only: stage transformation matrix (not persisted to file) */
     transformation?: number[];
 };
-/**
- * Pattern AST - A reusable workflow fragment that can be applied to workflows.
- *
- * Patterns are like workflow templates with IN/OUT pseudo-nodes instead of Start/Exit.
- * They can be applied to workflows to insert nodes, connections, and types.
- *
- * ```
- * ┌─────────────────────────────────────────────────────────────┐
- * │                        PATTERN                               │
- * │  ┌─────────────────┐    ┌─────────────────┐                 │
- * │  │  NODE TYPES     │    │  NODE INSTANCES │                 │
- * │  │  (inline/refs)  │◄───│  (pattern nodes)│                 │
- * │  └─────────────────┘    └─────────────────┘                 │
- * │                              │                               │
- * │  ┌───────────────────────────▼───────────────────────────┐  │
- * │  │                   CONNECTIONS                          │  │
- * │  │  IN.port → node.port, node.port → OUT.port             │  │
- * │  └────────────────────────────────────────────────────────┘  │
- * │  inputPorts{} ─────────────────────────────► outputPorts{}   │
- * └─────────────────────────────────────────────────────────────┘
- * ```
- *
- * @example
- * ```typescript
- * const pattern: TPatternAST = {
- *   type: "Pattern",
- *   name: "validateTransform",
- *   description: "Validate then transform data",
- *   nodeTypes: [...],
- *   instances: [...],
- *   connections: [...],
- *   inputPorts: { data: { description: "Input data" } },
- *   outputPorts: { result: { description: "Transformed result" } }
- * };
- * ```
- */
-export type TPatternAST = {
-    type: 'Pattern';
-    /** Source file path */
-    sourceFile: string;
-    /** Pattern name (from @name) */
-    name: string;
-    /** Description from @description */
-    description?: string;
-    /**
-     * Node types defined inline in this pattern.
-     * Referenced node types are not included here.
-     */
-    nodeTypes: TNodeTypeAST[];
-    /**
-     * Instances are the nodes in the pattern graph.
-     * Each instance references a node type by name.
-     */
-    instances: TNodeInstanceAST[];
-    /** Connections between pattern nodes and IN/OUT */
-    connections: TConnectionAST[];
-    /** Input ports (connections from IN pseudo-node) */
-    inputPorts: Record<string, TPatternPortDefinition>;
-    /** Output ports (connections to OUT pseudo-node) */
-    outputPorts: Record<string, TPatternPortDefinition>;
-    /** Source location of the pattern annotation */
-    sourceLocation?: TSourceLocation;
-    /** Reserved for plugin extensibility */
-    metadata?: Record<string, unknown>;
-};
-/**
- * Pattern Port Definition - A port on the IN or OUT pseudo-nodes.
- */
-export type TPatternPortDefinition = {
-    /** Port description from @port annotation */
-    description?: string;
-    /** Data type if known */
-    dataType?: TDataType;
-    /** Original TypeScript type string */
-    tsType?: string;
-};
 /**
  * Convenience alias - TPortType = TDataType
  */

package/dist/ast/workflow-utils.d.ts

@@ -1,4 +1,4 @@
-import type { TPortDefinition, TWorkflowAST } from "./types.js";
+import type { TPortDefinition, TWorkflowAST } from "./types";
 /**
  * Extracts the input port definitions from the workflow's Start virtual node.
  * Returns the workflow's explicit `startPorts` if defined, otherwise infers them
@@ -25,7 +25,7 @@ export declare function extractExitPorts(workflow: TWorkflowAST): Record<string,
  * @param nodeName - The name of the node type to find.
  * @returns The matching node type, or undefined if not found.
  */
-export declare function getNodeType(workflow: TWorkflowAST, nodeName: string): import("./types.js").TNodeTypeAST | undefined;
+export declare function getNodeType(workflow: TWorkflowAST, nodeName: string): import("./types").TNodeTypeAST | undefined;
 /**
  * Returns all connections originating from the specified node.
  *
@@ -33,7 +33,7 @@ export declare function getNodeType(workflow: TWorkflowAST, nodeName: string): i
  * @param nodeName - The source node name to filter by.
  * @returns An array of connections where `from.node` matches the given name.
  */
-export declare function getConnectionsFrom(workflow: TWorkflowAST, nodeName: string): import("./types.js").TConnectionAST[];
+export declare function getConnectionsFrom(workflow: TWorkflowAST, nodeName: string): import("./types").TConnectionAST[];
 /**
  * Returns all connections targeting the specified node.
  *
@@ -41,7 +41,7 @@ export declare function getConnectionsFrom(workflow: TWorkflowAST, nodeName: str
  * @param nodeName - The target node name to filter by.
  * @returns An array of connections where `to.node` matches the given name.
  */
-export declare function getConnectionsTo(workflow: TWorkflowAST, nodeName: string): import("./types.js").TConnectionAST[];
+export declare function getConnectionsTo(workflow: TWorkflowAST, nodeName: string): import("./types").TConnectionAST[];
 /**
  * Determines whether a workflow contains branching control flow.
  * A workflow has branching if any node type has multiple outgoing success connections

package/dist/built-in-nodes/coercion-types.d.ts

@@ -4,7 +4,7 @@
  * These are compiler-internal node types created by @coerce macros.
  * They generate inline JavaScript coercion expressions instead of function calls.
  */
-import type { TNodeTypeAST, TCoerceTargetType } from '../ast/types.js';
+import type { TNodeTypeAST, TCoerceTargetType } from '../ast/types';
 /** Maps coercion target type keyword to the synthetic node type name */
 export declare const COERCE_TYPE_MAP: Record<TCoerceTargetType, string>;
 /** Maps synthetic node type name to the inline JS expression */

package/dist/built-in-nodes/delay.d.ts

@@ -1,11 +1,13 @@
+import type { NodeExecutionRuntime } from '../runtime/durable-execution.js';
 /**
  * @flowWeaver nodeType
  * @input duration - Duration to sleep (e.g. "30s", "5m", "1h", "2d")
  * @output elapsed - Always true after sleep completes
  */
-export declare function delay(execute: boolean, duration: string): Promise<{
+export declare function delay(execute: boolean, duration: string, abortSignal?: AbortSignal, runtime?: NodeExecutionRuntime): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     elapsed: boolean;
 }>;
+export declare function parseDuration(text: unknown): number | undefined;
 //# sourceMappingURL=delay.d.ts.map

package/dist/built-in-nodes/generated-registry.d.ts

@@ -4,6 +4,6 @@
  * Registry of built-in node types for auto-injection into the parser.
  * Generated from the actual source files in src/built-in-nodes/.
  */
-import type { TNodeTypeAST } from '../ast/types.js';
+import type { TNodeTypeAST } from '../ast/types';
 export declare const BUILT_IN_NODE_TYPES: TNodeTypeAST[];
 //# sourceMappingURL=generated-registry.d.ts.map

package/dist/built-in-nodes/index.d.ts

@@ -1,6 +1,7 @@
-export { delay } from './delay.js';
-export { waitForEvent } from './wait-for-event.js';
-export { waitForAgent } from './wait-for-agent.js';
-export { invokeWorkflow } from './invoke-workflow.js';
-export type { FwMockConfig } from './mock-types.js';
+export { delay } from './delay';
+export { sleep } from './sleep';
+export { waitForEvent } from './wait-for-event';
+export { waitForAgent } from './wait-for-agent';
+export { invokeWorkflow } from './invoke-workflow';
+export type { FwMockConfig } from './mock-types';
 //# sourceMappingURL=index.d.ts.map

package/dist/built-in-nodes/index.js

@@ -1,5 +1,79 @@
-export { delay } from './delay.js';
-export { waitForEvent } from './wait-for-event.js';
-export { waitForAgent } from './wait-for-agent.js';
-export { invokeWorkflow } from './invoke-workflow.js';
-//# sourceMappingURL=index.js.map
+import {
+  delay,
+  getMockConfig,
+  lookupMock
+} from "../chunks/chunk-DIAA66GL.js";
+import {
+  CancellationError
+} from "../chunks/chunk-6KMVP6AU.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/built-in-nodes/sleep.ts
+async function sleep(execute, duration, runtime) {
+  if (!execute) return { onSuccess: false, onFailure: false, wokeAt: "" };
+  void duration;
+  void runtime;
+  throw new Error("sleep requires a generated durable timer gate");
+}
+
+// src/built-in-nodes/wait-for-event.ts
+async function waitForEvent(execute, eventName, match, timeout, runtime) {
+  if (!execute) return { onSuccess: false, onFailure: false, eventData: {} };
+  void eventName;
+  void match;
+  void timeout;
+  void runtime;
+  throw new Error("waitForEvent requires a generated durable input gate");
+}
+
+// src/built-in-nodes/wait-for-agent.ts
+async function waitForAgent(execute, agentId, context, prompt, _abortSignal, runtime) {
+  if (!execute) return { onSuccess: false, onFailure: false, agentResult: {} };
+  void agentId;
+  void context;
+  void prompt;
+  void runtime;
+  throw new Error("waitForAgent requires a generated durable agent gate");
+}
+
+// src/built-in-nodes/invoke-workflow.ts
+async function invokeWorkflow(execute, functionId, payload, timeout, abortSignal, runtime) {
+  if (!execute) return { onSuccess: false, onFailure: false, result: {} };
+  const mocks = getMockConfig(runtime);
+  if (mocks) {
+    const mockResult = lookupMock(mocks.invocations, functionId, runtime);
+    if (mockResult !== void 0) {
+      return { onSuccess: true, onFailure: false, result: mockResult };
+    }
+    return { onSuccess: false, onFailure: true, result: {} };
+  }
+  const registry = runtime?.runtime.services.workflowRegistry;
+  if (registry?.[functionId]) {
+    const nodeRuntime = runtime;
+    if (!Number.isSafeInteger(nodeRuntime.recursionDepth) || nodeRuntime.recursionDepth < 0 || nodeRuntime.recursionDepth >= 999) {
+      throw new Error("Max recursion depth exceeded (1000) in dynamic workflow invocation");
+    }
+    try {
+      const result = await registry[functionId](
+        true,
+        { ...payload, __rd__: nodeRuntime.recursionDepth + 1 },
+        nodeRuntime.createNestedRuntime(functionId)
+      );
+      return { onSuccess: true, onFailure: false, result: result ?? {} };
+    } catch (error) {
+      const controlFlowCode = typeof error === "object" && error !== null ? error.code : void 0;
+      if (CancellationError.isCancellationError(error) || controlFlowCode === "FLOW_WEAVER_DURABLE_GATE_YIELD" || controlFlowCode === "FLOW_WEAVER_AMBIGUOUS_EFFECT") {
+        throw error;
+      }
+      return { onSuccess: false, onFailure: true, result: {} };
+    }
+  }
+  return { onSuccess: true, onFailure: false, result: {} };
+}
+export {
+  delay,
+  invokeWorkflow,
+  sleep,
+  waitForAgent,
+  waitForEvent
+};

package/dist/built-in-nodes/invoke-workflow.d.ts

@@ -1,3 +1,4 @@
+import type { NodeExecutionRuntime } from '../runtime/durable-execution.js';
 /**
  * @flowWeaver nodeType
  * @input functionId - Function ID of the workflow to invoke (e.g. "my-service/sub-workflow")
@@ -5,7 +6,7 @@
  * @input [timeout] - Max wait time (e.g. "1h")
  * @output result - Return value from the invoked function
  */
-export declare function invokeWorkflow(execute: boolean, functionId: string, payload: object, timeout?: string): Promise<{
+export declare function invokeWorkflow(execute: boolean, functionId: string, payload: object, timeout?: string, abortSignal?: AbortSignal, runtime?: NodeExecutionRuntime): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     result: object;