@workflow/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/runtime/count-step-started-events.js

@@ -0,0 +1,72 @@
+const ownerOf = (e) => 'eventData' in e &&
+    e.eventData &&
+    'ownerMessageId' in e.eventData &&
+    typeof e.eventData.ownerMessageId === 'string'
+    ? e.eventData.ownerMessageId
+    : undefined;
+/**
+ * Number of `step_started` events already recorded for a step, used as the
+ * authoritative attempt count for the maxRetries ceiling (the only bound for
+ * steps that time out without writing a `step_failed`).
+ *
+ * IMPORTANT: the raw (unscoped) count is NOT a reliable attempt number.
+ * Concurrent invocations racing on the same pending batch (stale replays,
+ * wake replays, a step message dispatched by a replay that lost the
+ * create-claim race, ...) can each write a `step_started` for the same
+ * logical attempt — worlds without an atomic start guard (world-local) let
+ * all of them through. Counting those duplicates as "attempts" made the
+ * maxRetries ceiling fire on healthy runs and fail them with a false
+ * "exceeded max retries" (see workflow#3069).
+ *
+ * Callers therefore scope the count to the starts their ceiling is actually
+ * about via `scope`:
+ * - the inline owned-recovery ceiling counts only THIS message's starts
+ *   (`ownedBy`) — each real (re)delivery of the owning message stamps its
+ *   `ownerMessageId` on the start it writes, while racing invocations stamp
+ *   their own IDs (or none), so they no longer inflate the count;
+ * - the background-step ceiling counts the lifecycle attempt total
+ *   (`totalAttempts`: bare starts plus the largest single owner's starts) —
+ *   so a step that exhausted part of its budget under inline ownership
+ *   before transitioning to queued/bare retries still trips the combined
+ *   ceiling, while racers' one-off stamped duplicates don't accumulate, and
+ *   throttle/too-early redeliveries (which write no start at all) stay
+ *   excluded as before.
+ */
+export function countStepStartedEvents(events, stepId, scope) {
+    if (!events) {
+        return 0;
+    }
+    let bare = 0;
+    const byOwner = new Map();
+    for (const e of events) {
+        if (e.eventType !== 'step_started' || e.correlationId !== stepId) {
+            continue;
+        }
+        const owner = ownerOf(e);
+        if (owner === undefined) {
+            bare++;
+        }
+        else {
+            byOwner.set(owner, (byOwner.get(owner) ?? 0) + 1);
+        }
+    }
+    if (scope === undefined) {
+        let total = bare;
+        for (const count of byOwner.values()) {
+            total += count;
+        }
+        return total;
+    }
+    if (scope.type === 'ownedBy') {
+        return byOwner.get(scope.messageId) ?? 0;
+    }
+    // totalAttempts
+    let maxOwner = 0;
+    for (const count of byOwner.values()) {
+        if (count > maxOwner) {
+            maxOwner = count;
+        }
+    }
+    return bare + maxOwner;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnQtc3RlcC1zdGFydGVkLWV2ZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL2NvdW50LXN0ZXAtc3RhcnRlZC1ldmVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBcUJBLE1BQU0sT0FBTyxHQUFHLENBQUMsQ0FBUSxFQUFzQixFQUFFLENBQy9DLFdBQVcsSUFBSSxDQUFDO0lBQ2hCLENBQUMsQ0FBQyxTQUFTO0lBQ1gsZ0JBQWdCLElBQUksQ0FBQyxDQUFDLFNBQVM7SUFDL0IsT0FBTyxDQUFDLENBQUMsU0FBUyxDQUFDLGNBQWMsS0FBSyxRQUFRO0lBQzVDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLGNBQWM7SUFDNUIsQ0FBQyxDQUFDLFNBQVMsQ0FBQztBQUVoQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMkJHO0FBQ0gsTUFBTSxVQUFVLHNCQUFzQixDQUNwQyxNQUFrQyxFQUNsQyxNQUFjLEVBQ2QsS0FBc0I7SUFFdEIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osT0FBTyxDQUFDLENBQUM7SUFDWCxDQUFDO0lBQ0QsSUFBSSxJQUFJLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUM7SUFDMUMsS0FBSyxNQUFNLENBQUMsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsQ0FBQyxTQUFTLEtBQUssY0FBYyxJQUFJLENBQUMsQ0FBQyxhQUFhLEtBQUssTUFBTSxFQUFFLENBQUM7WUFDakUsU0FBUztRQUNYLENBQUM7UUFDRCxNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDekIsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDeEIsSUFBSSxFQUFFLENBQUM7UUFDVCxDQUFDO2FBQU0sQ0FBQztZQUNOLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUNwRCxDQUFDO0lBQ0gsQ0FBQztJQUNELElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQ3hCLElBQUksS0FBSyxHQUFHLElBQUksQ0FBQztRQUNqQixLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDO1lBQ3JDLEtBQUssSUFBSSxLQUFLLENBQUM7UUFDakIsQ0FBQztRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUNELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUM3QixPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBQ0QsZ0JBQWdCO0lBQ2hCLElBQUksUUFBUSxHQUFHLENBQUMsQ0FBQztJQUNqQixLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3JDLElBQUksS0FBSyxHQUFHLFFBQVEsRUFBRSxDQUFDO1lBQ3JCLFFBQVEsR0FBRyxLQUFLLENBQUM7UUFDbkIsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLElBQUksR0FBRyxRQUFRLENBQUM7QUFDekIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRXZlbnQgfSBmcm9tICdAd29ya2Zsb3cvd29ybGQnO1xuXG4vKipcbiAqIFNjb3BlIGZvciB7QGxpbmsgY291bnRTdGVwU3RhcnRlZEV2ZW50c306XG4gKiAtIGB7IHR5cGU6ICdvd25lZEJ5JywgbWVzc2FnZUlkIH1gIGNvdW50cyBvbmx5IHN0YXJ0cyB3aG9zZVxuICogICBgZXZlbnREYXRhLm93bmVyTWVzc2FnZUlkYCBtYXRjaGVzIOKAlCBpLmUuIGF0dGVtcHRzIHBlcmZvcm1lZCBieSB0aGF0XG4gKiAgIG93bmluZyBxdWV1ZSBtZXNzYWdlIChpbmxpbmUgbGF6eSBzdGFydHMgYW5kIG93bmVkLXJlY292ZXJ5IHJlLXN0YW1wcykuXG4gKiAtIGB7IHR5cGU6ICd0b3RhbEF0dGVtcHRzJyB9YCBlc3RpbWF0ZXMgdGhlIHN0ZXAncyBnZW51aW5lIGF0dGVtcHQgdG90YWxcbiAqICAgYWNyb3NzIGl0cyB3aG9sZSBsaWZlY3ljbGU6IHVuc3RhbXBlZCAoYmFyZSkgc3RhcnRzIOKAlCB3aGljaCBvbmx5IHJlYWxcbiAqICAgcXVldWUtZGlzcGF0Y2hlZCBiYWNrZ3JvdW5kIGRlbGl2ZXJpZXMgd3JpdGUg4oCUIHBsdXMgdGhlIHN0YXJ0cyBvZiB0aGVcbiAqICAgc2luZ2xlIG1vc3Qtc3RhcnRlZCBvd25lci4gQSBnZW51aW5lIGxpZmVjeWNsZSBoYXMgYXQgbW9zdCBvbmUgaW5saW5lXG4gKiAgIG93bmVyIHBoYXNlIChvd25lcnNoaXAgaXMgY2xhaW1lZCBhdG9taWNhbGx5IGF0IHN0ZXAgY3JlYXRpb24gYW5kXG4gKiAgIGxhcHNlcyBwZXJtYW5lbnRseSBhdCBgc3RlcF9yZXRyeWluZ2Agb3Igb24gYW55IGJhcmUgc3RhcnQpLCBzbyB0YWtpbmdcbiAqICAgdGhlIG1heCBvdmVyIG93bmVycyBjb3VudHMgdGhhdCBwaGFzZSdzIHJlYWwgYXR0ZW1wdHMgd2hpbGUgaW52b2NhdGlvbnNcbiAqICAgcmFjaW5nIG9uIHRoZSBzYW1lIGJhdGNoIOKAlCB3aGljaCBzdGFtcCB0aGVpciBvd24gb25lLW9mZiBtZXNzYWdlIElEcyDigJRcbiAqICAgY29udHJpYnV0ZSBhdCBtb3N0IHRoZWlyIHNpbmdsZSBsYXJnZXN0IGNvdW50IGluc3RlYWQgb2YgYWNjdW11bGF0aW5nLlxuICovXG5leHBvcnQgdHlwZSBTdGVwU3RhcnRTY29wZSA9XG4gIHwgeyB0eXBlOiAnb3duZWRCeSc7IG1lc3NhZ2VJZDogc3RyaW5nIH1cbiAgfCB7IHR5cGU6ICd0b3RhbEF0dGVtcHRzJyB9O1xuXG5jb25zdCBvd25lck9mID0gKGU6IEV2ZW50KTogc3RyaW5nIHwgdW5kZWZpbmVkID0+XG4gICdldmVudERhdGEnIGluIGUgJiZcbiAgZS5ldmVudERhdGEgJiZcbiAgJ293bmVyTWVzc2FnZUlkJyBpbiBlLmV2ZW50RGF0YSAmJlxuICB0eXBlb2YgZS5ldmVudERhdGEub3duZXJNZXNzYWdlSWQgPT09ICdzdHJpbmcnXG4gICAgPyBlLmV2ZW50RGF0YS5vd25lck1lc3NhZ2VJZFxuICAgIDogdW5kZWZpbmVkO1xuXG4vKipcbiAqIE51bWJlciBvZiBgc3RlcF9zdGFydGVkYCBldmVudHMgYWxyZWFkeSByZWNvcmRlZCBmb3IgYSBzdGVwLCB1c2VkIGFzIHRoZVxuICogYXV0aG9yaXRhdGl2ZSBhdHRlbXB0IGNvdW50IGZvciB0aGUgbWF4UmV0cmllcyBjZWlsaW5nICh0aGUgb25seSBib3VuZCBmb3JcbiAqIHN0ZXBzIHRoYXQgdGltZSBvdXQgd2l0aG91dCB3cml0aW5nIGEgYHN0ZXBfZmFpbGVkYCkuXG4gKlxuICogSU1QT1JUQU5UOiB0aGUgcmF3ICh1bnNjb3BlZCkgY291bnQgaXMgTk9UIGEgcmVsaWFibGUgYXR0ZW1wdCBudW1iZXIuXG4gKiBDb25jdXJyZW50IGludm9jYXRpb25zIHJhY2luZyBvbiB0aGUgc2FtZSBwZW5kaW5nIGJhdGNoIChzdGFsZSByZXBsYXlzLFxuICogd2FrZSByZXBsYXlzLCBhIHN0ZXAgbWVzc2FnZSBkaXNwYXRjaGVkIGJ5IGEgcmVwbGF5IHRoYXQgbG9zdCB0aGVcbiAqIGNyZWF0ZS1jbGFpbSByYWNlLCAuLi4pIGNhbiBlYWNoIHdyaXRlIGEgYHN0ZXBfc3RhcnRlZGAgZm9yIHRoZSBzYW1lXG4gKiBsb2dpY2FsIGF0dGVtcHQg4oCUIHdvcmxkcyB3aXRob3V0IGFuIGF0b21pYyBzdGFydCBndWFyZCAod29ybGQtbG9jYWwpIGxldFxuICogYWxsIG9mIHRoZW0gdGhyb3VnaC4gQ291bnRpbmcgdGhvc2UgZHVwbGljYXRlcyBhcyBcImF0dGVtcHRzXCIgbWFkZSB0aGVcbiAqIG1heFJldHJpZXMgY2VpbGluZyBmaXJlIG9uIGhlYWx0aHkgcnVucyBhbmQgZmFpbCB0aGVtIHdpdGggYSBmYWxzZVxuICogXCJleGNlZWRlZCBtYXggcmV0cmllc1wiIChzZWUgd29ya2Zsb3cjMzA2OSkuXG4gKlxuICogQ2FsbGVycyB0aGVyZWZvcmUgc2NvcGUgdGhlIGNvdW50IHRvIHRoZSBzdGFydHMgdGhlaXIgY2VpbGluZyBpcyBhY3R1YWxseVxuICogYWJvdXQgdmlhIGBzY29wZWA6XG4gKiAtIHRoZSBpbmxpbmUgb3duZWQtcmVjb3ZlcnkgY2VpbGluZyBjb3VudHMgb25seSBUSElTIG1lc3NhZ2UncyBzdGFydHNcbiAqICAgKGBvd25lZEJ5YCkg4oCUIGVhY2ggcmVhbCAocmUpZGVsaXZlcnkgb2YgdGhlIG93bmluZyBtZXNzYWdlIHN0YW1wcyBpdHNcbiAqICAgYG93bmVyTWVzc2FnZUlkYCBvbiB0aGUgc3RhcnQgaXQgd3JpdGVzLCB3aGlsZSByYWNpbmcgaW52b2NhdGlvbnMgc3RhbXBcbiAqICAgdGhlaXIgb3duIElEcyAob3Igbm9uZSksIHNvIHRoZXkgbm8gbG9uZ2VyIGluZmxhdGUgdGhlIGNvdW50O1xuICogLSB0aGUgYmFja2dyb3VuZC1zdGVwIGNlaWxpbmcgY291bnRzIHRoZSBsaWZlY3ljbGUgYXR0ZW1wdCB0b3RhbFxuICogICAoYHRvdGFsQXR0ZW1wdHNgOiBiYXJlIHN0YXJ0cyBwbHVzIHRoZSBsYXJnZXN0IHNpbmdsZSBvd25lcidzIHN0YXJ0cykg4oCUXG4gKiAgIHNvIGEgc3RlcCB0aGF0IGV4aGF1c3RlZCBwYXJ0IG9mIGl0cyBidWRnZXQgdW5kZXIgaW5saW5lIG93bmVyc2hpcFxuICogICBiZWZvcmUgdHJhbnNpdGlvbmluZyB0byBxdWV1ZWQvYmFyZSByZXRyaWVzIHN0aWxsIHRyaXBzIHRoZSBjb21iaW5lZFxuICogICBjZWlsaW5nLCB3aGlsZSByYWNlcnMnIG9uZS1vZmYgc3RhbXBlZCBkdXBsaWNhdGVzIGRvbid0IGFjY3VtdWxhdGUsIGFuZFxuICogICB0aHJvdHRsZS90b28tZWFybHkgcmVkZWxpdmVyaWVzICh3aGljaCB3cml0ZSBubyBzdGFydCBhdCBhbGwpIHN0YXlcbiAqICAgZXhjbHVkZWQgYXMgYmVmb3JlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY291bnRTdGVwU3RhcnRlZEV2ZW50cyhcbiAgZXZlbnRzOiBFdmVudFtdIHwgbnVsbCB8IHVuZGVmaW5lZCxcbiAgc3RlcElkOiBzdHJpbmcsXG4gIHNjb3BlPzogU3RlcFN0YXJ0U2NvcGVcbik6IG51bWJlciB7XG4gIGlmICghZXZlbnRzKSB7XG4gICAgcmV0dXJuIDA7XG4gIH1cbiAgbGV0IGJhcmUgPSAwO1xuICBjb25zdCBieU93bmVyID0gbmV3IE1hcDxzdHJpbmcsIG51bWJlcj4oKTtcbiAgZm9yIChjb25zdCBlIG9mIGV2ZW50cykge1xuICAgIGlmIChlLmV2ZW50VHlwZSAhPT0gJ3N0ZXBfc3RhcnRlZCcgfHwgZS5jb3JyZWxhdGlvbklkICE9PSBzdGVwSWQpIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cbiAgICBjb25zdCBvd25lciA9IG93bmVyT2YoZSk7XG4gICAgaWYgKG93bmVyID09PSB1bmRlZmluZWQpIHtcbiAgICAgIGJhcmUrKztcbiAgICB9IGVsc2Uge1xuICAgICAgYnlPd25lci5zZXQob3duZXIsIChieU93bmVyLmdldChvd25lcikgPz8gMCkgKyAxKTtcbiAgICB9XG4gIH1cbiAgaWYgKHNjb3BlID09PSB1bmRlZmluZWQpIHtcbiAgICBsZXQgdG90YWwgPSBiYXJlO1xuICAgIGZvciAoY29uc3QgY291bnQgb2YgYnlPd25lci52YWx1ZXMoKSkge1xuICAgICAgdG90YWwgKz0gY291bnQ7XG4gICAgfVxuICAgIHJldHVybiB0b3RhbDtcbiAgfVxuICBpZiAoc2NvcGUudHlwZSA9PT0gJ293bmVkQnknKSB7XG4gICAgcmV0dXJuIGJ5T3duZXIuZ2V0KHNjb3BlLm1lc3NhZ2VJZCkgPz8gMDtcbiAgfVxuICAvLyB0b3RhbEF0dGVtcHRzXG4gIGxldCBtYXhPd25lciA9IDA7XG4gIGZvciAoY29uc3QgY291bnQgb2YgYnlPd25lci52YWx1ZXMoKSkge1xuICAgIGlmIChjb3VudCA+IG1heE93bmVyKSB7XG4gICAgICBtYXhPd25lciA9IGNvdW50O1xuICAgIH1cbiAgfVxuICByZXR1cm4gYmFyZSArIG1heE93bmVyO1xufVxuIl19

package/dist/runtime/deployment-guard.d.ts

@@ -0,0 +1,99 @@
+import { type WorkflowRun, type World } from '@workflow/world';
+/**
+ * How the guard resolved a delivery. Both non-`continue` outcomes mean the
+ * caller must ack the message and return without executing anything.
+ */
+export type DeploymentAffinityOutcome = 
+/** The run belongs here (or this world has no deployment affinity). */
+'continue'
+/** Misrouted; re-enqueued at the run's own deployment. */
+ | 'rerouted'
+/** Misrouted and out of budget (or unroutable); `run_failed` recorded. */
+ | 'failed';
+/**
+ * `spanAttributes` is present only on a misrouted delivery — mismatches are
+ * rare, so the presence of `workflow.deployment.pinned_id` on a span *is* the
+ * signal that one happened, and `recovered` separates the ones a re-route fixed
+ * from the ones that kept misrouting.
+ */
+export interface DeploymentAffinityResult {
+    outcome: DeploymentAffinityOutcome;
+    spanAttributes?: Record<string, string | number | boolean>;
+}
+/**
+ * Arguments handed to a call site's re-enqueue closure. The guard owns the
+ * policy — counting, backoff, logging, telemetry, escalation — and the call
+ * site owns only the shape of the message it needs to put back on the queue.
+ */
+export interface ReenqueueArgs {
+    /** The deployment to target: the one the run is pinned to. */
+    deploymentId: string;
+    /**
+     * The run's spec version, so the world picks the right queue transport
+     * (CBOR vs JSON). Undefined on legacy runs that predate the field; worlds
+     * then fall back to their current default.
+     */
+    specVersion: number | undefined;
+    deploymentMismatchRetryCount: number;
+    /** Backoff before the re-routed message becomes visible. */
+    delaySeconds: number;
+}
+/**
+ * Guards deployment affinity: a run may only execute on the deployment it is
+ * pinned to.
+ *
+ * A run's `deploymentId` is fixed when it starts — the deployment that called
+ * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id
+ * or `'latest'`) — and no replay or step execution may happen anywhere else:
+ * the bundles here may not match the run's persisted history, and any step
+ * dispatched from here derives the per-run encryption key from the wrong
+ * deployment's master key, which surfaces as a `RuntimeDecryptionError` the
+ * queue retry callback swallows into a blank "exceeded max retries".
+ *
+ * A misrouted delivery is not treated as permanent. Rather than failing
+ * immediately, re-enqueue the message *explicitly targeted* at the run's own
+ * deployment; that send is strictly better-addressed than the one that
+ * misrouted, which inherited the producing deployment's ambient id. Fail only
+ * once the budget (`WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`, default 3) is
+ * spent, mirroring how a replay divergence gets bounded recovery replays before
+ * being recorded as a corrupted event log.
+ *
+ * Callers must pass a run entity they already have in hand — every call site
+ * loads the run for other reasons — so the guard costs no extra round trip.
+ * (`world.getDeploymentId()` reads the ambient deployment id, e.g.
+ * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)
+ *
+ * The failure is recorded **without resolving the run's encryption key**: the
+ * key is fetched from the pinned deployment's API, often unavailable once that
+ * deployment is past its retention window, so depending on it would throw here
+ * instead of recording the failure. The payload is written unencrypted (it
+ * holds only deployment ids, nothing sensitive), and the plaintext `errorCode`
+ * is the signal observability and the UI key off.
+ */
+export declare function guardDeploymentAffinity({ world, run, requestId, retryCount, reenqueue, isDeploymentUnavailableError, beforeStop, }: {
+    world: World;
+    run: Pick<WorkflowRun, 'runId' | 'deploymentId' | 'specVersion'>;
+    requestId?: string;
+    /** `deploymentMismatchRetryCount` from the incoming message, if any. */
+    retryCount?: number;
+    /**
+     * Puts this delivery's message back on the queue, targeted at the run's own
+     * deployment. Omitted by callers that cannot reconstruct their message, which
+     * makes the guard fail-fast.
+     */
+    reenqueue?: (args: ReenqueueArgs) => Promise<void>;
+    /**
+     * Classifies a re-enqueue failure as definitive proof that the pinned
+     * deployment cannot receive the message. Unclassified failures are retried
+     * by rejecting the handler and leaving the current queue message unacked.
+     */
+    isDeploymentUnavailableError?: (error: unknown) => boolean;
+    /**
+     * Ordering barrier awaited once a mismatch is confirmed, before either
+     * stopping action. Under turbo the `run_started` write is backgrounded, and
+     * both outcomes hand the run off (to a `run_failed` here, or to the pinned
+     * deployment's own `run_started`) — so that write must have landed first.
+     */
+    beforeStop?: () => Promise<void>;
+}): Promise<DeploymentAffinityResult>;
+//# sourceMappingURL=deployment-guard.d.ts.map

package/dist/runtime/deployment-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-guard.d.ts","sourceRoot":"","sources":["../../src/runtime/deployment-guard.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AASzB;;;GAGG;AACH,MAAM,MAAM,yBAAyB;AACnC,uEAAuE;AACrE,UAAU;AACZ,0DAA0D;GACxD,UAAU;AACZ,0EAA0E;GACxE,QAAQ,CAAC;AAEb;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,yBAAyB,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CAC5D;AAwBD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,8DAA8D;IAC9D,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,4BAA4B,EAAE,MAAM,CAAC;IACrC,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,KAAK,EACL,GAAG,EACH,SAAS,EACT,UAAc,EACd,SAAS,EACT,4BAA4B,EAC5B,UAAU,GACX,EAAE;IACD,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,GAAG,cAAc,GAAG,aAAa,CAAC,CAAC;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACnD;;;;OAIG;IACH,4BAA4B,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC3D;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAoIpC"}

package/dist/runtime/deployment-guard.js

@@ -0,0 +1,154 @@
+import { EntityConflictError, RUN_ERROR_CODES, RunExpiredError, WorkflowDeploymentMismatchError, } from '@workflow/errors';
+import { SPEC_VERSION_CURRENT, SPEC_VERSION_SUPPORTS_COMPRESSION, } from '@workflow/world';
+import { runtimeLogger } from '../logger.js';
+import { dehydrateRunError } from '../serialization.js';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { getDeploymentMismatchMaxRetries } from './constants.js';
+/** Cap on the re-route backoff, in seconds. */
+const MAX_REROUTE_DELAY_SECONDS = 8;
+/** The common case, allocation-free. */
+const CONTINUE = { outcome: 'continue' };
+/**
+ * Builds a stopping result. `attempts` is the re-route count *including* this
+ * invocation's own attempt, so the span attribute reads as "attempts so far".
+ */
+function result(outcome, pinnedDeploymentId, attempts) {
+    return {
+        outcome,
+        spanAttributes: {
+            ...Attribute.WorkflowRunPinnedDeploymentId(pinnedDeploymentId),
+            ...Attribute.WorkflowDeploymentMismatchRetryCount(attempts),
+            ...Attribute.WorkflowDeploymentMismatchRecovered(outcome === 'rerouted'),
+        },
+    };
+}
+/**
+ * Guards deployment affinity: a run may only execute on the deployment it is
+ * pinned to.
+ *
+ * A run's `deploymentId` is fixed when it starts — the deployment that called
+ * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id
+ * or `'latest'`) — and no replay or step execution may happen anywhere else:
+ * the bundles here may not match the run's persisted history, and any step
+ * dispatched from here derives the per-run encryption key from the wrong
+ * deployment's master key, which surfaces as a `RuntimeDecryptionError` the
+ * queue retry callback swallows into a blank "exceeded max retries".
+ *
+ * A misrouted delivery is not treated as permanent. Rather than failing
+ * immediately, re-enqueue the message *explicitly targeted* at the run's own
+ * deployment; that send is strictly better-addressed than the one that
+ * misrouted, which inherited the producing deployment's ambient id. Fail only
+ * once the budget (`WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`, default 3) is
+ * spent, mirroring how a replay divergence gets bounded recovery replays before
+ * being recorded as a corrupted event log.
+ *
+ * Callers must pass a run entity they already have in hand — every call site
+ * loads the run for other reasons — so the guard costs no extra round trip.
+ * (`world.getDeploymentId()` reads the ambient deployment id, e.g.
+ * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)
+ *
+ * The failure is recorded **without resolving the run's encryption key**: the
+ * key is fetched from the pinned deployment's API, often unavailable once that
+ * deployment is past its retention window, so depending on it would throw here
+ * instead of recording the failure. The payload is written unencrypted (it
+ * holds only deployment ids, nothing sensitive), and the plaintext `errorCode`
+ * is the signal observability and the UI key off.
+ */
+export async function guardDeploymentAffinity({ world, run, requestId, retryCount = 0, reenqueue, isDeploymentUnavailableError, beforeStop, }) {
+    // Deployment affinity is only meaningful in worlds whose deployments are
+    // atomic and immutable, which the World declares (world-vercel does) and
+    // capabilities default to unsupported. Local and self-hosted worlds report a
+    // synthetic deployment id (e.g. `dpl_local@<sdk-version>`) that legitimately
+    // differs across SDK versions within one logical environment, so guarding
+    // them would fail ordinary local runs after a version bump.
+    if (world.capabilities?.deploymentAffinity !== true) {
+        return CONTINUE;
+    }
+    const currentDeploymentId = await world.getDeploymentId();
+    if (run.deploymentId === currentDeploymentId) {
+        return CONTINUE;
+    }
+    await beforeStop?.();
+    const maxRetries = getDeploymentMismatchMaxRetries();
+    const logContext = {
+        workflowRunId: run.runId,
+        pinnedDeploymentId: run.deploymentId,
+        actualDeploymentId: currentDeploymentId,
+        retryCount,
+        maxRetries,
+    };
+    /**
+     * Records the terminal `run_failed`. Mirrors `recordFatalRunError`: it
+     * records and returns rather than throwing, so the caller acks the message
+     * instead of letting the queue redeliver a run that is now terminal.
+     */
+    const failRun = async (recoveryAttempts, cause) => {
+        const error = new WorkflowDeploymentMismatchError(run.runId, run.deploymentId, currentDeploymentId, { recoveryAttempts, cause });
+        try {
+            await world.events.create(run.runId, {
+                eventType: 'run_failed',
+                specVersion: SPEC_VERSION_CURRENT,
+                eventData: {
+                    // Unencrypted (undefined key): see the note on
+                    // `guardDeploymentAffinity`. dehydrate/hydrate are self-describing,
+                    // so this reads back without a key.
+                    error: await dehydrateRunError(error, run.runId, undefined, undefined, (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION),
+                    errorCode: RUN_ERROR_CODES.DEPLOYMENT_MISMATCH,
+                },
+            }, { requestId });
+        }
+        catch (failError) {
+            // Run already reached a terminal state (a concurrent writer failed it, or
+            // it was cancelled/expired) — still stop. Anything else is a transient
+            // persistence failure: rethrow so the queue redelivers and we try again.
+            if (!EntityConflictError.is(failError) &&
+                !RunExpiredError.is(failError)) {
+                throw failError;
+            }
+        }
+        return result('failed', run.deploymentId, recoveryAttempts);
+    };
+    if (reenqueue && retryCount < maxRetries) {
+        const attempt = retryCount + 1;
+        // Exponential, capped: 1s, 2s, 4s — cheap insurance against a hot
+        // re-enqueue loop, and time for a mid-flight routing change to settle.
+        const delaySeconds = Math.min(2 ** retryCount, MAX_REROUTE_DELAY_SECONDS);
+        try {
+            await reenqueue({
+                deploymentId: run.deploymentId,
+                specVersion: run.specVersion,
+                deploymentMismatchRetryCount: attempt,
+                delaySeconds,
+            });
+            runtimeLogger.warn('Workflow run received by a deployment it is not pinned to; re-routing to its own deployment', { ...logContext, attempt, delaySeconds });
+            return result('rerouted', run.deploymentId, attempt);
+        }
+        catch (reenqueueError) {
+            // A generic send failure can be transient (429, 5xx, connect/DNS). Do not
+            // turn one infrastructure blip into a terminal run failure: reject the
+            // handler so the current message remains unacked and is redelivered.
+            if (!isDeploymentUnavailableError?.(reenqueueError)) {
+                throw reenqueueError;
+            }
+            // The World explicitly classified the target as unavailable — deleted,
+            // aged out of its retention window, or otherwise undiscoverable. Burning
+            // the rest of the budget on a deployment that provably cannot be reached
+            // only delays the failure, so fail now.
+            runtimeLogger.error('Cannot re-route a misrouted workflow run to its own deployment; failing the run', {
+                ...logContext,
+                attempt,
+                errorMessage: reenqueueError instanceof Error
+                    ? reenqueueError.message
+                    : String(reenqueueError),
+            });
+            // Recovery never actually happened, so report 0 attempts and let `cause`
+            // explain why.
+            return failRun(0, reenqueueError);
+        }
+    }
+    runtimeLogger.error(retryCount > 0
+        ? 'Workflow run kept arriving at a deployment it is not pinned to after re-routing; failing the run'
+        : 'Workflow run received by a deployment it is not pinned to; failing the run', logContext);
+    return failRun(retryCount);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployment-guard.js","sourceRoot":"","sources":["../../src/runtime/deployment-guard.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EntityConflictError,\n  RUN_ERROR_CODES,\n  RunExpiredError,\n  WorkflowDeploymentMismatchError,\n} from '@workflow/errors';\nimport {\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateRunError } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getDeploymentMismatchMaxRetries } from './constants.js';\n\n/** Cap on the re-route backoff, in seconds. */\nconst MAX_REROUTE_DELAY_SECONDS = 8;\n\n/**\n * How the guard resolved a delivery. Both non-`continue` outcomes mean the\n * caller must ack the message and return without executing anything.\n */\nexport type DeploymentAffinityOutcome =\n  /** The run belongs here (or this world has no deployment affinity). */\n  | 'continue'\n  /** Misrouted; re-enqueued at the run's own deployment. */\n  | 'rerouted'\n  /** Misrouted and out of budget (or unroutable); `run_failed` recorded. */\n  | 'failed';\n\n/**\n * `spanAttributes` is present only on a misrouted delivery — mismatches are\n * rare, so the presence of `workflow.deployment.pinned_id` on a span *is* the\n * signal that one happened, and `recovered` separates the ones a re-route fixed\n * from the ones that kept misrouting.\n */\nexport interface DeploymentAffinityResult {\n  outcome: DeploymentAffinityOutcome;\n  spanAttributes?: Record<string, string | number | boolean>;\n}\n\n/** The common case, allocation-free. */\nconst CONTINUE: DeploymentAffinityResult = { outcome: 'continue' };\n\n/**\n * Builds a stopping result. `attempts` is the re-route count *including* this\n * invocation's own attempt, so the span attribute reads as \"attempts so far\".\n */\nfunction result(\n  outcome: 'rerouted' | 'failed',\n  pinnedDeploymentId: string,\n  attempts: number\n): DeploymentAffinityResult {\n  return {\n    outcome,\n    spanAttributes: {\n      ...Attribute.WorkflowRunPinnedDeploymentId(pinnedDeploymentId),\n      ...Attribute.WorkflowDeploymentMismatchRetryCount(attempts),\n      ...Attribute.WorkflowDeploymentMismatchRecovered(outcome === 'rerouted'),\n    },\n  };\n}\n\n/**\n * Arguments handed to a call site's re-enqueue closure. The guard owns the\n * policy — counting, backoff, logging, telemetry, escalation — and the call\n * site owns only the shape of the message it needs to put back on the queue.\n */\nexport interface ReenqueueArgs {\n  /** The deployment to target: the one the run is pinned to. */\n  deploymentId: string;\n  /**\n   * The run's spec version, so the world picks the right queue transport\n   * (CBOR vs JSON). Undefined on legacy runs that predate the field; worlds\n   * then fall back to their current default.\n   */\n  specVersion: number | undefined;\n  deploymentMismatchRetryCount: number;\n  /** Backoff before the re-routed message becomes visible. */\n  delaySeconds: number;\n}\n\n/**\n * Guards deployment affinity: a run may only execute on the deployment it is\n * pinned to.\n *\n * A run's `deploymentId` is fixed when it starts — the deployment that called\n * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id\n * or `'latest'`) — and no replay or step execution may happen anywhere else:\n * the bundles here may not match the run's persisted history, and any step\n * dispatched from here derives the per-run encryption key from the wrong\n * deployment's master key, which surfaces as a `RuntimeDecryptionError` the\n * queue retry callback swallows into a blank \"exceeded max retries\".\n *\n * A misrouted delivery is not treated as permanent. Rather than failing\n * immediately, re-enqueue the message *explicitly targeted* at the run's own\n * deployment; that send is strictly better-addressed than the one that\n * misrouted, which inherited the producing deployment's ambient id. Fail only\n * once the budget (`WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`, default 3) is\n * spent, mirroring how a replay divergence gets bounded recovery replays before\n * being recorded as a corrupted event log.\n *\n * Callers must pass a run entity they already have in hand — every call site\n * loads the run for other reasons — so the guard costs no extra round trip.\n * (`world.getDeploymentId()` reads the ambient deployment id, e.g.\n * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)\n *\n * The failure is recorded **without resolving the run's encryption key**: the\n * key is fetched from the pinned deployment's API, often unavailable once that\n * deployment is past its retention window, so depending on it would throw here\n * instead of recording the failure. The payload is written unencrypted (it\n * holds only deployment ids, nothing sensitive), and the plaintext `errorCode`\n * is the signal observability and the UI key off.\n */\nexport async function guardDeploymentAffinity({\n  world,\n  run,\n  requestId,\n  retryCount = 0,\n  reenqueue,\n  isDeploymentUnavailableError,\n  beforeStop,\n}: {\n  world: World;\n  run: Pick<WorkflowRun, 'runId' | 'deploymentId' | 'specVersion'>;\n  requestId?: string;\n  /** `deploymentMismatchRetryCount` from the incoming message, if any. */\n  retryCount?: number;\n  /**\n   * Puts this delivery's message back on the queue, targeted at the run's own\n   * deployment. Omitted by callers that cannot reconstruct their message, which\n   * makes the guard fail-fast.\n   */\n  reenqueue?: (args: ReenqueueArgs) => Promise<void>;\n  /**\n   * Classifies a re-enqueue failure as definitive proof that the pinned\n   * deployment cannot receive the message. Unclassified failures are retried\n   * by rejecting the handler and leaving the current queue message unacked.\n   */\n  isDeploymentUnavailableError?: (error: unknown) => boolean;\n  /**\n   * Ordering barrier awaited once a mismatch is confirmed, before either\n   * stopping action. Under turbo the `run_started` write is backgrounded, and\n   * both outcomes hand the run off (to a `run_failed` here, or to the pinned\n   * deployment's own `run_started`) — so that write must have landed first.\n   */\n  beforeStop?: () => Promise<void>;\n}): Promise<DeploymentAffinityResult> {\n  // Deployment affinity is only meaningful in worlds whose deployments are\n  // atomic and immutable, which the World declares (world-vercel does) and\n  // capabilities default to unsupported. Local and self-hosted worlds report a\n  // synthetic deployment id (e.g. `dpl_local@<sdk-version>`) that legitimately\n  // differs across SDK versions within one logical environment, so guarding\n  // them would fail ordinary local runs after a version bump.\n  if (world.capabilities?.deploymentAffinity !== true) {\n    return CONTINUE;\n  }\n\n  const currentDeploymentId = await world.getDeploymentId();\n  if (run.deploymentId === currentDeploymentId) {\n    return CONTINUE;\n  }\n\n  await beforeStop?.();\n\n  const maxRetries = getDeploymentMismatchMaxRetries();\n  const logContext = {\n    workflowRunId: run.runId,\n    pinnedDeploymentId: run.deploymentId,\n    actualDeploymentId: currentDeploymentId,\n    retryCount,\n    maxRetries,\n  };\n\n  /**\n   * Records the terminal `run_failed`. Mirrors `recordFatalRunError`: it\n   * records and returns rather than throwing, so the caller acks the message\n   * instead of letting the queue redeliver a run that is now terminal.\n   */\n  const failRun = async (\n    recoveryAttempts: number,\n    cause?: unknown\n  ): Promise<DeploymentAffinityResult> => {\n    const error = new WorkflowDeploymentMismatchError(\n      run.runId,\n      run.deploymentId,\n      currentDeploymentId,\n      { recoveryAttempts, cause }\n    );\n\n    try {\n      await world.events.create(\n        run.runId,\n        {\n          eventType: 'run_failed',\n          specVersion: SPEC_VERSION_CURRENT,\n          eventData: {\n            // Unencrypted (undefined key): see the note on\n            // `guardDeploymentAffinity`. dehydrate/hydrate are self-describing,\n            // so this reads back without a key.\n            error: await dehydrateRunError(\n              error,\n              run.runId,\n              undefined,\n              undefined,\n              (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION\n            ),\n            errorCode: RUN_ERROR_CODES.DEPLOYMENT_MISMATCH,\n          },\n        },\n        { requestId }\n      );\n    } catch (failError) {\n      // Run already reached a terminal state (a concurrent writer failed it, or\n      // it was cancelled/expired) — still stop. Anything else is a transient\n      // persistence failure: rethrow so the queue redelivers and we try again.\n      if (\n        !EntityConflictError.is(failError) &&\n        !RunExpiredError.is(failError)\n      ) {\n        throw failError;\n      }\n    }\n    return result('failed', run.deploymentId, recoveryAttempts);\n  };\n\n  if (reenqueue && retryCount < maxRetries) {\n    const attempt = retryCount + 1;\n    // Exponential, capped: 1s, 2s, 4s — cheap insurance against a hot\n    // re-enqueue loop, and time for a mid-flight routing change to settle.\n    const delaySeconds = Math.min(2 ** retryCount, MAX_REROUTE_DELAY_SECONDS);\n    try {\n      await reenqueue({\n        deploymentId: run.deploymentId,\n        specVersion: run.specVersion,\n        deploymentMismatchRetryCount: attempt,\n        delaySeconds,\n      });\n      runtimeLogger.warn(\n        'Workflow run received by a deployment it is not pinned to; re-routing to its own deployment',\n        { ...logContext, attempt, delaySeconds }\n      );\n      return result('rerouted', run.deploymentId, attempt);\n    } catch (reenqueueError) {\n      // A generic send failure can be transient (429, 5xx, connect/DNS). Do not\n      // turn one infrastructure blip into a terminal run failure: reject the\n      // handler so the current message remains unacked and is redelivered.\n      if (!isDeploymentUnavailableError?.(reenqueueError)) {\n        throw reenqueueError;\n      }\n\n      // The World explicitly classified the target as unavailable — deleted,\n      // aged out of its retention window, or otherwise undiscoverable. Burning\n      // the rest of the budget on a deployment that provably cannot be reached\n      // only delays the failure, so fail now.\n      runtimeLogger.error(\n        'Cannot re-route a misrouted workflow run to its own deployment; failing the run',\n        {\n          ...logContext,\n          attempt,\n          errorMessage:\n            reenqueueError instanceof Error\n              ? reenqueueError.message\n              : String(reenqueueError),\n        }\n      );\n      // Recovery never actually happened, so report 0 attempts and let `cause`\n      // explain why.\n      return failRun(0, reenqueueError);\n    }\n  }\n\n  runtimeLogger.error(\n    retryCount > 0\n      ? 'Workflow run kept arriving at a deployment it is not pinned to after re-routing; failing the run'\n      : 'Workflow run received by a deployment it is not pinned to; failing the run',\n    logContext\n  );\n  return failRun(retryCount);\n}\n"]}

package/dist/runtime/get-port-lazy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lazy loader for getPort that prevents bundlers (Turbopack, esbuild)
+ * from statically tracing @workflow/utils/get-port and its filesystem
+ * operations (readdir, readFile, readlink) into the flow route bundle.
+ *
+ * Uses createRequire with a dynamically constructed specifier so the
+ * dependency is invisible to bundler static analysis.
+ */
+export declare function getPortLazy(): Promise<number | undefined>;
+/**
+ * Resets the per-process port cache. Intended for tests; not used on the hot
+ * path. Callers must let any in-flight lookup settle (await the pending
+ * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `_cachedPort` after the reset and bleed into the next test.
+ */
+export declare function resetPortCacheForTesting(): void;
+/**
+ * Installs a fake port resolver and clears the cache. Test-only seam: the real
+ * resolver is loaded via `createRequire` with a runtime-built specifier (to
+ * hide it from bundlers), which also defeats module mocking, so injection is
+ * the only deterministic way to exercise the caching contract.
+ */
+export declare function setPortResolverForTesting(fn: () => Promise<number | undefined>): void;
+//# sourceMappingURL=get-port-lazy.d.ts.map

package/dist/runtime/get-port-lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAuBH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA4C/D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GACpC,IAAI,CAIN"}

package/dist/runtime/get-port-lazy.js

@@ -0,0 +1,92 @@
+/**
+ * Lazy loader for getPort that prevents bundlers (Turbopack, esbuild)
+ * from statically tracing @workflow/utils/get-port and its filesystem
+ * operations (readdir, readFile, readlink) into the flow route bundle.
+ *
+ * Uses createRequire with a dynamically constructed specifier so the
+ * dependency is invisible to bundler static analysis.
+ */
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+let _getPort;
+// Per-process cache of the resolved port. The workflow server listens on a
+// stable port for the lifetime of the process, but `getPort()` rediscovers it
+// on every call by querying the OS for the process's listening sockets — on
+// macOS that shells out to `lsof` (~60ms), which the runtime pays on EVERY
+// workflow replay or step invocation. Since the port does not change within a
+// process, resolve it once and reuse it. `_inFlight`
+// dedupes concurrent first calls so discovery never runs more than once.
+//
+// The first concrete port is pinned for the lifetime of the process — there is
+// no per-call re-resolution. This is safe because the runtime only runs inside
+// the already-listening dev-server process, and `getPort()` -> `getAllPorts()`
+// returns a deterministic order, so repeated calls would resolve the same port
+// anyway.
+let _cachedPort;
+let _inFlight;
+export async function getPortLazy() {
+    // Fast path: already resolved a concrete port for this process.
+    if (_cachedPort !== undefined) {
+        return _cachedPort;
+    }
+    // A discovery is already running — share it rather than starting a second.
+    if (_inFlight) {
+        return _inFlight;
+    }
+    if (!_getPort) {
+        try {
+            // Construct specifier at runtime to defeat bundler static analysis.
+            const spec = ['@workflow/utils', 'get-port'].join('/');
+            // Use process.cwd()-based createRequire for CJS/ESM compatibility.
+            // import.meta.url is unavailable in CJS re-bundled outputs.
+            const _require = createRequire(pathToFileURL(process.cwd() + '/package.json').href);
+            const mod = _require(spec);
+            _getPort = mod.getPort;
+        }
+        catch {
+            // Module not available (e.g., in a browser or minimal bundle)
+            _getPort = async () => undefined;
+        }
+    }
+    // `_getPort` is always assigned by the block above; the fallback keeps the
+    // type non-nullable without a non-null assertion.
+    const resolver = _getPort ?? (async () => undefined);
+    _inFlight = resolver()
+        .then((port) => {
+        // Only cache a concrete port. A transient `undefined` (e.g. the server is
+        // not listening yet on the very first replay) must not poison the cache —
+        // leaving it unset lets the next call retry discovery.
+        if (typeof port === 'number') {
+            _cachedPort = port;
+        }
+        return port;
+    })
+        .finally(() => {
+        _inFlight = undefined;
+    });
+    return _inFlight;
+}
+/**
+ * Resets the per-process port cache. Intended for tests; not used on the hot
+ * path. Callers must let any in-flight lookup settle (await the pending
+ * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `_cachedPort` after the reset and bleed into the next test.
+ */
+export function resetPortCacheForTesting() {
+    _getPort = undefined;
+    _cachedPort = undefined;
+    _inFlight = undefined;
+}
+/**
+ * Installs a fake port resolver and clears the cache. Test-only seam: the real
+ * resolver is loaded via `createRequire` with a runtime-built specifier (to
+ * hide it from bundlers), which also defeats module mocking, so injection is
+ * the only deterministic way to exercise the caching contract.
+ */
+export function setPortResolverForTesting(fn) {
+    _getPort = fn;
+    _cachedPort = undefined;
+    _inFlight = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/get-world-lazy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lazy accessor for the World singleton via globalThis symbols.
+ *
+ * This module exists to break the static import chain from step-side
+ * modules (serialization, run, helpers, start) to world.ts. Without it,
+ * esbuild bundles world.ts (and its transitive deps: world-local,
+ * world-vercel, process.cwd(), etc.) into the step registrations bundle,
+ * which triggers Turbopack NFT tracing errors in the V2 combined flow route.
+ *
+ * Resolution order, in priority:
+ *
+ * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ *    `getWorld()` call. This is the steady-state hot path.
+ * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ *    effect at the bottom of `./world.ts`. Fires on every server bundle
+ *    that reaches this file via `workflow` or `workflow/api` (which import
+ *    `./world-init.ts` for its side effect; see that file for the full
+ *    rationale). This is the cold-start path for routes that consume host
+ *    helpers without any prior workflow run.
+ */
+import type { World } from '@workflow/world';
+export declare function getWorldLazy(): Promise<World>;
+//# sourceMappingURL=get-world-lazy.d.ts.map

package/dist/runtime/get-world-lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-world-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-world-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAa7C,wBAAsB,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC,CAsBnD"}

package/dist/runtime/get-world-lazy.js

@@ -0,0 +1,46 @@
+/**
+ * Lazy accessor for the World singleton via globalThis symbols.
+ *
+ * This module exists to break the static import chain from step-side
+ * modules (serialization, run, helpers, start) to world.ts. Without it,
+ * esbuild bundles world.ts (and its transitive deps: world-local,
+ * world-vercel, process.cwd(), etc.) into the step registrations bundle,
+ * which triggers Turbopack NFT tracing errors in the V2 combined flow route.
+ *
+ * Resolution order, in priority:
+ *
+ * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ *    `getWorld()` call. This is the steady-state hot path.
+ * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ *    effect at the bottom of `./world.ts`. Fires on every server bundle
+ *    that reaches this file via `workflow` or `workflow/api` (which import
+ *    `./world-init.ts` for its side effect; see that file for the full
+ *    rationale). This is the cold-start path for routes that consume host
+ *    helpers without any prior workflow run.
+ */
+import { assertWorldSupportsRuntimeProtocol } from './world-compatibility.js';
+const WorldCacheKey = Symbol.for('@workflow/world//cache');
+const WorldCachePromiseKey = Symbol.for('@workflow/world//cachePromise');
+const GetWorldFnKey = Symbol.for('@workflow/world//getWorldFn');
+export async function getWorldLazy() {
+    const g = globalThis;
+    if (g[WorldCacheKey]) {
+        assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
+        return g[WorldCacheKey];
+    }
+    if (g[WorldCachePromiseKey]) {
+        g[WorldCacheKey] = await g[WorldCachePromiseKey];
+        assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
+        return g[WorldCacheKey];
+    }
+    // world-init statically imports world.ts in host bundles, which registers
+    // getWorld on globalThis at module load.
+    const getWorldFn = g[GetWorldFnKey];
+    if (getWorldFn) {
+        const world = await getWorldFn();
+        assertWorldSupportsRuntimeProtocol(world);
+        return world;
+    }
+    throw new Error('Workflow world runtime was not initialized. Import from the host workflow entrypoints (`workflow`, `workflow/api`, or `workflow/runtime`) so @workflow/core/runtime/world-init can register getWorld before getWorldLazy() is used.');
+}
+//# sourceMappingURL=data:application/json;base64,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