@pikku/core 0.12.134 → 0.12.136

package/dist/testing/service-tests.d.ts

@@ -41,8 +41,12 @@ export interface ServiceTestConfig {
         leaseService?: () => Promise<LeaseService>;
         /** A workflow service that fences each step write to the claim that made it. */
         workflowFencing?: () => Promise<WorkflowFencingHarness>;
+        /** A workflow service to run saga compensation and graph `recover` against, driven through a queue. */
+        workflowCompensationQueued?: () => Promise<PikkuWorkflowService>;
+        workflowCompensationQueuedOptions?: QueuedCompensationOptions;
     };
 }
+import { type QueuedCompensationOptions } from './service-tests/workflow-compensation-queued-tests.js';
 /**
  * The shared conformance suite every storage backend runs.
  *

package/dist/testing/service-tests.js

@@ -10,6 +10,7 @@ import { defineAgentRunServiceTests } from './service-tests/agent-run-service-te
 import { defineSessionStoreTests } from './service-tests/session-store-tests.js';
 import { defineLeaseServiceTests } from './service-tests/lease-service-tests.js';
 import { defineWorkflowFencingTests } from './service-tests/workflow-fencing-tests.js';
+import { defineWorkflowCompensationQueuedTests, } from './service-tests/workflow-compensation-queued-tests.js';
 /**
  * The shared conformance suite every storage backend runs.
  *
@@ -27,6 +28,9 @@ export function defineServiceTests(config) {
     if (services.workflowService) {
         defineWorkflowServiceTests(name, services.workflowService);
     }
+    if (services.workflowCompensationQueued) {
+        defineWorkflowCompensationQueuedTests(name, services.workflowCompensationQueued, services.workflowCompensationQueuedOptions);
+    }
     if (services.workflowRunService) {
         defineWorkflowRunServiceTests(name, services.workflowRunService);
     }

package/dist/utils/hmac.d.ts

@@ -1,4 +1,3 @@
-import type { CredentialService } from '../services/credential-service.js';
 /**
  * HMAC-SHA256 of a payload, hex-encoded. Senders wrap this in their own scheme
  * prefix (`sha256=`, `v0=`, …).
@@ -12,7 +11,6 @@ export declare function timingSafeStringEqual(a: string, b: string): boolean;
 export type WebhookPayload = string | Uint8Array;
 export type HmacAlgorithm = 'sha1' | 'sha256' | 'sha512';
 export type SecretEncoding = 'utf8' | 'hex' | 'base64';
-type SecretSource = string | null | (() => Promise<string | null>);
 /** The HMAC of `payload` under `secret`, for handshakes that answer with a digest. */
 export declare function hmacDigest(secret: string, algorithm: HmacAlgorithm, payload: WebhookPayload, encoding: 'hex' | 'base64', secretEncoding?: SecretEncoding): string;
 /** Whether `signature` is the HMAC of `payload` under `secret`, compared in constant time. */
@@ -22,34 +20,3 @@ export declare function verifyPublicKeySignature(publicKey: string, signature: s
     algorithm?: string;
     dsaEncoding?: 'der' | 'ieee-p1363';
 }): boolean;
-/**
- * @deprecated Declare `credential` and `verify` on `wireTriggerWebhookSource`,
- * which checks every request before `receive` runs, or use the functions above.
- */
-export declare class WebhookSigningSecret {
-    private readonly provider;
-    private readonly secret;
-    constructor(provider: string, secret: SecretSource);
-    /**
-     * The secret a `setup` step or a handshake stored in the credential store,
-     * so a new one takes effect without a deploy.
-     */
-    static fromCredential(provider: string, credentials: CredentialService | undefined, name: string): WebhookSigningSecret;
-    get configured(): boolean;
-    /** The secret as it is now, to check one delivery against. */
-    load(): Promise<WebhookSigningSecret>;
-    /** For handshakes that answer with a digest, such as Zoom's URL validation. */
-    hmac(algorithm: HmacAlgorithm, payload: WebhookPayload, encoding: 'hex' | 'base64', secretEncoding?: SecretEncoding): string;
-    /** Throws unless `signature` is the HMAC of `payload` under the secret. */
-    verifyHmac(signature: string | undefined, algorithm: HmacAlgorithm, payload: WebhookPayload, encoding: 'hex' | 'base64', secretEncoding?: SecretEncoding): void;
-    /** For providers that send the shared secret itself rather than a signature. */
-    verifyToken(token: string | undefined): void;
-    /** For providers that sign with a private key: the secret is their public key, as PEM. */
-    verifyPublicKey(signature: string | undefined, payload: WebhookPayload, options?: {
-        algorithm?: string;
-        dsaEncoding?: 'der' | 'ieee-p1363';
-    }): void;
-    private require;
-    private rejected;
-}
-export {};

