@blokjs/trigger-webhook 0.2.1 → 0.6.2

package/dist/WebhookTrigger.js

@@ -1,355 +1,354 @@
-"use strict";
 /**
- * WebhookTrigger - Handle webhook events from external services
+ * WebhookTrigger — v0.7 PR 4 — Inbound webhook trigger that mounts
+ * verified POST routes on the shared Hono app. One route per workflow
+ * whose `trigger.webhook` config is registered.
  *
- * Extends TriggerBase to process webhook events from:
- * - GitHub (push, pull_request, issues, etc.)
- * - Stripe (payment_intent, checkout.session, etc.)
- * - Shopify (orders, products, customers)
- * - Custom webhooks
+ * **Authoring surface (built-in provider):**
  *
- * Features:
- * - Signature verification for security
- * - Event type filtering
- * - Retry support
- * - Dead letter handling
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourceHandlers = exports.WebhookTrigger = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const runner_1 = require("@blok/runner");
-const api_1 = require("@opentelemetry/api");
-const uuid_1 = require("uuid");
-/**
- * Built-in source handlers
- */
-const sourceHandlers = {
-    github: {
-        getEventType: (headers) => headers["x-github-event"] || "unknown",
-        getSignature: (headers) => headers["x-hub-signature-256"] || headers["x-hub-signature"],
-        verifySignature: (rawBody, signature, secret) => {
-            const hmac = node_crypto_1.default.createHmac("sha256", secret);
-            const digest = `sha256=${hmac.update(rawBody).digest("hex")}`;
-            const sigBuffer = Buffer.from(signature);
-            const digestBuffer = Buffer.from(digest);
-            // Length check first to avoid timing attack on length
-            if (sigBuffer.length !== digestBuffer.length) {
-                return { valid: false, error: "Invalid GitHub signature" };
-            }
-            const valid = node_crypto_1.default.timingSafeEqual(sigBuffer, digestBuffer);
-            return { valid, error: valid ? undefined : "Invalid GitHub signature" };
-        },
-        getEventId: (headers) => headers["x-github-delivery"] || (0, uuid_1.v4)(),
-    },
-    stripe: {
-        getEventType: (_, body) => body?.type || "unknown",
-        getSignature: (headers) => headers["stripe-signature"],
-        verifySignature: (rawBody, signature, secret) => {
-            // Stripe signature format: t=timestamp,v1=signature
-            const parts = signature.split(",").reduce((acc, part) => {
-                const [key, value] = part.split("=");
-                acc[key] = value;
-                return acc;
-            }, {});
-            const timestamp = parts.t;
-            const expectedSig = parts.v1;
-            if (!timestamp || !expectedSig) {
-                return { valid: false, error: "Invalid Stripe signature format" };
-            }
-            const payload = `${timestamp}.${rawBody}`;
-            const hmac = node_crypto_1.default.createHmac("sha256", secret);
-            const computedSig = hmac.update(payload).digest("hex");
-            const sigBuffer = Buffer.from(expectedSig);
-            const computedBuffer = Buffer.from(computedSig);
-            if (sigBuffer.length !== computedBuffer.length) {
-                return { valid: false, error: "Invalid Stripe signature" };
-            }
-            const valid = node_crypto_1.default.timingSafeEqual(sigBuffer, computedBuffer);
-            return { valid, error: valid ? undefined : "Invalid Stripe signature" };
-        },
-        getEventId: (_, body) => body?.id || (0, uuid_1.v4)(),
-    },
-    shopify: {
-        getEventType: (headers) => headers["x-shopify-topic"] || "unknown",
-        getSignature: (headers) => headers["x-shopify-hmac-sha256"],
-        verifySignature: (rawBody, signature, secret) => {
-            const hmac = node_crypto_1.default.createHmac("sha256", secret);
-            const digest = hmac.update(rawBody, "utf8").digest("base64");
-            const sigBuffer = Buffer.from(signature, "base64");
-            const digestBuffer = Buffer.from(digest, "base64");
-            if (sigBuffer.length !== digestBuffer.length) {
-                return { valid: false, error: "Invalid Shopify signature" };
-            }
-            const valid = node_crypto_1.default.timingSafeEqual(sigBuffer, digestBuffer);
-            return { valid, error: valid ? undefined : "Invalid Shopify signature" };
-        },
-        getEventId: (headers) => headers["x-shopify-webhook-id"] || (0, uuid_1.v4)(),
-    },
-    custom: {
-        getEventType: (headers, body) => headers["x-event-type"] || body?.event || "custom",
-        getSignature: (headers) => headers["x-signature"] || headers["x-webhook-signature"],
-        verifySignature: (rawBody, signature, secret) => {
-            // Default: HMAC-SHA256
-            const hmac = node_crypto_1.default.createHmac("sha256", secret);
-            const digest = hmac.update(rawBody).digest("hex");
-            const valid = signature === digest || signature === `sha256=${digest}`;
-            return { valid, error: valid ? undefined : "Invalid signature" };
-        },
-        getEventId: (headers, body) => headers["x-event-id"] || body?.id || (0, uuid_1.v4)(),
-    },
-};
-exports.sourceHandlers = sourceHandlers;
-/**
- * WebhookTrigger - Handle webhook events
+ * ```json
+ * {
+ *   "name": "stripe-events",
+ *   "trigger": {
+ *     "webhook": {
+ *       "provider": "stripe",
+ *       "path": "/webhooks/stripe",
+ *       "secretEnv": "STRIPE_WEBHOOK_SECRET",
+ *       "namespace": "stripe",
+ *       "idempotencyKey": "js/ctx.request.body.id"
+ *     }
+ *   },
+ *   "steps": [
+ *     { "id": "dispatch", "subworkflow": "js/ctx.request.body.type", "inputs": { "stripeEvent": "js/ctx.request.body" } }
+ *   ]
+ * }
+ * ```
+ *
+ * **Pipeline (per inbound request):**
+ *
+ *   1. Read raw body — verifiers MUST sign the bytes that crossed
+ *      the wire, not the JSON-re-stringified body (Stripe / GitHub /
+ *      Slack all sign raw bytes).
+ *   2. Verify the signature via the per-provider strategy
+ *      (`verifiers.ts`). On failure, return 401 with structured
+ *      `{ error, reason, message }`.
+ *   3. Replay check: if `idempotencyKey` is configured, look up
+ *      `(workflowName, eventId)` in the idempotency cache (same store
+ *      as Tier 1 step caching). On hit, return 200 with
+ *      `{ status: "duplicate", eventId }` and DON'T run the workflow.
+ *   4. Events allowlist: if `events: [...]` is configured, skip
+ *      workflow runs whose event type isn't in the list — return
+ *      200 with `{ status: "ignored", eventType }` so the sender
+ *      doesn't retry.
+ *   5. Run the workflow through `TriggerBase.run` so middleware,
+ *      tracing, retries, concurrency, etc. apply uniformly.
+ *   6. Cache the eventId so a retry within the TTL window returns
+ *      the duplicate response.
+ *
+ * **Hono integration:** identical to WebSocket and SSE — accepts the
+ * shared `Hono<any, any, any>` app and an optional `HttpTriggerLike`
+ * exposing `addPreCatchAllHook` so webhook routes mount BEFORE the
+ * legacy `/:workflow{.+}` catch-all and win Hono's first-match
+ * dispatch.
+ *
+ * See [additional-triggers-plan.mdx](../../../docs/c/devtools/additional-triggers-plan.mdx#webhook-trigger)
+ * for the full v0.7 design.
  */
