@xyne/workflow-sdk 1.0.0

package/dist/runtime/workflow-runtime.js

@@ -0,0 +1,699 @@
+/**
+ * WorkflowRuntime — the central orchestrator.
+ *
+ * Ties together: persistence, queue, scheduler, executor, triggers, and steps.
+ * The host creates one runtime instance and uses it for all workflow operations:
+ *
+ * - Activate/deactivate triggers (cron, webhook)
+ * - Dispatch domain events → matching workflows
+ * - Handle incoming webhooks
+ * - Fire manual triggers
+ * - Resume paused executions
+ * - Process queued jobs (the worker loop body)
+ */
+import { ConfigValidator } from '../engine/config-validator.js';
+import { EventTrigger } from '../triggers/event-trigger.js';
+import { WebhookTrigger } from '../triggers/webhook-trigger.js';
+import { CronTrigger } from '../triggers/cron-trigger.js';
+import { PauseStep } from '../engine/pause-step.js';
+// ─── Helpers ───
+const noopLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+function generateSecret() {
+    const bytes = new Uint8Array(24);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+function parseWorkflowConfig(raw) {
+    return JSON.parse(raw ?? '{}');
+}
+/**
+ * Match a MIME type against an accept-list that supports wildcards.
+ * - "image/png"  matches exact "image/png"
+ * - "image/*"    matches anything under "image/"
+ * - "*"          matches anything
+ */
+function mimeAccepted(mime, accept) {
+    for (const a of accept) {
+        if (a === '*' || a === '*/*' || a === mime)
+            return true;
+        if (a.endsWith('/*')) {
+            const prefix = a.slice(0, -1); // "image/"
+            if (mime.startsWith(prefix))
+                return true;
+        }
+    }
+    return false;
+}
+// ─── WorkflowRuntime ───
+export class WorkflowRuntime {
+    persistence;
+    queue;
+    scheduler;
+    services;
+    steps;
+    triggers;
+    executor;
+    log;
+    baseUrl;
+    /** Event bus for real-time SSE streaming. Exposed for the router. */
+    eventBus;
+    /** Storage adapter for file attachments. Exposed for the router. */
+    storage;
+    /** When true, the upload route accepts executable MIME types / extensions. */
+    allowExecutableUploads;
+    /** IANA timezone applied to every cron-triggered workflow. */
+    defaultCronTimezone;
+    constructor(opts) {
+        this.persistence = opts.persistence;
+        this.queue = opts.queue;
+        this.scheduler = opts.scheduler;
+        this.services = opts.services;
+        this.steps = opts.steps;
+        this.triggers = opts.triggers;
+        this.executor = opts.executor;
+        this.log = opts.logger ?? noopLogger;
+        this.eventBus = opts.eventBus;
+        this.storage = opts.storage;
+        const config = opts.config ?? {};
+        this.baseUrl = config.baseUrl ?? '';
+        this.allowExecutableUploads = config.allowExecutableUploads ?? false;
+        this.defaultCronTimezone = config.defaultCronTimezone ?? 'Asia/Kolkata';
+    }
+    // ─── Validation ───
+    /**
+     * Validate a workflow config before saving.
+     *
+     * The host's save handler should call this and reject the save if
+     * `result.valid` is false. Returns structured issues the frontend
+     * can render inline in the workflow builder.
+     */
+    validateConfig(config) {
+        const validator = new ConfigValidator(this.triggers, this.steps);
+        return validator.validate(config);
+    }
+    // ─── Workflow Lifecycle ───
+    /**
+     * Activate a workflow's trigger.
+     *
+     * - WebhookTrigger: generates a unique path, stores it, calls onActivate()
+     * - CronTrigger: registers with the scheduler
+     * - EventTrigger / ManualTrigger: no activation needed (status change only)
+     */
+    async activateWorkflow(workflowId) {
+        const workflow = await this.persistence.getWorkflow(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow ${workflowId} not found`);
+        }
+        const config = parseWorkflowConfig(workflow.config);
+        if (!this.triggers.has(config.trigger.type)) {
+            throw new Error(`Trigger type "${config.trigger.type}" is not registered`);
+        }
+        const trigger = this.triggers.get(config.trigger.type);
+        if (trigger instanceof WebhookTrigger) {
+            const secret = generateSecret();
+            const path = `/webhooks/${workflowId}/${secret}`;
+            await this.persistence.storeWebhookPath(workflowId, path, secret);
+            if (trigger.onActivate) {
+                const credentials = await this.resolveCredentialsForTrigger(workflow);
+                await trigger.onActivate(config.trigger.config, {
+                    webhookUrl: this.baseUrl + path,
+                    credentials,
+                });
+            }
+            this.log.info(`activated webhook trigger for workflow ${workflowId}`);
+        }
+        else if (trigger instanceof CronTrigger) {
+            const { expression } = trigger.getSchedule(config.trigger.config);
+            await this.scheduler.schedule(workflowId, expression, this.defaultCronTimezone);
+            this.log.info(`activated cron trigger for workflow ${workflowId}: ${expression} (${this.defaultCronTimezone})`);
+        }
+        // EventTrigger and ManualTrigger require no activation
+    }
+    /**
+     * Deactivate a workflow's trigger.
+     */
+    async deactivateWorkflow(workflowId) {
+        const workflow = await this.persistence.getWorkflow(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow ${workflowId} not found`);
+        }
+        const config = parseWorkflowConfig(workflow.config);
+        if (!this.triggers.has(config.trigger.type))
+            return;
+        const trigger = this.triggers.get(config.trigger.type);
+        if (trigger instanceof WebhookTrigger) {
+            if (trigger.onDeactivate) {
+                const credentials = await this.resolveCredentialsForTrigger(workflow);
+                await trigger.onDeactivate(config.trigger.config, {
+                    webhookUrl: '',
+                    credentials,
+                });
+            }
+            await this.persistence.removeWebhookPath(workflowId);
+            this.log.info(`deactivated webhook trigger for workflow ${workflowId}`);
+        }
+        else if (trigger instanceof CronTrigger) {
+            await this.scheduler.unschedule(workflowId);
+            this.log.info(`deactivated cron trigger for workflow ${workflowId}`);
+        }
+    }
+    // ─── Workflow callback secret ───
+    /**
+     * Lazy-allocate the workflow's stable wait-callback secret. Idempotent —
+     * if a secret already exists, returns the existing record.
+     *
+     * Host calls this when saving a workflow that uses wait-step webhook
+     * mode, then surfaces the URL in the UI so the author can paste it into
+     * the external system's configuration.
+     */
+    async ensureWorkflowCallback(workflowId) {
+        const existing = await this.persistence.getWorkflowCallback(workflowId);
+        if (existing)
+            return existing;
+        const record = {
+            workflowId,
+            secret: generateSecret(),
+            createdAt: new Date(),
+        };
+        await this.persistence.storeWorkflowCallback(record);
+        return record;
+    }
+    /**
+     * Rotate the workflow's wait-callback secret. The old URL stops working
+     * immediately. Author has to update external configurations.
+     */
+    async rotateWorkflowCallback(workflowId) {
+        return this.persistence.rotateWorkflowCallback(workflowId, generateSecret());
+    }
+    /**
+     * Build the wait-callback URL template the author should paste into
+     * their external system. `{executionId}` is the placeholder the HTTP
+     * step substitutes via `{{ runtime.executionId }}`.
+     */
+    buildWaitCallbackUrl(secret, executionId) {
+        const base = `${this.baseUrl}/wait/callback/${secret}`;
+        return executionId ? `${base}/${executionId}` : `${base}/{executionId}`;
+    }
+    // ─── Trigger Firing ───
+    /**
+     * Dispatch a domain event. Finds all active workflows that match,
+     * hydrates payloads, applies filters, and enqueues executions.
+     *
+     * Returns the execution IDs that were created.
+     */
+    async dispatchEvent(event) {
+        const workflows = await this.persistence.findActiveWorkflows(event.type, event.metadata);
+        const executionIds = [];
+        for (const workflow of workflows) {
+            const config = parseWorkflowConfig(workflow.config);
+            if (!this.triggers.has(config.trigger.type))
+                continue;
+            const trigger = this.triggers.get(config.trigger.type);
+            if (!(trigger instanceof EventTrigger))
+                continue;
+            // Hydrate lightweight payload → full context
+            let payload = { ...event.payload };
+            if (trigger.hydratePayload) {
+                try {
+                    payload = await trigger.hydratePayload(payload);
+                }
+                catch (err) {
+                    this.log.warn(`dispatchEvent: hydratePayload failed for workflow ${workflow.id}: ${err instanceof Error ? err.message : String(err)}`);
+                    continue;
+                }
+            }
+            // Filter — does this event match this workflow's trigger config?
+            if (!trigger.matchFilters(config.trigger.config, payload)) {
+                continue;
+            }
+            const execId = await this.createAndEnqueue(workflow, {
+                type: event.type,
+                ...payload,
+            });
+            executionIds.push(execId);
+        }
+        return executionIds;
+    }
+    /**
+     * Handle an incoming webhook request.
+     *
+     * Looks up the workflow by webhook path, delegates to the trigger's
+     * `handleRequest()`, and enqueues an execution.
+     */
+    async handleWebhook(path, request) {
+        const webhookRecord = await this.persistence.getWebhookByPath(path);
+        if (!webhookRecord) {
+            return {
+                executionId: '',
+                httpResponse: { status: 404, body: { error: 'Webhook not found' } },
+            };
+        }
+        const workflow = await this.persistence.getWorkflow(webhookRecord.workflowId);
+        if (!workflow || workflow.status !== 'ACTIVE') {
+            return {
+                executionId: '',
+                httpResponse: { status: 404, body: { error: 'Workflow not active' } },
+            };
+        }
+        const config = parseWorkflowConfig(workflow.config);
+        const trigger = this.triggers.get(config.trigger.type);
+        if (!(trigger instanceof WebhookTrigger)) {
+            return {
+                executionId: '',
+                httpResponse: {
+                    status: 400,
+                    body: { error: 'Workflow does not use a webhook trigger' },
+                },
+            };
+        }
+        const { triggerData, httpResponse } = await trigger.handleRequest(request, config.trigger.config);
+        const execId = await this.createAndEnqueue(workflow, {
+            type: config.trigger.type,
+            ...triggerData,
+        });
+        return { executionId: execId, httpResponse };
+    }
+    /**
+     * Handle an incoming wait-callback at `POST /wait/callback/<secret>/<executionId>`.
+     *
+     * The `secret` is the workflow's stable callback secret (generated at
+     * workflow create). The `executionId` is the in-flight execution that
+     * paused on a wait-webhook step — the workflow's HTTP step interpolated
+     * it into the URL it gave the external system via
+     * `{{ runtime.executionId }}`.
+     *
+     * Validation:
+     * 1. Secret resolves to a workflow (404 on miss, same hash-map security
+     *    as trigger webhooks — wrong/unknown secrets are indistinguishable).
+     * 2. Execution exists, is EXTERNAL_WAIT, and belongs to that workflow
+     *    (404 otherwise; same 404 so attackers can't probe for valid
+     *    execution IDs by guessing).
+     *
+     * On success, the callback body becomes the resume payload and the
+     * execution is re-enqueued. The wait step's `onResume` sees it as
+     * `resumeData`.
+     */
+    async handleWaitCallback(secret, executionId, body) {
+        const callback = await this.persistence.getWorkflowCallbackBySecret(secret);
+        if (!callback) {
+            return { status: 404, body: { error: 'Wait callback not found' } };
+        }
+        const exec = await this.persistence.getExecution(executionId);
+        if (!exec ||
+            exec.workflowId !== callback.workflowId ||
+            exec.status !== 'EXTERNAL_WAIT') {
+            // Either the execution is wrong workflow, terminal, or unknown. Same
+            // 404 either way — don't leak which case.
+            return { status: 404, body: { error: 'Wait callback not found' } };
+        }
+        // Wrap the caller's body as a structured resume payload. Objects pass
+        // through; primitives get wrapped under `{ body }` so step code always
+        // sees a record.
+        const data = body && typeof body === 'object' && !Array.isArray(body)
+            ? body
+            : { body };
+        await this.resume(executionId, {
+            data: { action: 'approve', data },
+        });
+        return { status: 202, body: { received: true, executionId } };
+    }
+    /**
+     * Fire a workflow manually via API.
+     *
+     * `attachments` is validated against the trigger's `attachments` config
+     * (mime accept-list, maxCount, required). Validated refs are merged into
+     * the trigger payload as `context.trigger.attachments`.
+     *
+     * Returns the execution ID.
+     */
+    async triggerManual(workflowId, payload, attachments) {
+        const workflow = await this.persistence.getWorkflow(workflowId);
+        if (!workflow) {
+            throw new Error(`Workflow ${workflowId} not found`);
+        }
+        const config = parseWorkflowConfig(workflow.config);
+        const triggerCfg = (config.trigger.config ?? {});
+        const att = (triggerCfg['attachments'] ?? null);
+        if (att) {
+            const provided = attachments ?? [];
+            if (att.required && provided.length === 0) {
+                throw new Error('At least one attachment is required for this workflow');
+            }
+            if (att.maxCount !== undefined && provided.length > att.maxCount) {
+                throw new Error(`Too many attachments: ${String(provided.length)} > ${String(att.maxCount)}`);
+            }
+            for (const a of provided) {
+                if (att.accept && att.accept.length > 0 && !mimeAccepted(a.mimeType, att.accept)) {
+                    throw new Error(`Attachment "${a.name}" mime "${a.mimeType}" is not in accept list`);
+                }
+                if (att.maxSize !== undefined && a.size !== undefined && a.size > att.maxSize) {
+                    throw new Error(`Attachment "${a.name}" exceeds maxSize (${String(a.size)} > ${String(att.maxSize)})`);
+                }
+            }
+        }
+        else if (attachments && attachments.length > 0) {
+            // Workflow didn't declare an attachments slot — reject silently? Accept?
+            // We accept and pass through; the trigger schema simply doesn't constrain
+            // attachments. The host can choose to ignore them downstream.
+        }
+        const triggerPayload = {
+            type: config.trigger.type,
+            ...payload,
+        };
+        if (attachments && attachments.length > 0) {
+            triggerPayload['attachments'] = attachments;
+        }
+        return this.createAndEnqueue(workflow, triggerPayload);
+    }
+    /**
+     * Resume a paused execution.
+     *
+     * Stores the resume payload and re-enqueues the execution.
+     */
+    async resume(executionId, input) {
+        const exec = await this.persistence.getExecution(executionId);
+        if (!exec) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        if (exec.status !== 'EXTERNAL_WAIT') {
+            throw new Error(`Execution ${executionId} is not paused (status: ${exec.status})`);
+        }
+        // Unified abort: either the explicit `abort` flag OR `data.action === 'abort'`.
+        const isAbort = input?.abort === true || input?.data?.action === 'abort';
+        if (isAbort) {
+            await this.persistence.updateExecutionStatus(executionId, 'CANCELLED');
+            this.eventBus?.emit(executionId, { event: 'execution_cancelled', data: {} });
+            this.log.info(`execution ${executionId} aborted by user`);
+            return;
+        }
+        if (input?.data) {
+            await this.persistence.persistResumePayload(executionId, input.data);
+        }
+        // Keep status as EXTERNAL_WAIT — the executor detects this as a resume
+        // and reads the saved pause path to continue from the correct step.
+        await this.queue.enqueue({ executionId });
+        this.log.info(`execution ${executionId} resume enqueued`);
+    }
+    /**
+     * Rerun a workflow from a specific step, using the source execution's
+     * cached outputs for all prior steps. Creates a new execution.
+     *
+     * Used for:
+     * - "Rerun from step N" — replay downstream with same upstream data
+     * - "Modify input and rerun" — pass `configOverrides` to change the
+     *   entry step's input
+     * - Agent feedback after execution completed — pass `configOverrides`
+     *   with new `userMessage`; agent receives `priorState.messages` and
+     *   continues the conversation
+     *
+     * Returns the new execution ID.
+     */
+    async rerunFromStep(sourceExecutionId, fromStepId, options) {
+        const newExecutionId = await this.executor.rerunFromStep(sourceExecutionId, fromStepId, options);
+        await this.queue.enqueue({ executionId: newExecutionId });
+        return newExecutionId;
+    }
+    // ─── CRUD (used by router) ───
+    /**
+     * List all workflows visible to the given auth metadata.
+     */
+    async listWorkflows(metadata) {
+        return this.persistence.listWorkflows(metadata);
+    }
+    /**
+     * Get a single workflow by ID.
+     */
+    async getWorkflow(workflowId) {
+        return this.persistence.getWorkflow(workflowId);
+    }
+    /**
+     * Create a new workflow definition.
+     *
+     * Validates the config, persists it, and optionally activates the trigger.
+     * Returns the created WorkflowRecord.
+     */
+    async createWorkflow(input) {
+        const validation = this.validateConfig(input.config);
+        if (!validation.valid) {
+            throw new Error(`Invalid workflow config: ${validation.issues.map((i) => i.message).join('; ')}`);
+        }
+        const metadata = { ...input.metadata, name: input.name };
+        const id = await this.persistence.createWorkflow({
+            status: 'ACTIVE',
+            config: JSON.stringify(input.config),
+            metadata: JSON.stringify(metadata),
+            eventType: input.config.trigger.type,
+        });
+        const record = await this.persistence.getWorkflow(id);
+        if (!record)
+            throw new Error('Failed to read created workflow');
+        // Auto-activate the trigger
+        try {
+            await this.activateWorkflow(id);
+        }
+        catch {
+            // Non-fatal — workflow is created but trigger may need manual activation
+        }
+        this.log.info(`created workflow ${id} (${input.name})`);
+        return record;
+    }
+    /**
+     * Update an existing workflow definition.
+     *
+     * Accepts partial updates: config, metadata, or both.
+     * If config changes, validates it and updates the trigger type.
+     */
+    async updateWorkflow(workflowId, input) {
+        const existing = await this.persistence.getWorkflow(workflowId);
+        if (!existing) {
+            throw new Error(`Workflow ${workflowId} not found`);
+        }
+        const update = {};
+        // Update config if provided
+        if (input.config) {
+            const validation = this.validateConfig(input.config);
+            if (!validation.valid) {
+                throw new Error(`Invalid workflow config: ${validation.issues.map((i) => i.message).join('; ')}`);
+            }
+            update.config = JSON.stringify(input.config);
+            update.eventType = input.config.trigger.type;
+        }
+        // Update metadata if name or metadata provided
+        if (input.name !== undefined || input.metadata !== undefined) {
+            const existingMeta = JSON.parse(existing.metadata ?? '{}');
+            if (input.metadata)
+                Object.assign(existingMeta, input.metadata);
+            if (input.name !== undefined)
+                existingMeta['name'] = input.name;
+            update.metadata = JSON.stringify(existingMeta);
+        }
+        await this.persistence.updateWorkflow(workflowId, update);
+        const updated = await this.persistence.getWorkflow(workflowId);
+        if (!updated)
+            throw new Error('Failed to read updated workflow');
+        this.log.info(`updated workflow ${workflowId}`);
+        return updated;
+    }
+    /**
+     * List executions with optional filters and cursor pagination.
+     */
+    async listExecutions(params) {
+        return this.persistence.listExecutions(params);
+    }
+    /**
+     * Get execution detail including step records.
+     */
+    async getExecutionDetail(executionId) {
+        const exec = await this.persistence.getExecution(executionId);
+        if (!exec)
+            return null;
+        const stepRows = await this.persistence.getStepRows(executionId);
+        // Try to attach the workflow config snapshot
+        const result = { execution: exec, steps: stepRows };
+        const workflow = await this.persistence.getWorkflow(exec.workflowId);
+        if (workflow?.config) {
+            try {
+                result.config = JSON.parse(workflow.config);
+            }
+            catch {
+                // config is optional — skip if corrupt
+            }
+        }
+        // Extract trigger data from execution state context
+        try {
+            const state = await this.persistence.getExecutionState(executionId);
+            if (state?.context) {
+                const ctx = JSON.parse(state.context);
+                if (ctx.trigger) {
+                    result.triggerData = ctx.trigger;
+                }
+            }
+        }
+        catch {
+            // trigger data is optional — skip if missing or corrupt
+        }
+        return result;
+    }
+    /**
+     * Cancel a running or paused execution.
+     */
+    async cancelExecution(executionId) {
+        const exec = await this.persistence.getExecution(executionId);
+        if (!exec) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        if (exec.status === 'COMPLETED' || exec.status === 'FAILED' || exec.status === 'CANCELLED') {
+            throw new Error(`Execution ${executionId} is already terminal (status: ${exec.status})`);
+        }
+        await this.persistence.updateExecutionStatus(executionId, 'CANCELLED');
+        this.eventBus?.emit(executionId, { event: 'execution_cancelled', data: {} });
+        this.log.info(`execution ${executionId} cancelled`);
+    }
+    /**
+     * List credentials visible to the given auth metadata.
+     */
+    async listCredentials(metadata) {
+        return this.persistence.listCredentials(metadata);
+    }
+    /**
+     * Store a credential.
+     */
+    async createCredential(metadata, name, credential) {
+        await this.persistence.storeCredential(metadata, name, credential);
+        return { name, type: credential.type };
+    }
+    /**
+     * Delete a credential by name.
+     */
+    async deleteCredential(metadata, name) {
+        await this.persistence.deleteCredential(metadata, name);
+    }
+    // ─── Job Processing ───
+    /**
+     * The queue consumer body. The host's queue worker calls this for each job.
+     *
+     * ```ts
+     * workflowQueue.process((job) => runtime.processJob(job.data.executionId));
+     * ```
+     */
+    async processJob(executionId) {
+        const exec = await this.persistence.getExecution(executionId);
+        if (!exec)
+            return { status: 'not_found' };
+        if (!['PENDING', 'EXTERNAL_WAIT'].includes(exec.status)) {
+            return {
+                status: 'skipped',
+                reason: `execution status is ${exec.status}`,
+            };
+        }
+        try {
+            await this.executor.runExecution(executionId);
+            // Check final status after execution
+            const final = await this.persistence.getExecution(executionId);
+            if (!final)
+                return { status: 'not_found' };
+            if (final.status === 'EXTERNAL_WAIT') {
+                return { status: 'paused', reason: 'Step requested pause' };
+            }
+            if (final.status === 'COMPLETED') {
+                return { status: 'completed' };
+            }
+            if (final.status === 'FAILED') {
+                return { status: 'failed', error: 'Execution failed' };
+            }
+            if (final.status === 'SKIPPED') {
+                return { status: 'skipped', reason: 'Trigger filter mismatch' };
+            }
+            return { status: 'completed' };
+        }
+        catch (err) {
+            if (PauseStep.is(err)) {
+                // The executor already persisted the pause state
+                return { status: 'paused', reason: err.message };
+            }
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.log.error(`processJob ${executionId} failed: ${errMsg}`);
+            return { status: 'failed', error: errMsg };
+        }
+    }
+    /**
+     * Process a cron tick for a workflow.
+     *
+     * Called by the scheduler when a cron job fires. Checks poll() if available,
+     * otherwise fires unconditionally.
+     */
+    async processCronTick(workflowId) {
+        const workflow = await this.persistence.getWorkflow(workflowId);
+        if (!workflow || workflow.status !== 'ACTIVE')
+            return null;
+        const config = parseWorkflowConfig(workflow.config);
+        if (!this.triggers.has(config.trigger.type))
+            return null;
+        const trigger = this.triggers.get(config.trigger.type);
+        if (!(trigger instanceof CronTrigger))
+            return null;
+        const metadata = JSON.parse(workflow.metadata ?? '{}');
+        if (trigger.poll) {
+            const data = await trigger.poll(config.trigger.config, {
+                staticData: {
+                    get: (key) => this.persistence.getStaticData(workflowId, key),
+                    set: (key, value) => this.persistence.setStaticData(workflowId, key, value),
+                    delete: (key) => this.persistence.deleteStaticData(workflowId, key),
+                },
+                services: this.services,
+                metadata,
+            });
+            if (data === null)
+                return null; // nothing new, skip
+            return this.createAndEnqueue(workflow, {
+                type: config.trigger.type,
+                ...data,
+            });
+        }
+        // Pure cron — always fire
+        const payload = trigger.buildPayload
+            ? trigger.buildPayload(config.trigger.config)
+            : { firedAt: new Date().toISOString() };
+        return this.createAndEnqueue(workflow, {
+            type: config.trigger.type,
+            ...payload,
+        });
+    }
+    // ─── Internal ───
+    async createAndEnqueue(workflow, triggerPayload) {
+        const metadata = JSON.parse(workflow.metadata ?? '{}');
+        const initialContext = {
+            workflow: {
+                id: workflow.id,
+                metadata,
+            },
+            trigger: triggerPayload,
+            steps: {},
+        };
+        const execId = await this.persistence.createExecution({
+            workflowId: workflow.id,
+            status: 'PENDING',
+            context: JSON.stringify(initialContext),
+        });
+        await this.queue.enqueue({ executionId: execId });
+        this.log.info(`created execution ${execId} for workflow ${workflow.id}`);
+        return execId;
+    }
+    async resolveCredentialsForTrigger(workflow) {
+        const metadata = JSON.parse(workflow.metadata ?? '{}');
+        const creds = await this.persistence.listCredentials(metadata);
+        const resolved = {};
+        for (const cred of creds) {
+            const full = await this.persistence.resolveCredential(metadata, cred.name);
+            if (full) {
+                resolved[cred.name] = full;
+            }
+        }
+        return resolved;
+    }
+}
+//# sourceMappingURL=workflow-runtime.js.map