package/dist/utils/hmac.js

@@ -1,5 +1,4 @@
 import { createHmac, createVerify, timingSafeEqual } from 'node:crypto';
-import { UnauthorizedError } from '../errors/errors.js';
 /**
  * HMAC-SHA256 of a payload, hex-encoded. Senders wrap this in their own scheme
  * prefix (`sha256=`, `v0=`, …).
@@ -43,63 +42,3 @@ export function verifyPublicKeySignature(publicKey, signature, payload, options
         return false;
     }
 }
-/**
- * @deprecated Declare `credential` and `verify` on `wireTriggerWebhookSource`,
- * which checks every request before `receive` runs, or use the functions above.
- */
-export class WebhookSigningSecret {
-    provider;
-    secret;
-    constructor(provider, secret) {
-        this.provider = provider;
-        this.secret = secret;
-    }
-    /**
-     * The secret a `setup` step or a handshake stored in the credential store,
-     * so a new one takes effect without a deploy.
-     */
-    static fromCredential(provider, credentials, name) {
-        return new WebhookSigningSecret(provider, async () => credentials ? credentials.get(name) : null);
-    }
-    get configured() {
-        return typeof this.secret === 'string';
-    }
-    /** The secret as it is now, to check one delivery against. */
-    async load() {
-        if (typeof this.secret !== 'function') {
-            return this;
-        }
-        return new WebhookSigningSecret(this.provider, await this.secret());
-    }
-    /** For handshakes that answer with a digest, such as Zoom's URL validation. */
-    hmac(algorithm, payload, encoding, secretEncoding = 'utf8') {
-        return hmacDigest(this.require(), algorithm, payload, encoding, secretEncoding);
-    }
-    /** Throws unless `signature` is the HMAC of `payload` under the secret. */
-    verifyHmac(signature, algorithm, payload, encoding, secretEncoding = 'utf8') {
-        if (!verifyHmacSignature(this.require(), signature, algorithm, payload, encoding, secretEncoding)) {
-            throw this.rejected();
-        }
-    }
-    /** For providers that send the shared secret itself rather than a signature. */
-    verifyToken(token) {
-        if (!token || !timingSafeStringEqual(token, this.require())) {
-            throw this.rejected();
-        }
-    }
-    /** For providers that sign with a private key: the secret is their public key, as PEM. */
-    verifyPublicKey(signature, payload, options = {}) {
-        if (!verifyPublicKeySignature(this.require(), signature, payload, options)) {
-            throw this.rejected();
-        }
-    }
-    require() {
-        if (typeof this.secret !== 'string') {
-            throw new UnauthorizedError(`The ${this.provider} webhook receiver has no signing secret`);
-        }
-        return this.secret;
-    }
-    rejected() {
-        return new UnauthorizedError(`Invalid ${this.provider} webhook signature`);
-    }
-}

package/dist/utils.d.ts

@@ -4,6 +4,13 @@ export declare const closeWireServices: (logger: Logger, wireServices: WireServi
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
 export declare const getTagGroups: <T>(tagGroups: Record<string, T>, tag: string) => T[];
+/**
+ * `JSON.parse` of text or UTF-8 bytes, refusing anything that is not JSON with
+ * a 400 rather than a 500.
+ *
+ * @example snippet: pikkuWebhookReceive
+ */
+export declare const parseJson: <T = any>(input: string | Uint8Array) => T;
 export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];
 /** Stops addon package services first, then the parent singleton services. */
 export declare const stopSingletonServices: () => Promise<void>;

package/dist/utils.js

@@ -1,4 +1,5 @@
 import { getSingletonServices, getAllPackageStates } from './pikku-state.js';