-class WebhookTrigger extends runner_1.TriggerBase {
+import { DefaultLogger, RunTracker, TriggerBase, WorkflowRegistry, } from "@blokjs/runner";
+import { SpanStatusCode, metrics, trace } from "@opentelemetry/api";
+import { v4 as uuid } from "uuid";
+import { BUILTIN_VERIFIERS, buildCustomVerifier } from "./verifiers";
+const DEFAULT_TOLERANCE_SEC = 300;
+const DEFAULT_REPLAY_TTL_MS = 5 * 60 * 1000; // 5 min — match Stripe / Svix default.
+const REPLAY_NAMESPACE = "__webhook__";
+// -----------------------------------------------------------------------------
+// Trigger class
+// -----------------------------------------------------------------------------
+export default class WebhookTrigger extends TriggerBase {
     nodeMap = {};
-    tracer = api_1.trace.getTracer(process.env.PROJECT_NAME || "trigger-webhook-workflow", process.env.PROJECT_VERSION || "0.0.1");
-    logger = new runner_1.DefaultLogger();
-    webhookWorkflows = [];
-    constructor() {
+    logger = new DefaultLogger();
+    tracer = trace.getTracer(process.env.PROJECT_NAME || "trigger-webhook-workflow", process.env.PROJECT_VERSION || "0.0.1");
+    meter = metrics.getMeter("blok");
+    counterReceived = this.meter.createCounter("blok_webhook_received_total", {
+        description: "Webhook deliveries received (cumulative).",
+        unit: "1",
+    });
+    counterRejected = this.meter.createCounter("blok_webhook_rejected_total", {
+        description: "Webhook deliveries rejected (signature failure, allowlist miss, replay).",
+        unit: "1",
+    });
+    counterAccepted = this.meter.createCounter("blok_webhook_accepted_total", {
+        description: "Webhook deliveries that triggered a workflow run.",
+        unit: "1",
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: Hono's generic propagation
+    app;
+    httpTrigger;
+    wired = false;
+    // biome-ignore lint/suspicious/noExplicitAny: matches `app` field's any generic
+    constructor(app, httpTrigger) {
         super();
-        this.loadNodes();
-        this.loadWorkflows();
-    }
-    /**
-     * Load nodes into the node map
-     */
-    loadNodes() {
-        this.nodeMap.nodes = new runner_1.NodeMap();
-        const nodeKeys = Object.keys(this.nodes);
-        for (const key of nodeKeys) {
-            this.nodeMap.nodes.addNode(key, this.nodes[key]);
-        }
+        this.app = app;
+        this.httpTrigger = httpTrigger ?? null;
+        _setActiveWebhookTrigger(this);
     }
     /**
-     * Load workflows into the workflow map
+     * Inject the runner's GlobalOptions (nodes + workflows). Called by
+     * the orchestrator AFTER constructing the trigger but BEFORE
+     * `listen()`. Shares HttpTrigger's nodeMap so per-request workflow
+     * runs resolve helpers + sub-workflows through the same registry.
      */
-    loadWorkflows() {
-        this.nodeMap.workflows = this.workflows;
+    setNodeMap(nodeMap) {
+        this.nodeMap = nodeMap;
     }
-    /**
-     * Initialize webhook trigger (call after loading workflows)
-     */
     async listen() {
         const startTime = this.startCounter();
-        // Find all workflows with webhook triggers
-        this.webhookWorkflows = this.getWebhookWorkflows();
-        if (this.webhookWorkflows.length === 0) {
-            this.logger.log("No workflows with webhook triggers found");
+        if (this.wired) {
+            this.logger.log("[blok][webhook] listen() called twice; ignoring");
+            return this.endCounter(startTime);
         }
-        else {
-            this.logger.log(`Webhook trigger initialized. ${this.webhookWorkflows.length} workflow(s) registered`);
+        this.wired = true;
+        if (this.httpTrigger) {
+            this.httpTrigger.addPreCatchAllHook(() => {
+                this.registerRoutesFromRegistry();
+            });
         }
-        // Enable HMR in development mode
-        if (process.env.BLOK_HMR === "true" || process.env.NODE_ENV === "development") {
-            await this.enableHotReload();
+        else {
+            this.registerRoutesFromRegistry();
         }
         return this.endCounter(startTime);
     }
-    /**
-     * Stop the webhook trigger
-     */
     async stop() {
-        this.webhookWorkflows = [];
-        this.logger.log("Webhook trigger stopped");
+        this.wired = false;
+        if (_getActiveWebhookTrigger() === this)
+            _setActiveWebhookTrigger(null);
+        this.destroyMonitoring();
+        this.logger.log("[blok][webhook] stopped");
     }
-    async onHmrWorkflowChange() {
-        this.loadWorkflows();
-        this.webhookWorkflows = this.getWebhookWorkflows();
-        this.logger.log(`[HMR] Webhook workflows reloaded. ${this.webhookWorkflows.length} workflow(s) registered`);
+    // ---------------------------------------------------------------------------
+    // Route registration
+    // ---------------------------------------------------------------------------
+    registerRoutesFromRegistry() {
+        const workflows = this.getWebhookWorkflows();
+        if (workflows.length === 0) {
+            this.logger.log("[blok][webhook] no workflows with trigger.webhook found");
+            return;
+        }
+        this.logger.log(`[blok][webhook] registering ${workflows.length} webhook route(s):`);
+        for (const entry of workflows) {
+            this.registerWebhookRoute(entry);
+        }
     }
-    /**
-     * Process an incoming webhook request
-     * Call this from your HTTP endpoint handler
-     */
-    async handleWebhook(source, rawBody, headers) {
-        const handler = sourceHandlers[source] || sourceHandlers.custom;
-        // Parse body
-        let body;
-        try {
-            body = JSON.parse(rawBody);
+    registerWebhookRoute(entry) {
+        const { workflowName, config } = entry;
+        const path = config.path ?? (config.provider ? `/webhooks/${config.provider}` : `/webhooks/${workflowName}`);
+        const label = config.provider ?? "custom";
+        this.logger.log(`[blok][webhook]   POST    ${path}  ←  ${workflowName}  (${label})`);
+        this.app.post(path, (c) => this.handleRequest(c, workflowName, path, config));
+    }
+    async handleRequest(c, workflowName, path, config) {
+        this.counterReceived.add(1, { workflow_name: workflowName });
+        // 1. Capture raw body BEFORE parsing — verifiers sign the wire bytes.
+        const rawBody = await c.req.text();
+        let parsedBody = {};
+        if (rawBody.length > 0) {
+            try {
+                parsedBody = JSON.parse(rawBody);
+            }
+            catch {
+                // Non-JSON body — leave parsed as the raw text. Slack
+                // challenges & Shopify can post non-JSON occasionally.
+                parsedBody = rawBody;
+            }
         }
-        catch {
-            body = rawBody;
+        const headers = Object.fromEntries(c.req.raw.headers);
+        const pathParams = c.req.param();
+        const queryParams = Object.fromEntries(new URL(c.req.url).searchParams);
+        // 2. Pick the verifier.
+        const verifier = this.resolveVerifier(workflowName, config);
+        if (!verifier) {
+            this.counterRejected.add(1, { workflow_name: workflowName, reason: "no_verifier" });
+            return c.json({ error: "Configuration", reason: "no_verifier", message: "No verifier configured" }, 500);
         }
-        // Create webhook event
-        const event = {
-            id: handler.getEventId(headers, body),
-            source,
-            eventType: handler.getEventType(headers, body),
-            payload: body,
+        // 3. Resolve the secret from the env var.
+        const secretEnv = config.secretEnv ?? config.signature?.secretEnv;
+        const secret = secretEnv ? (process.env[secretEnv] ?? "") : "";
+        // 4. Verify.
+        const toleranceSec = config.tolerance ?? config.signature?.tolerance ?? DEFAULT_TOLERANCE_SEC;
+        const result = verifier.verify({
             headers,
-            signature: handler.getSignature(headers),
-            timestamp: new Date(),
             rawBody,
-        };
-        // Find matching workflow
-        const workflow = this.findMatchingWorkflow(event);
-        if (!workflow) {
-            this.logger.log(`No matching workflow for webhook: ${source}/${event.eventType}`);
-            return null;
+            parsedBody,
+            secret,
+            toleranceSec,
+        });
+        if (!result.ok) {
+            this.counterRejected.add(1, { workflow_name: workflowName, reason: result.reason });
+            this.logger.error(`[blok][webhook] ${workflowName}: verify failed reason=${result.reason} message="${result.message}"`);
+            return c.json({ error: "Unauthorized", reason: result.reason, message: result.message }, 401);
+        }
+        // 5. Events allowlist — verified-but-out-of-scope returns 200 (no retry).
+        if (Array.isArray(config.events) && config.events.length > 0 && !config.events.includes(result.eventType)) {
+            this.counterRejected.add(1, { workflow_name: workflowName, reason: "event_not_allowed" });
+            return c.json({ status: "ignored", reason: "event_not_allowed", eventType: result.eventType }, 200);
         }
-        const config = workflow.config.trigger?.webhook;
-        // Verify signature if secret is configured
-        if (config.secret && event.signature) {
-            const verification = handler.verifySignature(rawBody, event.signature, config.secret);
-            if (!verification.valid) {
-                this.logger.error(`Webhook signature verification failed: ${verification.error}`);
-                throw new Error(`Signature verification failed: ${verification.error}`);
+        // 6. Replay protection via the idempotency cache.
+        if (config.idempotencyKey && result.eventId) {
+            const tracker = RunTracker.getInstance();
+            const store = tracker.getStore();
+            const cached = store.getIdempotencyCache(REPLAY_NAMESPACE, workflowName, result.eventId);
+            if (cached) {
+                this.counterRejected.add(1, { workflow_name: workflowName, reason: "replay" });
+                return c.json({
+                    status: "duplicate",
+                    eventId: result.eventId,
+                    eventType: result.eventType,
+                    firstSeenRunId: cached.sourceRunId,
+                }, 200);
             }
         }
-        else if (config.secret && !event.signature) {
-            this.logger.error("Webhook signature missing but secret is configured");
-            throw new Error("Signature missing");
+        // 7. Verified + new event — dispatch the workflow.
+        this.counterAccepted.add(1, { workflow_name: workflowName });
+        const requestId = uuid();
+        const dispatchOutcome = await this.dispatchWorkflow({
+            workflowName,
+            path,
+            config,
+            requestId,
+            headers,
+            body: parsedBody,
+            rawBody,
+            pathParams,
+            queryParams,
+            eventId: result.eventId,
+            eventType: result.eventType,
+        });
+        // 8. Cache event id AFTER successful dispatch so retries on the
+        //    same delivery are deduped. We cache even on workflow failure
+        //    — webhook senders should not retry deliveries they've
+        //    already delivered (the workflow's own retry / DLQ owns that).
+        if (config.idempotencyKey && result.eventId) {
+            const tracker = RunTracker.getInstance();
+            const store = tracker.getStore();
+            store.setIdempotencyCache(REPLAY_NAMESPACE, workflowName, result.eventId, {
+                data: { eventId: result.eventId, eventType: result.eventType },
+                cachedAt: Date.now(),
+                expiresAt: Date.now() + DEFAULT_REPLAY_TTL_MS,
+                sourceRunId: requestId,
+                sourceNodeRunId: requestId,
+            });
         }
-        return this.executeWorkflow(event, workflow, config);
+        // 9. Shape the response. Workflow's `ctx.response` lands in the
+        //    body for parity with HTTP triggers.
+        return c.json({
+            status: "ok",
+            eventId: result.eventId,
+            eventType: result.eventType,
+            runId: requestId,
+            response: dispatchOutcome,
+        }, 200);
     }
-    /**
-     * Get all workflows that have webhook triggers
-     */
-    getWebhookWorkflows() {
-        const workflows = [];
-        for (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {
-            const workflowConfig = workflow._config;
-            if (workflowConfig?.trigger) {
-                const triggerType = Object.keys(workflowConfig.trigger)[0];
-                if (triggerType === "webhook" && workflowConfig.trigger.webhook) {
-                    workflows.push({
-                        path,
-                        config: workflowConfig,
-                    });
-                }
+    resolveVerifier(workflowName, config) {
+        if (config.provider) {
+            const v = BUILTIN_VERIFIERS[config.provider];
+            if (!v) {
+                this.logger.error(`[blok][webhook] ${workflowName}: unknown provider "${config.provider}"`);
+                return null;
             }
+            return v;
         }
-        return workflows;
-    }
-    /**
-     * Find workflow matching the webhook event
-     */
-    findMatchingWorkflow(event) {
-        for (const workflow of this.webhookWorkflows) {
-            const config = workflow.config.trigger?.webhook;
-            if (!config)
-                continue;
-            // Check source match
-            if (config.source !== event.source)
-                continue;
-            // Check event type match
-            if (config.events && config.events.length > 0) {
-                const matches = config.events.some((pattern) => {
-                    // Support wildcards (e.g., "push", "pull_request.*")
-                    if (pattern === "*")
-                        return true;
-                    if (pattern.endsWith(".*")) {
-                        const prefix = pattern.slice(0, -2);
-                        return event.eventType.startsWith(prefix);
-                    }
-                    return pattern === event.eventType;
-                });
-                if (!matches)
-                    continue;
-            }
-            return workflow;
+        if (config.signature) {
+            return buildCustomVerifier({
+                scheme: config.signature.scheme ?? "hmac-sha256",
+                header: config.signature.header,
+                format: config.signature.format ?? "{hex}",
+                secretEnv: config.signature.secretEnv,
+                tolerance: config.signature.tolerance ?? DEFAULT_TOLERANCE_SEC,
+                timestampHeader: config.signature.timestampHeader,
+            });
         }
         return null;
     }
-    /**
-     * Execute a workflow for a webhook event
-     */
-    async executeWorkflow(event, workflow, _config) {
-        const executionId = (0, uuid_1.v4)();
-        const defaultMeter = api_1.metrics.getMeter("default");
-        const webhookExecutions = defaultMeter.createCounter("webhook_executions", {
-            description: "Webhook executions",
-        });
-        const webhookErrors = defaultMeter.createCounter("webhook_errors", {
-            description: "Webhook execution errors",
-        });
-        return new Promise((resolve) => {
-            this.tracer.startActiveSpan(`webhook:${event.source}/${event.eventType}`, async (span) => {
-                try {
-                    const start = performance.now();
-                    // Initialize configuration for this workflow
-                    await this.configuration.init(workflow.path, this.nodeMap);
-                    // Create context
-                    const ctx = this.createContext(undefined, workflow.path, executionId);
-                    // Populate request with webhook event
-                    ctx.request = {
-                        body: event.payload,
-                        headers: event.headers,
-                        query: {},
-                        params: {
-                            source: event.source,
-                            eventType: event.eventType,
-                            eventId: event.id,
-                        },
-                    };
-                    // Store webhook context in vars
-                    if (!ctx.vars)
-                        ctx.vars = {};
-                    ctx.vars._webhook_event = {
-                        id: event.id,
-                        source: event.source,
-                        eventType: event.eventType,
-                        timestamp: event.timestamp.toISOString(),
-                        hasSignature: String(!!event.signature),
-                    };
-                    ctx.logger.log(`Processing webhook: ${event.source}/${event.eventType} (${event.id})`);
-                    // Execute workflow
-                    const response = await this.run(ctx);
-                    const end = performance.now();
-                    // Set span attributes
-                    span.setAttribute("success", true);
-                    span.setAttribute("event_id", event.id);
-                    span.setAttribute("source", event.source);
-                    span.setAttribute("event_type", event.eventType);
-                    span.setAttribute("workflow_path", workflow.path);
-                    span.setAttribute("elapsed_ms", end - start);
-                    span.setStatus({ code: api_1.SpanStatusCode.OK });
-                    // Record metrics
-                    webhookExecutions.add(1, {
-                        env: process.env.NODE_ENV,
-                        source: event.source,
-                        event_type: event.eventType,
-                        workflow_name: this.configuration.name,
-                        success: "true",
-                    });
-                    ctx.logger.log(`Webhook processed in ${(end - start).toFixed(2)}ms: ${event.id}`);
-                    resolve(response);
+    // ---------------------------------------------------------------------------
+    // Workflow dispatch
+    // ---------------------------------------------------------------------------
+    async dispatchWorkflow(opts) {
+        const { workflowName, requestId, headers, body, rawBody, pathParams, queryParams, eventId, eventType } = opts;
+        return this.tracer.startActiveSpan(`webhook:${workflowName}`, async (span) => {
+            try {
+                const registry = WorkflowRegistry.getInstance();
+                const entry = registry.get(workflowName);
+                if (!entry) {
+                    throw new Error(`[blok][webhook] workflow "${workflowName}" not found in registry`);
                 }
-                catch (error) {
-                    const errorMessage = error.message;
-                    // Set span error
-                    span.setAttribute("success", false);
-                    span.recordException(error);
-                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: errorMessage });
-                    // Record error metrics
-                    webhookErrors.add(1, {
-                        env: process.env.NODE_ENV,
-                        source: event.source,
-                        event_type: event.eventType,
-                        workflow_name: this.configuration?.name || "unknown",
-                    });
-                    this.logger.error(`Webhook failed ${event.id}: ${errorMessage}`, error.stack);
-                    throw error;
-                }
-                finally {
-                    span.end();
-                }
-            });
+                await this.configuration.init(workflowName, this.nodeMap, entry.workflow);
+                const ctx = this.createContext(undefined, workflowName, requestId);
+                ctx.request = {
+                    body,
+                    rawBody,
+                    headers,
+                    params: pathParams,
+                    query: queryParams,
+                };
+                // Stamp webhook metadata onto ctx so polymorphic dispatch
+                // can read namespace + event metadata uniformly.
+                ctx._webhook = {
+                    eventId,
+                    eventType,
+                    namespace: opts.config.namespace,
+                };
+                await this.applyMiddlewareChain(ctx, this.nodeMap);
+                await this.run(ctx);
+                span.setAttribute("workflow_name", workflowName);
+                span.setAttribute("event_id", eventId);
+                span.setAttribute("event_type", eventType);
+                span.setStatus({ code: SpanStatusCode.OK });
+                return ctx.response;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                span.recordException(err);
+                span.setStatus({ code: SpanStatusCode.ERROR, message: msg });
+                this.logger.error(`[blok][webhook] workflow ${workflowName} failed: ${msg}`);
+                return { error: msg };
+            }
+            finally {
+                span.end();
+            }
         });
     }
-    /**
-     * Register a custom source handler
-     */
-    static registerSourceHandler(source, handler) {
-        sourceHandlers[source] = handler;
+    // ---------------------------------------------------------------------------
+    // Introspection
+    // ---------------------------------------------------------------------------
+    getStats() {
+        return { workflowsRegistered: this.getWebhookWorkflows().length };
     }
+    getWebhookWorkflows() {
+        const registry = WorkflowRegistry.getInstance();
+        const out = [];
+        for (const entry of registry.list()) {
+            const wf = entry.workflow;
+            const cfg = wf?.trigger?.webhook;
+            if (!cfg)
+                continue;
+            // Skip configs missing both provider AND signature — they can't
+            // verify anything. Authors get a structured error at boot.
+            if (!cfg.provider && !cfg.signature) {
+                this.logger.error(`[blok][webhook] workflow "${entry.name}" has trigger.webhook with neither \`provider\` nor \`signature\` — skipping. Add one to enable signature verification.`);
+                continue;
+            }
+            out.push({ workflowName: entry.name, config: cfg });
+        }
+        return out;
+    }
+}
+// -----------------------------------------------------------------------------
+// Singleton accessor (mirrors WS / SSE)
+// -----------------------------------------------------------------------------
+let activeTrigger = null;
+export function _setActiveWebhookTrigger(trigger) {
+    activeTrigger = trigger;
+}
+export function _getActiveWebhookTrigger() {
+    return activeTrigger;
 }
-exports.WebhookTrigger = WebhookTrigger;
-exports.default = WebhookTrigger;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WebhookTrigger.js","sourceRoot":"","sources":["../src/WebhookTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WebhookTrigger - Handle webhook events from external services\n *\n * Extends TriggerBase to process webhook events from:\n * - GitHub (push, pull_request, issues, etc.)\n * - Stripe (payment_intent, checkout.session, etc.)\n * - Shopify (orders, products, customers)\n * - Custom webhooks\n *\n * Features:\n * - Signature verification for security\n * - Event type filtering\n * - Retry support\n * - Dead letter handling\n */\n\nimport crypto from \"node:crypto\";\nimport type { HelperResponse, WebhookTriggerOpts } from \"@blok/helper\";\nimport {\n\tDefaultLogger,\n\ttype GlobalOptions,\n\ttype BlokService,\n\tNodeMap,\n\tTriggerBase,\n\ttype TriggerResponse,\n} from \"@blok/runner\";\nimport type { Context, RequestContext } from \"@blok/shared\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport { v4 as uuid } from \"uuid\";\n\n/**\n * Webhook event structure\n */\nexport interface WebhookEvent {\n\t/** Unique event ID */\n\tid: string;\n\t/** Source service (github, stripe, shopify, custom) */\n\tsource: string;\n\t/** Event type (e.g., push, payment_intent.succeeded) */\n\teventType: string;\n\t/** Event payload */\n\tpayload: unknown;\n\t/** Request headers */\n\theaders: Record<string, string>;\n\t/** Signature (if provided) */\n\tsignature?: string;\n\t/** Timestamp */\n\ttimestamp: Date;\n\t/** Raw request body */\n\trawBody: string;\n}\n\n/**\n * Signature verification result\n */\nexport interface VerificationResult {\n\tvalid: boolean;\n\terror?: string;\n}\n\n/**\n * Webhook source handlers\n */\nexport interface WebhookSourceHandler {\n\t/** Extract event type from request */\n\tgetEventType(headers: Record<string, string>, body: unknown): string;\n\t/** Get signature from request */\n\tgetSignature(headers: Record<string, string>): string | undefined;\n\t/** Verify signature */\n\tverifySignature(rawBody: string, signature: string, secret: string): VerificationResult;\n\t/** Get event ID */\n\tgetEventId(headers: Record<string, string>, body: unknown): string;\n}\n\n/**\n * Workflow model with webhook trigger configuration\n */\ninterface WebhookWorkflowModel {\n\tpath: string;\n\tconfig: {\n\t\tname: string;\n\t\tversion: string;\n\t\ttrigger?: {\n\t\t\twebhook?: WebhookTriggerOpts;\n\t\t\t[key: string]: unknown;\n\t\t};\n\t\t[key: string]: unknown;\n\t};\n}\n\n/**\n * Built-in source handlers\n */\nconst sourceHandlers: Record<string, WebhookSourceHandler> = {\n\tgithub: {\n\t\tgetEventType: (headers) => headers[\"x-github-event\"] || \"unknown\",\n\t\tgetSignature: (headers) => headers[\"x-hub-signature-256\"] || headers[\"x-hub-signature\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst digest = `sha256=${hmac.update(rawBody).digest(\"hex\")}`;\n\t\t\tconst sigBuffer = Buffer.from(signature);\n\t\t\tconst digestBuffer = Buffer.from(digest);\n\t\t\t// Length check first to avoid timing attack on length\n\t\t\tif (sigBuffer.length !== digestBuffer.length) {\n\t\t\t\treturn { valid: false, error: \"Invalid GitHub signature\" };\n\t\t\t}\n\t\t\tconst valid = crypto.timingSafeEqual(sigBuffer, digestBuffer);\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid GitHub signature\" };\n\t\t},\n\t\tgetEventId: (headers) => headers[\"x-github-delivery\"] || uuid(),\n\t},\n\n\tstripe: {\n\t\tgetEventType: (_, body) => (body as { type?: string })?.type || \"unknown\",\n\t\tgetSignature: (headers) => headers[\"stripe-signature\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\t// Stripe signature format: t=timestamp,v1=signature\n\t\t\tconst parts = signature.split(\",\").reduce(\n\t\t\t\t(acc, part) => {\n\t\t\t\t\tconst [key, value] = part.split(\"=\");\n\t\t\t\t\tacc[key] = value;\n\t\t\t\t\treturn acc;\n\t\t\t\t},\n\t\t\t\t{} as Record<string, string>,\n\t\t\t);\n\n\t\t\tconst timestamp = parts.t;\n\t\t\tconst expectedSig = parts.v1;\n\n\t\t\tif (!timestamp || !expectedSig) {\n\t\t\t\treturn { valid: false, error: \"Invalid Stripe signature format\" };\n\t\t\t}\n\n\t\t\tconst payload = `${timestamp}.${rawBody}`;\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst computedSig = hmac.update(payload).digest(\"hex\");\n\n\t\t\tconst sigBuffer = Buffer.from(expectedSig);\n\t\t\tconst computedBuffer = Buffer.from(computedSig);\n\t\t\tif (sigBuffer.length !== computedBuffer.length) {\n\t\t\t\treturn { valid: false, error: \"Invalid Stripe signature\" };\n\t\t\t}\n\t\t\tconst valid = crypto.timingSafeEqual(sigBuffer, computedBuffer);\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid Stripe signature\" };\n\t\t},\n\t\tgetEventId: (_, body) => (body as { id?: string })?.id || uuid(),\n\t},\n\n\tshopify: {\n\t\tgetEventType: (headers) => headers[\"x-shopify-topic\"] || \"unknown\",\n\t\tgetSignature: (headers) => headers[\"x-shopify-hmac-sha256\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst digest = hmac.update(rawBody, \"utf8\").digest(\"base64\");\n\t\t\tconst sigBuffer = Buffer.from(signature, \"base64\");\n\t\t\tconst digestBuffer = Buffer.from(digest, \"base64\");\n\t\t\tif (sigBuffer.length !== digestBuffer.length) {\n\t\t\t\treturn { valid: false, error: \"Invalid Shopify signature\" };\n\t\t\t}\n\t\t\tconst valid = crypto.timingSafeEqual(sigBuffer, digestBuffer);\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid Shopify signature\" };\n\t\t},\n\t\tgetEventId: (headers) => headers[\"x-shopify-webhook-id\"] || uuid(),\n\t},\n\n\tcustom: {\n\t\tgetEventType: (headers, body) => headers[\"x-event-type\"] || (body as { event?: string })?.event || \"custom\",\n\t\tgetSignature: (headers) => headers[\"x-signature\"] || headers[\"x-webhook-signature\"],\n\t\tverifySignature: (rawBody, signature, secret) => {\n\t\t\t// Default: HMAC-SHA256\n\t\t\tconst hmac = crypto.createHmac(\"sha256\", secret);\n\t\t\tconst digest = hmac.update(rawBody).digest(\"hex\");\n\t\t\tconst valid = signature === digest || signature === `sha256=${digest}`;\n\t\t\treturn { valid, error: valid ? undefined : \"Invalid signature\" };\n\t\t},\n\t\tgetEventId: (headers, body) => headers[\"x-event-id\"] || (body as { id?: string })?.id || uuid(),\n\t},\n};\n\n/**\n * WebhookTrigger - Handle webhook events\n */\nexport abstract class WebhookTrigger extends TriggerBase {\n\tprotected nodeMap: GlobalOptions = {} as GlobalOptions;\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-webhook-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\tprotected readonly logger = new DefaultLogger();\n\tprotected webhookWorkflows: WebhookWorkflowModel[] = [];\n\n\t// Subclasses provide these\n\tprotected abstract nodes: Record<string, BlokService<unknown>>;\n\tprotected abstract workflows: Record<string, HelperResponse>;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis.loadNodes();\n\t\tthis.loadWorkflows();\n\t}\n\n\t/**\n\t * Load nodes into the node map\n\t */\n\tloadNodes(): void {\n\t\tthis.nodeMap.nodes = new NodeMap();\n\t\tconst nodeKeys = Object.keys(this.nodes);\n\t\tfor (const key of nodeKeys) {\n\t\t\tthis.nodeMap.nodes.addNode(key, this.nodes[key]);\n\t\t}\n\t}\n\n\t/**\n\t * Load workflows into the workflow map\n\t */\n\tloadWorkflows(): void {\n\t\tthis.nodeMap.workflows = this.workflows;\n\t}\n\n\t/**\n\t * Initialize webhook trigger (call after loading workflows)\n\t */\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\n\t\t// Find all workflows with webhook triggers\n\t\tthis.webhookWorkflows = this.getWebhookWorkflows();\n\n\t\tif (this.webhookWorkflows.length === 0) {\n\t\t\tthis.logger.log(\"No workflows with webhook triggers found\");\n\t\t} else {\n\t\t\tthis.logger.log(`Webhook trigger initialized. ${this.webhookWorkflows.length} workflow(s) registered`);\n\t\t}\n\n\t\t// Enable HMR in development mode\n\t\tif (process.env.BLOK_HMR === \"true\" || process.env.NODE_ENV === \"development\") {\n\t\t\tawait this.enableHotReload();\n\t\t}\n\n\t\treturn this.endCounter(startTime);\n\t}\n\n\t/**\n\t * Stop the webhook trigger\n\t */\n\tasync stop(): Promise<void> {\n\t\tthis.webhookWorkflows = [];\n\t\tthis.logger.log(\"Webhook trigger stopped\");\n\t}\n\n\tprotected override async onHmrWorkflowChange(): Promise<void> {\n\t\tthis.loadWorkflows();\n\t\tthis.webhookWorkflows = this.getWebhookWorkflows();\n\t\tthis.logger.log(`[HMR] Webhook workflows reloaded. ${this.webhookWorkflows.length} workflow(s) registered`);\n\t}\n\n\t/**\n\t * Process an incoming webhook request\n\t * Call this from your HTTP endpoint handler\n\t */\n\tasync handleWebhook(\n\t\tsource: string,\n\t\trawBody: string,\n\t\theaders: Record<string, string>,\n\t): Promise<TriggerResponse | null> {\n\t\tconst handler = sourceHandlers[source] || sourceHandlers.custom;\n\n\t\t// Parse body\n\t\tlet body: unknown;\n\t\ttry {\n\t\t\tbody = JSON.parse(rawBody);\n\t\t} catch {\n\t\t\tbody = rawBody;\n\t\t}\n\n\t\t// Create webhook event\n\t\tconst event: WebhookEvent = {\n\t\t\tid: handler.getEventId(headers, body),\n\t\t\tsource,\n\t\t\teventType: handler.getEventType(headers, body),\n\t\t\tpayload: body,\n\t\t\theaders,\n\t\t\tsignature: handler.getSignature(headers),\n\t\t\ttimestamp: new Date(),\n\t\t\trawBody,\n\t\t};\n\n\t\t// Find matching workflow\n\t\tconst workflow = this.findMatchingWorkflow(event);\n\t\tif (!workflow) {\n\t\t\tthis.logger.log(`No matching workflow for webhook: ${source}/${event.eventType}`);\n\t\t\treturn null;\n\t\t}\n\n\t\tconst config = workflow.config.trigger?.webhook as WebhookTriggerOpts;\n\n\t\t// Verify signature if secret is configured\n\t\tif (config.secret && event.signature) {\n\t\t\tconst verification = handler.verifySignature(rawBody, event.signature, config.secret);\n\t\t\tif (!verification.valid) {\n\t\t\t\tthis.logger.error(`Webhook signature verification failed: ${verification.error}`);\n\t\t\t\tthrow new Error(`Signature verification failed: ${verification.error}`);\n\t\t\t}\n\t\t} else if (config.secret && !event.signature) {\n\t\t\tthis.logger.error(\"Webhook signature missing but secret is configured\");\n\t\t\tthrow new Error(\"Signature missing\");\n\t\t}\n\n\t\treturn this.executeWorkflow(event, workflow, config);\n\t}\n\n\t/**\n\t * Get all workflows that have webhook triggers\n\t */\n\tprotected getWebhookWorkflows(): WebhookWorkflowModel[] {\n\t\tconst workflows: WebhookWorkflowModel[] = [];\n\n\t\tfor (const [path, workflow] of Object.entries(this.nodeMap.workflows || {})) {\n\t\t\tconst workflowConfig = (workflow as unknown as { _config: WebhookWorkflowModel[\"config\"] })._config;\n\n\t\t\tif (workflowConfig?.trigger) {\n\t\t\t\tconst triggerType = Object.keys(workflowConfig.trigger)[0];\n\n\t\t\t\tif (triggerType === \"webhook\" && workflowConfig.trigger.webhook) {\n\t\t\t\t\tworkflows.push({\n\t\t\t\t\t\tpath,\n\t\t\t\t\t\tconfig: workflowConfig,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn workflows;\n\t}\n\n\t/**\n\t * Find workflow matching the webhook event\n\t */\n\tprotected findMatchingWorkflow(event: WebhookEvent): WebhookWorkflowModel | null {\n\t\tfor (const workflow of this.webhookWorkflows) {\n\t\t\tconst config = workflow.config.trigger?.webhook;\n\t\t\tif (!config) continue;\n\n\t\t\t// Check source match\n\t\t\tif (config.source !== event.source) continue;\n\n\t\t\t// Check event type match\n\t\t\tif (config.events && config.events.length > 0) {\n\t\t\t\tconst matches = config.events.some((pattern) => {\n\t\t\t\t\t// Support wildcards (e.g., \"push\", \"pull_request.*\")\n\t\t\t\t\tif (pattern === \"*\") return true;\n\t\t\t\t\tif (pattern.endsWith(\".*\")) {\n\t\t\t\t\t\tconst prefix = pattern.slice(0, -2);\n\t\t\t\t\t\treturn event.eventType.startsWith(prefix);\n\t\t\t\t\t}\n\t\t\t\t\treturn pattern === event.eventType;\n\t\t\t\t});\n\t\t\t\tif (!matches) continue;\n\t\t\t}\n\n\t\t\treturn workflow;\n\t\t}\n\n\t\treturn null;\n\t}\n\n\t/**\n\t * Execute a workflow for a webhook event\n\t */\n\tprotected async executeWorkflow(\n\t\tevent: WebhookEvent,\n\t\tworkflow: WebhookWorkflowModel,\n\t\t_config: WebhookTriggerOpts,\n\t): Promise<TriggerResponse> {\n\t\tconst executionId = uuid();\n\n\t\tconst defaultMeter = metrics.getMeter(\"default\");\n\t\tconst webhookExecutions = defaultMeter.createCounter(\"webhook_executions\", {\n\t\t\tdescription: \"Webhook executions\",\n\t\t});\n\t\tconst webhookErrors = defaultMeter.createCounter(\"webhook_errors\", {\n\t\t\tdescription: \"Webhook execution errors\",\n\t\t});\n\n\t\treturn new Promise((resolve) => {\n\t\t\tthis.tracer.startActiveSpan(`webhook:${event.source}/${event.eventType}`, async (span: Span) => {\n\t\t\t\ttry {\n\t\t\t\t\tconst start = performance.now();\n\n\t\t\t\t\t// Initialize configuration for this workflow\n\t\t\t\t\tawait this.configuration.init(workflow.path, this.nodeMap);\n\n\t\t\t\t\t// Create context\n\t\t\t\t\tconst ctx: Context = this.createContext(undefined, workflow.path, executionId);\n\n\t\t\t\t\t// Populate request with webhook event\n\t\t\t\t\tctx.request = {\n\t\t\t\t\t\tbody: event.payload,\n\t\t\t\t\t\theaders: event.headers,\n\t\t\t\t\t\tquery: {},\n\t\t\t\t\t\tparams: {\n\t\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\t\teventType: event.eventType,\n\t\t\t\t\t\t\teventId: event.id,\n\t\t\t\t\t\t},\n\t\t\t\t\t} as unknown as RequestContext;\n\n\t\t\t\t\t// Store webhook context in vars\n\t\t\t\t\tif (!ctx.vars) ctx.vars = {};\n\t\t\t\t\tctx.vars._webhook_event = {\n\t\t\t\t\t\tid: event.id,\n\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\teventType: event.eventType,\n\t\t\t\t\t\ttimestamp: event.timestamp.toISOString(),\n\t\t\t\t\t\thasSignature: String(!!event.signature),\n\t\t\t\t\t};\n\n\t\t\t\t\tctx.logger.log(`Processing webhook: ${event.source}/${event.eventType} (${event.id})`);\n\n\t\t\t\t\t// Execute workflow\n\t\t\t\t\tconst response: TriggerResponse = await this.run(ctx);\n\t\t\t\t\tconst end = performance.now();\n\n\t\t\t\t\t// Set span attributes\n\t\t\t\t\tspan.setAttribute(\"success\", true);\n\t\t\t\t\tspan.setAttribute(\"event_id\", event.id);\n\t\t\t\t\tspan.setAttribute(\"source\", event.source);\n\t\t\t\t\tspan.setAttribute(\"event_type\", event.eventType);\n\t\t\t\t\tspan.setAttribute(\"workflow_path\", workflow.path);\n\t\t\t\t\tspan.setAttribute(\"elapsed_ms\", end - start);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\n\t\t\t\t\t// Record metrics\n\t\t\t\t\twebhookExecutions.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\tevent_type: event.eventType,\n\t\t\t\t\t\tworkflow_name: this.configuration.name,\n\t\t\t\t\t\tsuccess: \"true\",\n\t\t\t\t\t});\n\n\t\t\t\t\tctx.logger.log(`Webhook processed in ${(end - start).toFixed(2)}ms: ${event.id}`);\n\n\t\t\t\t\tresolve(response);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tconst errorMessage = (error as Error).message;\n\n\t\t\t\t\t// Set span error\n\t\t\t\t\tspan.setAttribute(\"success\", false);\n\t\t\t\t\tspan.recordException(error as Error);\n\t\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });\n\n\t\t\t\t\t// Record error metrics\n\t\t\t\t\twebhookErrors.add(1, {\n\t\t\t\t\t\tenv: process.env.NODE_ENV,\n\t\t\t\t\t\tsource: event.source,\n\t\t\t\t\t\tevent_type: event.eventType,\n\t\t\t\t\t\tworkflow_name: this.configuration?.name || \"unknown\",\n\t\t\t\t\t});\n\n\t\t\t\t\tthis.logger.error(`Webhook failed ${event.id}: ${errorMessage}`, (error as Error).stack);\n\n\t\t\t\t\tthrow error;\n\t\t\t\t} finally {\n\t\t\t\t\tspan.end();\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t}\n\n\t/**\n\t * Register a custom source handler\n\t */\n\tstatic registerSourceHandler(source: string, handler: WebhookSourceHandler): void {\n\t\tsourceHandlers[source] = handler;\n\t}\n}\n\nexport default WebhookTrigger;\nexport { sourceHandlers };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WebhookTrigger.js","sourceRoot":"","sources":["../src/WebhookTrigger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EACN,aAAa,EACb,UAAU,EAEV,WAAW,EACX,gBAAgB,GAChB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAa,cAAc,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE/E,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAElC,OAAO,EAAE,iBAAiB,EAAoC,mBAAmB,EAAE,MAAM,aAAa,CAAC;AA6BvG,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,uCAAuC;AACpF,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAEvC,gFAAgF;AAChF,gBAAgB;AAChB,gFAAgF;AAEhF,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,WAAW;IAC5C,OAAO,GAAwB,EAAyB,CAAC;IAChD,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;IAC7B,MAAM,GAAG,KAAK,CAAC,SAAS,CAC1C,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,0BAA0B,EACtD,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,OAAO,CACtC,CAAC;IAEe,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACjC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,6BAA6B,EAAE;QAC1F,WAAW,EAAE,2CAA2C;QACxD,IAAI,EAAE,GAAG;KACT,CAAC,CAAC;IACc,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,6BAA6B,EAAE;QAC1F,WAAW,EAAE,0EAA0E;QACvF,IAAI,EAAE,GAAG;KACT,CAAC,CAAC;IACc,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,6BAA6B,EAAE;QAC1F,WAAW,EAAE,mDAAmD;QAChE,IAAI,EAAE,GAAG;KACT,CAAC,CAAC;IAEH,yEAAyE;IACxD,GAAG,CAAsB;IACzB,WAAW,CAAyB;IAE7C,KAAK,GAAG,KAAK,CAAC;IAEtB,gFAAgF;IAChF,YAAY,GAAwB,EAAE,WAA6B;QAClE,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,WAAW,GAAG,WAAW,IAAI,IAAI,CAAC;QACvC,wBAAwB,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,OAA4B;QACtC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,MAAM;QACX,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACtC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,iDAAiD,CAAC,CAAC;YACnE,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,GAAG,EAAE;gBACxC,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACnC,CAAC,CAAC,CAAC;QACJ,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,0BAA0B,EAAE,CAAC;QACnC,CAAC;QAED,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,IAAI;QACT,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,wBAAwB,EAAE,KAAK,IAAI;YAAE,wBAAwB,CAAC,IAAI,CAAC,CAAC;QACxE,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;IAC5C,CAAC;IAED,8EAA8E;IAC9E,qBAAqB;IACrB,8EAA8E;IAEtE,0BAA0B;QACjC,MAAM,SAAS,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7C,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAC;YAC3E,OAAO;QACR,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,+BAA+B,SAAS,CAAC,MAAM,oBAAoB,CAAC,CAAC;QACrF,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC;IACF,CAAC;IAEO,oBAAoB,CAAC,KAA6D;QACzF,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QACvC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,aAAa,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,aAAa,YAAY,EAAE,CAAC,CAAC;QAC7G,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,IAAI,QAAQ,CAAC;QAC1C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,6BAA6B,IAAI,QAAQ,YAAY,MAAM,KAAK,GAAG,CAAC,CAAC;QAErF,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAc,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5F,CAAC;IAEO,KAAK,CAAC,aAAa,CAC1B,CAAc,EACd,YAAoB,EACpB,IAAY,EACZ,MAA4B;QAE5B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC,CAAC;QAE7D,sEAAsE;QACtE,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACnC,IAAI,UAAU,GAAY,EAAE,CAAC;QAC7B,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC;gBACJ,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,CAAC;YAC7C,CAAC;YAAC,MAAM,CAAC;gBACR,sDAAsD;gBACtD,uDAAuD;gBACvD,UAAU,GAAG,OAAO,CAAC;YACtB,CAAC;QACF,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACtD,MAAM,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,EAA4B,CAAC;QAC3D,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC;QAExE,wBAAwB;QACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,EAAE,CAAC;YACf,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;YACpF,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,wBAAwB,EAAE,EAAE,GAAG,CAAC,CAAC;QAC1G,CAAC;QAED,0CAA0C;QAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC;QAClE,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAE/D,aAAa;QACb,MAAM,YAAY,GAAG,MAAM,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,EAAE,SAAS,IAAI,qBAAqB,CAAC;QAC9F,MAAM,MAAM,GAAiB,QAAQ,CAAC,MAAM,CAAC;YAC5C,OAAO;YACP,OAAO;YACP,UAAU;YACV,MAAM;YACN,YAAY;SACZ,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YAChB,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;YACpF,IAAI,CAAC,MAAM,CAAC,KAAK,CAChB,mBAAmB,YAAY,0BAA0B,MAAM,CAAC,MAAM,aAAa,MAAM,CAAC,OAAO,GAAG,CACpG,CAAC;YACF,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,EAAE,GAAG,CAAC,CAAC;QAC/F,CAAC;QAED,0EAA0E;QAC1E,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YAC3G,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,mBAAmB,EAAE,CAAC,CAAC;YAC1F,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,mBAAmB,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,EAAE,GAAG,CAAC,CAAC;QACrG,CAAC;QAED,kDAAkD;QAClD,IAAI,MAAM,CAAC,cAAc,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YAC7C,MAAM,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;YACjC,MAAM,MAAM,GAAG,KAAK,CAAC,mBAAmB,CAAC,gBAAgB,EAAE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;YACzF,IAAI,MAAM,EAAE,CAAC;gBACZ,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;gBAC/E,OAAO,CAAC,CAAC,IAAI,CACZ;oBACC,MAAM,EAAE,WAAW;oBACnB,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,cAAc,EAAE,MAAM,CAAC,WAAW;iBAClC,EACD,GAAG,CACH,CAAC;YACH,CAAC;QACF,CAAC;QAED,mDAAmD;QACnD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC,CAAC;QAC7D,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC;QACzB,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC;YACnD,YAAY;YACZ,IAAI;YACJ,MAAM;YACN,SAAS;YACT,OAAO;YACP,IAAI,EAAE,UAAU;YAChB,OAAO;YACP,UAAU;YACV,WAAW;YACX,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;SAC3B,CAAC,CAAC;QAEH,gEAAgE;QAChE,kEAAkE;QAClE,2DAA2D;QAC3D,mEAAmE;QACnE,IAAI,MAAM,CAAC,cAAc,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YAC7C,MAAM,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;YACjC,KAAK,CAAC,mBAAmB,CAAC,gBAAgB,EAAE,YAAY,EAAE,MAAM,CAAC,OAAO,EAAE;gBACzE,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE;gBAC9D,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE;gBACpB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,qBAAqB;gBAC7C,WAAW,EAAE,SAAS;gBACtB,eAAe,EAAE,SAAS;aAC1B,CAAC,CAAC;QACJ,CAAC;QAED,gEAAgE;QAChE,yCAAyC;QACzC,OAAO,CAAC,CAAC,IAAI,CACZ;YACC,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,KAAK,EAAE,SAAS;YAChB,QAAQ,EAAE,eAAe;SACzB,EACD,GAAG,CACH,CAAC;IACH,CAAC;IAEO,eAAe,CAAC,YAAoB,EAAE,MAA4B;QACzE,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrB,MAAM,CAAC,GAAG,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAC7C,IAAI,CAAC,CAAC,EAAE,CAAC;gBACR,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,YAAY,uBAAuB,MAAM,CAAC,QAAQ,GAAG,CAAC,CAAC;gBAC5F,OAAO,IAAI,CAAC;YACb,CAAC;YACD,OAAO,CAAC,CAAC;QACV,CAAC;QACD,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACtB,OAAO,mBAAmB,CAAC;gBAC1B,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,IAAI,aAAa;gBAChD,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM;gBAC/B,MAAM,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,IAAI,OAAO;gBAC1C,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,SAAS;gBACrC,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC,SAAS,IAAI,qBAAqB;gBAC9D,eAAe,EAAE,MAAM,CAAC,SAAS,CAAC,eAAe;aACjD,CAAC,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,8EAA8E;IAC9E,oBAAoB;IACpB,8EAA8E;IAEtE,KAAK,CAAC,gBAAgB,CAAC,IAY9B;QACA,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;QAE9G,OAAO,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,WAAW,YAAY,EAAE,EAAE,KAAK,EAAE,IAAU,EAAE,EAAE;YAClF,IAAI,CAAC;gBACJ,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;gBAChD,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;gBACzC,IAAI,CAAC,KAAK,EAAE,CAAC;oBACZ,MAAM,IAAI,KAAK,CAAC,6BAA6B,YAAY,yBAAyB,CAAC,CAAC;gBACrF,CAAC;gBACD,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;gBAE1E,MAAM,GAAG,GAAY,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;gBAC5E,GAAG,CAAC,OAAO,GAAG;oBACb,IAAI;oBACJ,OAAO;oBACP,OAAO;oBACP,MAAM,EAAE,UAAU;oBAClB,KAAK,EAAE,WAAW;iBACW,CAAC;gBAE/B,0DAA0D;gBAC1D,iDAAiD;gBAChD,GAA+B,CAAC,QAAQ,GAAG;oBAC3C,OAAO;oBACP,SAAS;oBACT,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS;iBAChC,CAAC;gBAEF,MAAM,IAAI,CAAC,oBAAoB,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBACnD,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAEpB,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;gBACjD,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACvC,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;gBAC3C,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC5C,OAAO,GAAG,CAAC,QAAQ,CAAC;YACrB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACd,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC7D,IAAI,CAAC,eAAe,CAAC,GAAY,CAAC,CAAC;gBACnC,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC;gBAC7D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,4BAA4B,YAAY,YAAY,GAAG,EAAE,CAAC,CAAC;gBAC7E,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;YACvB,CAAC;oBAAS,CAAC;gBACV,IAAI,CAAC,GAAG,EAAE,CAAC;YACZ,CAAC;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,8EAA8E;IAC9E,gBAAgB;IAChB,8EAA8E;IAE9E,QAAQ;QACP,OAAO,EAAE,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,EAAE,CAAC,MAAM,EAAE,CAAC;IACnE,CAAC;IAEO,mBAAmB;QAC1B,MAAM,QAAQ,GAAG,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAChD,MAAM,GAAG,GAAkE,EAAE,CAAC;QAC9E,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;YACrC,MAAM,EAAE,GAAG,KAAK,CAAC,QAAwE,CAAC;YAC1F,MAAM,GAAG,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC;YACjC,IAAI,CAAC,GAAG;gBAAE,SAAS;YACnB,gEAAgE;YAChE,2DAA2D;YAC3D,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;gBACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAChB,6BAA6B,KAAK,CAAC,IAAI,yHAAyH,CAChK,CAAC;gBACF,SAAS;YACV,CAAC;YACD,GAAG,CAAC,IAAI,CAAC,EAAE,YAAY,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,OAAO,GAAG,CAAC;IACZ,CAAC;CACD;AAED,gFAAgF;AAChF,wCAAwC;AACxC,gFAAgF;AAEhF,IAAI,aAAa,GAA0B,IAAI,CAAC;AAEhD,MAAM,UAAU,wBAAwB,CAAC,OAA8B;IACtE,aAAa,GAAG,OAAO,CAAC;AACzB,CAAC;AAED,MAAM,UAAU,wBAAwB;IACvC,OAAO,aAAa,CAAC;AACtB,CAAC","sourcesContent":["/**\n * WebhookTrigger — v0.7 PR 4 — Inbound webhook trigger that mounts\n * verified POST routes on the shared Hono app. One route per workflow\n * whose `trigger.webhook` config is registered.\n *\n * **Authoring surface (built-in provider):**\n *\n * ```json\n * {\n *   \"name\": \"stripe-events\",\n *   \"trigger\": {\n *     \"webhook\": {\n *       \"provider\": \"stripe\",\n *       \"path\": \"/webhooks/stripe\",\n *       \"secretEnv\": \"STRIPE_WEBHOOK_SECRET\",\n *       \"namespace\": \"stripe\",\n *       \"idempotencyKey\": \"js/ctx.request.body.id\"\n *     }\n *   },\n *   \"steps\": [\n *     { \"id\": \"dispatch\", \"subworkflow\": \"js/ctx.request.body.type\", \"inputs\": { \"stripeEvent\": \"js/ctx.request.body\" } }\n *   ]\n * }\n * ```\n *\n * **Pipeline (per inbound request):**\n *\n *   1. Read raw body — verifiers MUST sign the bytes that crossed\n *      the wire, not the JSON-re-stringified body (Stripe / GitHub /\n *      Slack all sign raw bytes).\n *   2. Verify the signature via the per-provider strategy\n *      (`verifiers.ts`). On failure, return 401 with structured\n *      `{ error, reason, message }`.\n *   3. Replay check: if `idempotencyKey` is configured, look up\n *      `(workflowName, eventId)` in the idempotency cache (same store\n *      as Tier 1 step caching). On hit, return 200 with\n *      `{ status: \"duplicate\", eventId }` and DON'T run the workflow.\n *   4. Events allowlist: if `events: [...]` is configured, skip\n *      workflow runs whose event type isn't in the list — return\n *      200 with `{ status: \"ignored\", eventType }` so the sender\n *      doesn't retry.\n *   5. Run the workflow through `TriggerBase.run` so middleware,\n *      tracing, retries, concurrency, etc. apply uniformly.\n *   6. Cache the eventId so a retry within the TTL window returns\n *      the duplicate response.\n *\n * **Hono integration:** identical to WebSocket and SSE — accepts the\n * shared `Hono<any, any, any>` app and an optional `HttpTriggerLike`\n * exposing `addPreCatchAllHook` so webhook routes mount BEFORE the\n * legacy `/:workflow{.+}` catch-all and win Hono's first-match\n * dispatch.\n *\n * See [additional-triggers-plan.mdx](../../../docs/c/devtools/additional-triggers-plan.mdx#webhook-trigger)\n * for the full v0.7 design.\n */\n\nimport {\n\tDefaultLogger,\n\tRunTracker,\n\ttype GlobalOptions as RunnerGlobalOptions,\n\tTriggerBase,\n\tWorkflowRegistry,\n} from \"@blokjs/runner\";\nimport type { Context, RequestContext } from \"@blokjs/shared\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport type { Hono, Context as HonoContext } from \"hono\";\nimport { v4 as uuid } from \"uuid\";\n\nimport { BUILTIN_VERIFIERS, type Verifier, type VerifyResult, buildCustomVerifier } from \"./verifiers\";\n\n// -----------------------------------------------------------------------------\n// Types\n// -----------------------------------------------------------------------------\n\ninterface WebhookTriggerConfig {\n\tprovider?: \"github\" | \"stripe\" | \"slack\" | \"shopify\" | \"svix\";\n\tpath?: string;\n\tevents?: string[];\n\tsecretEnv?: string;\n\tsignature?: {\n\t\tscheme?: \"hmac-sha256\" | \"hmac-sha1\" | \"hmac-sha512\";\n\t\theader: string;\n\t\tformat?: string;\n\t\tsecretEnv: string;\n\t\ttolerance?: number;\n\t\ttimestampHeader?: string;\n\t};\n\ttolerance?: number;\n\tidempotencyKey?: string;\n\tnamespace?: string;\n\tmiddleware?: string[];\n}\n\ninterface HttpTriggerLike {\n\taddPreCatchAllHook(cb: () => void | Promise<void>): void;\n}\n\nconst DEFAULT_TOLERANCE_SEC = 300;\nconst DEFAULT_REPLAY_TTL_MS = 5 * 60 * 1000; // 5 min — match Stripe / Svix default.\nconst REPLAY_NAMESPACE = \"__webhook__\";\n\n// -----------------------------------------------------------------------------\n// Trigger class\n// -----------------------------------------------------------------------------\n\nexport default class WebhookTrigger extends TriggerBase {\n\tprotected nodeMap: RunnerGlobalOptions = {} as RunnerGlobalOptions;\n\tprotected readonly logger = new DefaultLogger();\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-webhook-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\n\tprivate readonly meter = metrics.getMeter(\"blok\");\n\tprivate readonly counterReceived = this.meter.createCounter(\"blok_webhook_received_total\", {\n\t\tdescription: \"Webhook deliveries received (cumulative).\",\n\t\tunit: \"1\",\n\t});\n\tprivate readonly counterRejected = this.meter.createCounter(\"blok_webhook_rejected_total\", {\n\t\tdescription: \"Webhook deliveries rejected (signature failure, allowlist miss, replay).\",\n\t\tunit: \"1\",\n\t});\n\tprivate readonly counterAccepted = this.meter.createCounter(\"blok_webhook_accepted_total\", {\n\t\tdescription: \"Webhook deliveries that triggered a workflow run.\",\n\t\tunit: \"1\",\n\t});\n\n\t// biome-ignore lint/suspicious/noExplicitAny: Hono's generic propagation\n\tprivate readonly app: Hono<any, any, any>;\n\tprivate readonly httpTrigger: HttpTriggerLike | null;\n\n\tprivate wired = false;\n\n\t// biome-ignore lint/suspicious/noExplicitAny: matches `app` field's any generic\n\tconstructor(app: Hono<any, any, any>, httpTrigger?: HttpTriggerLike) {\n\t\tsuper();\n\t\tthis.app = app;\n\t\tthis.httpTrigger = httpTrigger ?? null;\n\t\t_setActiveWebhookTrigger(this);\n\t}\n\n\t/**\n\t * Inject the runner's GlobalOptions (nodes + workflows). Called by\n\t * the orchestrator AFTER constructing the trigger but BEFORE\n\t * `listen()`. Shares HttpTrigger's nodeMap so per-request workflow\n\t * runs resolve helpers + sub-workflows through the same registry.\n\t */\n\tsetNodeMap(nodeMap: RunnerGlobalOptions): void {\n\t\tthis.nodeMap = nodeMap;\n\t}\n\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\t\tif (this.wired) {\n\t\t\tthis.logger.log(\"[blok][webhook] listen() called twice; ignoring\");\n\t\t\treturn this.endCounter(startTime);\n\t\t}\n\t\tthis.wired = true;\n\n\t\tif (this.httpTrigger) {\n\t\t\tthis.httpTrigger.addPreCatchAllHook(() => {\n\t\t\t\tthis.registerRoutesFromRegistry();\n\t\t\t});\n\t\t} else {\n\t\t\tthis.registerRoutesFromRegistry();\n\t\t}\n\n\t\treturn this.endCounter(startTime);\n\t}\n\n\tasync stop(): Promise<void> {\n\t\tthis.wired = false;\n\t\tif (_getActiveWebhookTrigger() === this) _setActiveWebhookTrigger(null);\n\t\tthis.destroyMonitoring();\n\t\tthis.logger.log(\"[blok][webhook] stopped\");\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// Route registration\n\t// ---------------------------------------------------------------------------\n\n\tprivate registerRoutesFromRegistry(): void {\n\t\tconst workflows = this.getWebhookWorkflows();\n\t\tif (workflows.length === 0) {\n\t\t\tthis.logger.log(\"[blok][webhook] no workflows with trigger.webhook found\");\n\t\t\treturn;\n\t\t}\n\t\tthis.logger.log(`[blok][webhook] registering ${workflows.length} webhook route(s):`);\n\t\tfor (const entry of workflows) {\n\t\t\tthis.registerWebhookRoute(entry);\n\t\t}\n\t}\n\n\tprivate registerWebhookRoute(entry: { workflowName: string; config: WebhookTriggerConfig }): void {\n\t\tconst { workflowName, config } = entry;\n\t\tconst path = config.path ?? (config.provider ? `/webhooks/${config.provider}` : `/webhooks/${workflowName}`);\n\t\tconst label = config.provider ?? \"custom\";\n\t\tthis.logger.log(`[blok][webhook]   POST    ${path}  ←  ${workflowName}  (${label})`);\n\n\t\tthis.app.post(path, (c: HonoContext) => this.handleRequest(c, workflowName, path, config));\n\t}\n\n\tprivate async handleRequest(\n\t\tc: HonoContext,\n\t\tworkflowName: string,\n\t\tpath: string,\n\t\tconfig: WebhookTriggerConfig,\n\t): Promise<Response> {\n\t\tthis.counterReceived.add(1, { workflow_name: workflowName });\n\n\t\t// 1. Capture raw body BEFORE parsing — verifiers sign the wire bytes.\n\t\tconst rawBody = await c.req.text();\n\t\tlet parsedBody: unknown = {};\n\t\tif (rawBody.length > 0) {\n\t\t\ttry {\n\t\t\t\tparsedBody = JSON.parse(rawBody) as unknown;\n\t\t\t} catch {\n\t\t\t\t// Non-JSON body — leave parsed as the raw text. Slack\n\t\t\t\t// challenges & Shopify can post non-JSON occasionally.\n\t\t\t\tparsedBody = rawBody;\n\t\t\t}\n\t\t}\n\n\t\tconst headers = Object.fromEntries(c.req.raw.headers);\n\t\tconst pathParams = c.req.param() as Record<string, string>;\n\t\tconst queryParams = Object.fromEntries(new URL(c.req.url).searchParams);\n\n\t\t// 2. Pick the verifier.\n\t\tconst verifier = this.resolveVerifier(workflowName, config);\n\t\tif (!verifier) {\n\t\t\tthis.counterRejected.add(1, { workflow_name: workflowName, reason: \"no_verifier\" });\n\t\t\treturn c.json({ error: \"Configuration\", reason: \"no_verifier\", message: \"No verifier configured\" }, 500);\n\t\t}\n\n\t\t// 3. Resolve the secret from the env var.\n\t\tconst secretEnv = config.secretEnv ?? config.signature?.secretEnv;\n\t\tconst secret = secretEnv ? (process.env[secretEnv] ?? \"\") : \"\";\n\n\t\t// 4. Verify.\n\t\tconst toleranceSec = config.tolerance ?? config.signature?.tolerance ?? DEFAULT_TOLERANCE_SEC;\n\t\tconst result: VerifyResult = verifier.verify({\n\t\t\theaders,\n\t\t\trawBody,\n\t\t\tparsedBody,\n\t\t\tsecret,\n\t\t\ttoleranceSec,\n\t\t});\n\n\t\tif (!result.ok) {\n\t\t\tthis.counterRejected.add(1, { workflow_name: workflowName, reason: result.reason });\n\t\t\tthis.logger.error(\n\t\t\t\t`[blok][webhook] ${workflowName}: verify failed reason=${result.reason} message=\"${result.message}\"`,\n\t\t\t);\n\t\t\treturn c.json({ error: \"Unauthorized\", reason: result.reason, message: result.message }, 401);\n\t\t}\n\n\t\t// 5. Events allowlist — verified-but-out-of-scope returns 200 (no retry).\n\t\tif (Array.isArray(config.events) && config.events.length > 0 && !config.events.includes(result.eventType)) {\n\t\t\tthis.counterRejected.add(1, { workflow_name: workflowName, reason: \"event_not_allowed\" });\n\t\t\treturn c.json({ status: \"ignored\", reason: \"event_not_allowed\", eventType: result.eventType }, 200);\n\t\t}\n\n\t\t// 6. Replay protection via the idempotency cache.\n\t\tif (config.idempotencyKey && result.eventId) {\n\t\t\tconst tracker = RunTracker.getInstance();\n\t\t\tconst store = tracker.getStore();\n\t\t\tconst cached = store.getIdempotencyCache(REPLAY_NAMESPACE, workflowName, result.eventId);\n\t\t\tif (cached) {\n\t\t\t\tthis.counterRejected.add(1, { workflow_name: workflowName, reason: \"replay\" });\n\t\t\t\treturn c.json(\n\t\t\t\t\t{\n\t\t\t\t\t\tstatus: \"duplicate\",\n\t\t\t\t\t\teventId: result.eventId,\n\t\t\t\t\t\teventType: result.eventType,\n\t\t\t\t\t\tfirstSeenRunId: cached.sourceRunId,\n\t\t\t\t\t},\n\t\t\t\t\t200,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\t// 7. Verified + new event — dispatch the workflow.\n\t\tthis.counterAccepted.add(1, { workflow_name: workflowName });\n\t\tconst requestId = uuid();\n\t\tconst dispatchOutcome = await this.dispatchWorkflow({\n\t\t\tworkflowName,\n\t\t\tpath,\n\t\t\tconfig,\n\t\t\trequestId,\n\t\t\theaders,\n\t\t\tbody: parsedBody,\n\t\t\trawBody,\n\t\t\tpathParams,\n\t\t\tqueryParams,\n\t\t\teventId: result.eventId,\n\t\t\teventType: result.eventType,\n\t\t});\n\n\t\t// 8. Cache event id AFTER successful dispatch so retries on the\n\t\t//    same delivery are deduped. We cache even on workflow failure\n\t\t//    — webhook senders should not retry deliveries they've\n\t\t//    already delivered (the workflow's own retry / DLQ owns that).\n\t\tif (config.idempotencyKey && result.eventId) {\n\t\t\tconst tracker = RunTracker.getInstance();\n\t\t\tconst store = tracker.getStore();\n\t\t\tstore.setIdempotencyCache(REPLAY_NAMESPACE, workflowName, result.eventId, {\n\t\t\t\tdata: { eventId: result.eventId, eventType: result.eventType },\n\t\t\t\tcachedAt: Date.now(),\n\t\t\t\texpiresAt: Date.now() + DEFAULT_REPLAY_TTL_MS,\n\t\t\t\tsourceRunId: requestId,\n\t\t\t\tsourceNodeRunId: requestId,\n\t\t\t});\n\t\t}\n\n\t\t// 9. Shape the response. Workflow's `ctx.response` lands in the\n\t\t//    body for parity with HTTP triggers.\n\t\treturn c.json(\n\t\t\t{\n\t\t\t\tstatus: \"ok\",\n\t\t\t\teventId: result.eventId,\n\t\t\t\teventType: result.eventType,\n\t\t\t\trunId: requestId,\n\t\t\t\tresponse: dispatchOutcome,\n\t\t\t},\n\t\t\t200,\n\t\t);\n\t}\n\n\tprivate resolveVerifier(workflowName: string, config: WebhookTriggerConfig): Verifier | null {\n\t\tif (config.provider) {\n\t\t\tconst v = BUILTIN_VERIFIERS[config.provider];\n\t\t\tif (!v) {\n\t\t\t\tthis.logger.error(`[blok][webhook] ${workflowName}: unknown provider \"${config.provider}\"`);\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\treturn v;\n\t\t}\n\t\tif (config.signature) {\n\t\t\treturn buildCustomVerifier({\n\t\t\t\tscheme: config.signature.scheme ?? \"hmac-sha256\",\n\t\t\t\theader: config.signature.header,\n\t\t\t\tformat: config.signature.format ?? \"{hex}\",\n\t\t\t\tsecretEnv: config.signature.secretEnv,\n\t\t\t\ttolerance: config.signature.tolerance ?? DEFAULT_TOLERANCE_SEC,\n\t\t\t\ttimestampHeader: config.signature.timestampHeader,\n\t\t\t});\n\t\t}\n\t\treturn null;\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// Workflow dispatch\n\t// ---------------------------------------------------------------------------\n\n\tprivate async dispatchWorkflow(opts: {\n\t\tworkflowName: string;\n\t\tpath: string;\n\t\tconfig: WebhookTriggerConfig;\n\t\trequestId: string;\n\t\theaders: Record<string, string>;\n\t\tbody: unknown;\n\t\trawBody: string;\n\t\tpathParams: Record<string, string>;\n\t\tqueryParams: Record<string, string>;\n\t\teventId: string;\n\t\teventType: string;\n\t}): Promise<unknown> {\n\t\tconst { workflowName, requestId, headers, body, rawBody, pathParams, queryParams, eventId, eventType } = opts;\n\n\t\treturn this.tracer.startActiveSpan(`webhook:${workflowName}`, async (span: Span) => {\n\t\t\ttry {\n\t\t\t\tconst registry = WorkflowRegistry.getInstance();\n\t\t\t\tconst entry = registry.get(workflowName);\n\t\t\t\tif (!entry) {\n\t\t\t\t\tthrow new Error(`[blok][webhook] workflow \"${workflowName}\" not found in registry`);\n\t\t\t\t}\n\t\t\t\tawait this.configuration.init(workflowName, this.nodeMap, entry.workflow);\n\n\t\t\t\tconst ctx: Context = this.createContext(undefined, workflowName, requestId);\n\t\t\t\tctx.request = {\n\t\t\t\t\tbody,\n\t\t\t\t\trawBody,\n\t\t\t\t\theaders,\n\t\t\t\t\tparams: pathParams,\n\t\t\t\t\tquery: queryParams,\n\t\t\t\t} as unknown as RequestContext;\n\n\t\t\t\t// Stamp webhook metadata onto ctx so polymorphic dispatch\n\t\t\t\t// can read namespace + event metadata uniformly.\n\t\t\t\t(ctx as Record<string, unknown>)._webhook = {\n\t\t\t\t\teventId,\n\t\t\t\t\teventType,\n\t\t\t\t\tnamespace: opts.config.namespace,\n\t\t\t\t};\n\n\t\t\t\tawait this.applyMiddlewareChain(ctx, this.nodeMap);\n\t\t\t\tawait this.run(ctx);\n\n\t\t\t\tspan.setAttribute(\"workflow_name\", workflowName);\n\t\t\t\tspan.setAttribute(\"event_id\", eventId);\n\t\t\t\tspan.setAttribute(\"event_type\", eventType);\n\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\t\t\t\treturn ctx.response;\n\t\t\t} catch (err) {\n\t\t\t\tconst msg = err instanceof Error ? err.message : String(err);\n\t\t\t\tspan.recordException(err as Error);\n\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: msg });\n\t\t\t\tthis.logger.error(`[blok][webhook] workflow ${workflowName} failed: ${msg}`);\n\t\t\t\treturn { error: msg };\n\t\t\t} finally {\n\t\t\t\tspan.end();\n\t\t\t}\n\t\t});\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// Introspection\n\t// ---------------------------------------------------------------------------\n\n\tgetStats(): { workflowsRegistered: number } {\n\t\treturn { workflowsRegistered: this.getWebhookWorkflows().length };\n\t}\n\n\tprivate getWebhookWorkflows(): Array<{ workflowName: string; config: WebhookTriggerConfig }> {\n\t\tconst registry = WorkflowRegistry.getInstance();\n\t\tconst out: Array<{ workflowName: string; config: WebhookTriggerConfig }> = [];\n\t\tfor (const entry of registry.list()) {\n\t\t\tconst wf = entry.workflow as { trigger?: { webhook?: WebhookTriggerConfig } } | undefined;\n\t\t\tconst cfg = wf?.trigger?.webhook;\n\t\t\tif (!cfg) continue;\n\t\t\t// Skip configs missing both provider AND signature — they can't\n\t\t\t// verify anything. Authors get a structured error at boot.\n\t\t\tif (!cfg.provider && !cfg.signature) {\n\t\t\t\tthis.logger.error(\n\t\t\t\t\t`[blok][webhook] workflow \"${entry.name}\" has trigger.webhook with neither \\`provider\\` nor \\`signature\\` — skipping. Add one to enable signature verification.`,\n\t\t\t\t);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tout.push({ workflowName: entry.name, config: cfg });\n\t\t}\n\t\treturn out;\n\t}\n}\n\n// -----------------------------------------------------------------------------\n// Singleton accessor (mirrors WS / SSE)\n// -----------------------------------------------------------------------------\n\nlet activeTrigger: WebhookTrigger | null = null;\n\nexport function _setActiveWebhookTrigger(trigger: WebhookTrigger | null): void {\n\tactiveTrigger = trigger;\n}\n\nexport function _getActiveWebhookTrigger(): WebhookTrigger | null {\n\treturn activeTrigger;\n}\n\nexport type { WebhookTriggerConfig };\n"]}