+import { BadRequestError } from './errors/errors.js';
 export const closeWireServices = async (logger, wireServices) => {
     await Promise.all(Object.values(wireServices).map(async (service) => {
         if (service?.close) {
@@ -44,6 +45,21 @@ export const getTagGroups = (tagGroups, tag) => {
     }
     return results;
 };
+/**
+ * `JSON.parse` of text or UTF-8 bytes, refusing anything that is not JSON with
+ * a 400 rather than a 500.
+ *
+ * @example snippet: pikkuWebhookReceive
+ */
+export const parseJson = (input) => {
+    const text = typeof input === 'string' ? input : new TextDecoder().decode(input);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new BadRequestError('Body is not valid JSON');
+    }
+};
 const EMPTY_ARRAY = Object.freeze([]);
 export const freezeDedupe = (arr) => {
     if (!arr || arr.length === 0)

package/dist/wirings/flag/define-feature-flags.d.ts

@@ -16,18 +16,6 @@ import type { CoreFeatureFlags } from './flag.types.js';
  * the same reason: a mid-deploy revocation is not something a code edit should
  * be able to cause.
  *
- * @example
- * ```typescript
- * defineFeatureFlags({
- *   takeInBike: {
- *     description: 'Book a bike in at the counter',
- *     anyOf: ['bikes:intake'],
- *   },
- *   aiAssistant: {
- *     description: 'The assistant panel',
- *     // no anyOf — the switch is the whole answer
- *   },
- * })
- * ```
+ * @example snippet: defineFeatureFlags
  */
 export declare const defineFeatureFlags: (_config: CoreFeatureFlags) => void;

package/dist/wirings/flag/define-feature-flags.js

@@ -15,18 +15,6 @@
  * the same reason: a mid-deploy revocation is not something a code edit should
  * be able to cause.
  *
- * @example
- * ```typescript
- * defineFeatureFlags({
- *   takeInBike: {
- *     description: 'Book a bike in at the counter',
- *     anyOf: ['bikes:intake'],
- *   },
- *   aiAssistant: {
- *     description: 'The assistant panel',
- *     // no anyOf — the switch is the whole answer
- *   },
- * })
- * ```
+ * @example snippet: defineFeatureFlags
  */
 export const defineFeatureFlags = (_config) => { };

package/dist/wirings/http/http-runner.js

@@ -215,9 +215,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             await applyWebResponse(http.response, result);
         }
         else if (result === undefined || result === null) {
-            if (!statusSetByRoute) {
-                http?.response?.status(204);
-            }
+            // Nothing returned: the response keeps the status the function left on it.
         }
         else if (route.returnsJSON === false) {
             http?.response?.arrayBuffer(result);

package/dist/wirings/rpc/rpc-runner.js

@@ -1,3 +1,4 @@
+import { forwardStepName, isCompensationStepName, } from '../../function/compensation-name.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { addonInstanceForNamespace } from '../addon/addon-runner.js';
 import { isAddonFunctionExposed } from '../addon/wire-addon.js';
@@ -86,6 +87,15 @@ const resolvePikkuFunction = (rpcName, packageName = null) => {
             };
         }
     }
+    if (!rpcMeta && isCompensationStepName(rpcName)) {
+        const forward = forwardStepName(rpcName);
+        const funcs = pikkuState(null, 'function', 'functions');
+        const forwardId = rpc[forward] ?? (funcs.has(forward) ? forward : undefined);
+        const forwardFunc = forwardId ? funcs.get(forwardId) : undefined;
+        if (forwardId && forwardFunc?.compensate) {
+            return { pikkuFuncId: `${forwardId}:compensate`, packageName: null };
+        }
+    }
     if (!rpcMeta) {
         throw new RPCNotFoundError(rpcName);
     }
@@ -203,7 +213,17 @@ export class ContextAwareRPCService {
             };
         }
         const addonFunctionMeta = pikkuState(resolved.package, 'function', 'meta');
-        const funcMeta = addonFunctionMeta[resolved.function];
+        let funcMeta = addonFunctionMeta[resolved.function];
+        if (!funcMeta && isCompensationStepName(resolved.function)) {
+            const forwardName = forwardStepName(resolved.function);
+            const forwardMeta = addonFunctionMeta[forwardName];
+            if (forwardMeta?.compensate) {
+                funcMeta = {
+                    ...forwardMeta,
+                    pikkuFuncId: `${forwardMeta.pikkuFuncId || forwardName}:compensate`,
+                };
+            }
+        }
         if (!funcMeta) {
             return NOT_RESOLVED;
         }

package/dist/wirings/trigger/webhook-source-runner.d.ts

@@ -14,9 +14,9 @@ export declare const subscribedWebhookEvents: (source: string) => string[];
  */
 export declare const receiveWebhookSourceRequest: (sourceName: string, wire: {
     http?: PikkuHTTP;
-}) => Promise<Response | {
+}) => Promise<{
     received: number;
-}>;
+} | void>;
 /** The `pikku-incoming-webhooks` worker: runs the trigger an event was queued for. Throws so the queue retries. */
 export declare const dispatchWebhookSourceJob: (job: WebhookSourceJob) => Promise<void>;
 export type WebhookSourceOutcome = {

package/dist/wirings/trigger/webhook-source-runner.js

@@ -1,5 +1,6 @@
 import { getSingletonServices, pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
+import { parseJson } from '../../utils.js';
 import { PikkuMissingMetaError, UnauthorizedError, } from '../../errors/errors.js';
 import { timingSafeStringEqual, verifyHmacSignature, verifyPublicKeySignature, } from '../../utils/hmac.js';
 import { webhookSecretCredentialName } from './webhook-source.types.js';
@@ -37,11 +38,11 @@ const getSourceMeta = (source) => {
     }
     return meta;
 };
-const runSourceStep = (singletonServices, source, funcId, data) => runPikkuFunc('trigger', source, funcId, {
+const runSourceStep = (singletonServices, source, funcId, data, wire = {}) => runPikkuFunc('trigger', source, funcId, {
     singletonServices,
     auth: false,
     data: () => data,
-    wire: {},
+    wire,
 });
 const readRequest = async (http) => {
     const request = http?.request;
@@ -134,31 +135,30 @@ export const receiveWebhookSourceRequest = async (sourceName, wire) => {
     const meta = getSourceMeta(sourceName);
     const store = singletonServices.triggerSourceStore;
     if (store && !(await store.getTriggerSource(sourceName))?.enabled) {
-        return new Response(null, { status: 404 });
+        wire.http?.response?.status(404);
+        return;
     }
     const source = pikkuState(null, 'trigger', 'webhookSources').get(sourceName);
     const request = await readRequest(wire.http);
+    // A HEAD is a provider checking the URL is live. It carries no events, so
+    // it is answered here rather than in every source's `receive`.
+    if (request.method.toLowerCase() === 'head') {
+        wire.http?.response?.status(200);
+        return;
+    }
     const verified = await verifyRequest(source, request, singletonServices);
     const result = meta.receive
-        ? await runSourceStep(singletonServices, sourceName, meta.receive, request)
+        ? await runSourceStep(singletonServices, sourceName, meta.receive, request, wire)
         : {
             events: [
                 {
                     name: '',
-                    data: request.body.length
-                        ? JSON.parse(new TextDecoder().decode(request.body))
-                        : undefined,
+                    data: request.body.length ? parseJson(request.body) : undefined,
                 },
             ],
         };
-    if ('respond' in result) {
-        const { status, body, headers } = result.respond;
-        const text = body === undefined
-            ? null
-            : typeof body === 'string'
-                ? body
-                : JSON.stringify(body);
-        return new Response(text, { status, headers });
+    if (!result) {
+        return;
     }
     if (!verified && result.events.length > 0) {
         throw new UnauthorizedError(`The ${sourceName} webhook source received events in an unsigned request`);

package/dist/wirings/trigger/webhook-source.types.d.ts

@@ -20,16 +20,12 @@ export type WebhookRequest = {
     url: string;
     query: Record<string, string>;
 };
+/**
+ * The events a request carries. A handshake returns nothing and answers
+ * through `http.response` instead, which is sent only then.
+ */
 export type WebhookReceiveResult = {
     events: TriggerEvent[];
-}
-/** A handshake, such as Slack's `url_verification`: answered directly, nothing is dispatched. */
- | {
-    respond: {
-        status: number;
-        body?: unknown;
-        headers?: Record<string, string>;
-    };
 };
 export type WebhookSourceMethod = 'post' | 'put' | 'get' | 'head';
 /** Whatever `setup` wants back on the next deploy, for providers whose endpoints cannot be found by label. */
@@ -120,14 +116,15 @@ export type CoreTriggerWebhookSource<Events extends Record<string, StandardSchem
     /** What the secret is and where to find it, shown to whoever has to set it. */
     credentialDescription?: string;
     /**
-     * Checked before `receive` on every request with a body. A request is
+     * Checked before `receive` on every request. A request with a body is
      * refused when the credential is not set or the signature does not match.
-     * A request without a body — a HEAD probe, a validation token in the query —
-     * reaches `receive` unchecked, and may be answered but dispatches nothing.
+     * A request without a body that fails the check — a HEAD probe, a
+     * validation token in the query — still reaches `receive`, which may answer
+     * it, but any events it returns are refused.
      */
     verify?: WebhookVerify;
     /** Omitted: the JSON body is one event dispatched to the trigger named `<name>`. */
-    receive?: SourceFunction<WebhookRequest, WebhookReceiveResult>;
+    receive?: SourceFunction<WebhookRequest, WebhookReceiveResult | void>;
     check?: SourceFunction<WebhookLifecycleInput, WebhookCheckResult>;
     setup?: SourceFunction<WebhookLifecycleInput, WebhookSetupResult>;
     teardown?: SourceFunction<WebhookTeardownInput, WebhookTeardownResult>;

package/dist/wirings/workflow/dsl/workflow-dsl.types.d.ts

@@ -3,6 +3,7 @@
  * These types define the step-based workflow format extracted by the inspector
  */
 import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { SerializedError } from '../../../errors/serialized-error.js';
 import type { WorkflowRun } from '../workflow.types.js';
 import type { ScenarioPersona } from '../../../services/personas-service.js';
 import type { ScenarioStepOptions, ScenarioStepPhase, ScenarioSurface } from '../scenario-step.types.js';
@@ -17,12 +18,11 @@ export interface WorkflowStepOptions {
     /** Delay between retry attempts (e.g., '1s', '2s', '2min') */
     retryDelay?: string | number;
     /**
-     * RPC to invoke for compensation when this step fails after exhausting its
-     * retries. Mirrors a graph node's `onError`: the handler receives
-     * `{ error: { message } }` and the original error is still thrown, so the
-     * workflow fails — this is compensation, not recovery.
+     * Set to `false` to leave this step out of an unwind even though its
+     * function declares a `compensate`. It cannot substitute a different
+     * compensation.
      */
-    onError?: string;
+    compensate?: false;
     /**
      * Run this step as an actor (scenarios). The RPC is sent through the
      * actor's authenticated client over the REAL transport — never dispatched
@@ -93,6 +93,10 @@ export type WorkflowWireSleep = (stepName: string, duration: string) => Promise<
  * loops, like dynamic `do()` step names.
  */
 export type WorkflowWireSuspend = (reason: string) => Promise<void>;
+/**
+ * Type signature for workflow.milestone() - used by inspector.
+ */
+export type WorkflowWireMilestone = (name: string) => Promise<void>;
 /**
  * Who is allowed to answer an approval gate, relative to the user who started
  * the run.
@@ -436,6 +440,14 @@ export interface SuspendStepMeta {
     /** Reason string passed to workflow.suspend() — becomes the durable step key */
     reason: string;
 }
+/**
+ * Milestone step metadata (workflow.milestone())
+ */
+export interface MilestoneStepMeta {
+    type: 'milestone';
+    /** Name passed to workflow.milestone() — where a compensating run rests */
+    name: string;
+}
 /**
  * Approval step metadata (workflow.approval())
  */
@@ -485,7 +497,7 @@ export interface ArrayPredicateStepMeta {
 /**
  * Workflow step metadata (extracted by inspector)
  */
-export type WorkflowStepMeta = RpcStepMeta | ScenarioStepMeta | BranchStepMeta | ParallelGroupStepMeta | FanoutStepMeta | ReturnStepMeta | InlineStepMeta | SleepStepMeta | CancelStepMeta | SuspendStepMeta | ApprovalStepMeta | SwitchStepMeta | FilterStepMeta | ArrayPredicateStepMeta | SetStepMeta;
+export type WorkflowStepMeta = RpcStepMeta | ScenarioStepMeta | BranchStepMeta | ParallelGroupStepMeta | FanoutStepMeta | ReturnStepMeta | InlineStepMeta | SleepStepMeta | CancelStepMeta | SuspendStepMeta | MilestoneStepMeta | ApprovalStepMeta | SwitchStepMeta | FilterStepMeta | ArrayPredicateStepMeta | SetStepMeta;
 /**
  * Workflow step wire context for RPC functions
  * Provides step-level metadata including retry attempt tracking
@@ -520,7 +532,22 @@ export interface WorkflowStepWire {
  * Workflow wire object for DSL workflows
  * Provides workflow-specific capabilities to function execution
  */
+export type CompensatingFor<Out = unknown> = {
+    ok: true;
+    output: Out;
+    stepName?: string;
+} | {
+    ok: false;
+    output: null;
+    error: SerializedError;
+    stepName?: string;
+};
 export interface PikkuWorkflowWire {
+    /**
+     * Set only while a function's `compensate` is running: the outcome of the
+     * forward call being undone. `undefined` on a forward run.
+     */
+    compensatingFor?: CompensatingFor;
     /** The workflow name */
     name: string;
     /** The current run ID */
@@ -535,6 +562,11 @@ export interface PikkuWorkflowWire {
     sleep: WorkflowWireSleep;
     /** Suspend workflow until explicitly resumed */
     suspend: WorkflowWireSuspend;
+    /**
+     * A named checkpoint. On failure the unwind stops at the last milestone
+     * reached and the run rests there. The name must be a string literal.
+     */
+    milestone: WorkflowWireMilestone;
     /** Suspend workflow until a human records a decision against this gate */
     approval: WorkflowWireApproval;
 }

package/dist/wirings/workflow/graph/graph-node.d.ts

@@ -27,7 +27,8 @@ type GraphNodeConfigMap<FuncMap extends Record<string, string>, RPCMap extends R
         /** How the per-item instances run. Defaults to 'parallel'. */
         mode?: ForEachMode;
         input?: (ref: <N extends Extract<keyof FuncMap, string>, P extends keyof ComputeNodeOutputs<FuncMap, RPCMap>[N] & string>(nodeId: N, path: P) => TypedRef<ComputeNodeOutputs<FuncMap, RPCMap>[N][P]>, template: TemplateFn, $item: ItemFn) => InputWithRefs<ComputeNodeInputs<FuncMap, RPCMap>[K]>;
-        onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[];
+        recover?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[] | 'ignore';
+        compensate?: false;
         retries?: number;
         retryDelay?: string | number;
         notes?: string;

package/dist/wirings/workflow/graph/graph-node.js

@@ -20,7 +20,8 @@ export function createGraph() {
                 mode: def?.mode,
                 input: def?.input,
                 next: def?.next,
-                onError: def?.onError,
+                recover: def?.recover,
+                compensate: def?.compensate,
                 retries: def?.retries,
                 retryDelay: def?.retryDelay,
             };

package/dist/wirings/workflow/graph/graph-runner.d.ts

@@ -8,7 +8,7 @@ export declare class ChildWorkflowStartedException extends Error {
     constructor(parentRunId: string, stepId: string, childRunId: string);
 }
 export declare function stripInstanceOrdinal(name: string): string;
-export declare function continueGraph(workflowService: PikkuWorkflowService, runId: string, graphName: string, overrideMeta?: WorkflowRuntimeMeta): Promise<void>;
+export declare function continueGraph(workflowService: PikkuWorkflowService, runId: string, graphName: string, overrideMeta?: WorkflowRuntimeMeta, rpcService?: any): Promise<void>;
 export declare function executeGraphStep(workflowService: PikkuWorkflowService, rpcService: any, runId: string, stepId: string, nodeId: string, rpcName: string, data: any, graphName: string): Promise<any>;
 export declare function runFromMeta(workflowService: PikkuWorkflowService, runId: string, meta: WorkflowRuntimeMeta, _rpcService: any): Promise<void>;
 export declare function runWorkflowGraph(workflowService: PikkuWorkflowService, graphName: string, triggerInput: any, rpcService?: any, inline?: boolean, startNode?: string, wire?: WorkflowRunWire, overrideMeta?: WorkflowRuntimeMeta): Promise<{