@workflow/core 5.0.0-beta.5 → 5.0.0-beta.50

package/dist/runtime/count-step-started-events.d.ts

@@ -0,0 +1,52 @@
+import type { Event } from '@workflow/world';
+/**
+ * Scope for {@link countStepStartedEvents}:
+ * - `{ type: 'ownedBy', messageId }` counts only starts whose
+ *   `eventData.ownerMessageId` matches, i.e. attempts performed by that
+ *   owning queue message (inline lazy starts and owned-recovery re-stamps).
+ * - `{ type: 'totalAttempts' }` estimates the step's genuine attempt total
+ *   across its whole lifecycle: unstamped (bare) starts, which only real
+ *   queue-dispatched background deliveries write, plus the starts of the
+ *   single most-started owner. A genuine lifecycle has at most one inline
+ *   owner phase (ownership is claimed atomically at step creation and
+ *   lapses permanently at `step_retrying` or on any bare start), so taking
+ *   the max over owners counts that phase's real attempts while invocations
+ *   racing on the same batch, which stamp their own one-off message IDs,
+ *   contribute at most their single largest count instead of accumulating.
+ */
+export type StepStartScope = {
+    type: 'ownedBy';
+    messageId: string;
+} | {
+    type: 'totalAttempts';
+};
+/**
+ * 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 declare function countStepStartedEvents(events: Event[] | null | undefined, stepId: string, scope?: StepStartScope): number;
+//# sourceMappingURL=count-step-started-events.d.ts.map

package/dist/runtime/count-step-started-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count-step-started-events.d.ts","sourceRoot":"","sources":["../../src/runtime/count-step-started-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,CAAC;AAU9B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,GAAG,SAAS,EAClC,MAAM,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,cAAc,GACrB,MAAM,CAmCR"}

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnQtc3RlcC1zdGFydGVkLWV2ZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL2NvdW50LXN0ZXAtc3RhcnRlZC1ldmVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBcUJBLE1BQU0sT0FBTyxHQUFHLENBQUMsQ0FBUSxFQUFzQixFQUFFLENBQy9DLFdBQVcsSUFBSSxDQUFDO0lBQ2hCLENBQUMsQ0FBQyxTQUFTO0lBQ1gsZ0JBQWdCLElBQUksQ0FBQyxDQUFDLFNBQVM7SUFDL0IsT0FBTyxDQUFDLENBQUMsU0FBUyxDQUFDLGNBQWMsS0FBSyxRQUFRO0lBQzVDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLGNBQWM7SUFDNUIsQ0FBQyxDQUFDLFNBQVMsQ0FBQztBQUVoQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMkJHO0FBQ0gsTUFBTSxVQUFVLHNCQUFzQixDQUNwQyxNQUFrQyxFQUNsQyxNQUFjLEVBQ2QsS0FBc0I7SUFFdEIsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osT0FBTyxDQUFDLENBQUM7SUFDWCxDQUFDO0lBQ0QsSUFBSSxJQUFJLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUM7SUFDMUMsS0FBSyxNQUFNLENBQUMsSUFBSSxNQUFNLEVBQUUsQ0FBQztRQUN2QixJQUFJLENBQUMsQ0FBQyxTQUFTLEtBQUssY0FBYyxJQUFJLENBQUMsQ0FBQyxhQUFhLEtBQUssTUFBTSxFQUFFLENBQUM7WUFDakUsU0FBUztRQUNYLENBQUM7UUFDRCxNQUFNLEtBQUssR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDekIsSUFBSSxLQUFLLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDeEIsSUFBSSxFQUFFLENBQUM7UUFDVCxDQUFDO2FBQU0sQ0FBQztZQUNOLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUNwRCxDQUFDO0lBQ0gsQ0FBQztJQUNELElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1FBQ3hCLElBQUksS0FBSyxHQUFHLElBQUksQ0FBQztRQUNqQixLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDO1lBQ3JDLEtBQUssSUFBSSxLQUFLLENBQUM7UUFDakIsQ0FBQztRQUNELE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUNELElBQUksS0FBSyxDQUFDLElBQUksS0FBSyxTQUFTLEVBQUUsQ0FBQztRQUM3QixPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBQ0QsZ0JBQWdCO0lBQ2hCLElBQUksUUFBUSxHQUFHLENBQUMsQ0FBQztJQUNqQixLQUFLLE1BQU0sS0FBSyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDO1FBQ3JDLElBQUksS0FBSyxHQUFHLFFBQVEsRUFBRSxDQUFDO1lBQ3JCLFFBQVEsR0FBRyxLQUFLLENBQUM7UUFDbkIsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLElBQUksR0FBRyxRQUFRLENBQUM7QUFDekIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRXZlbnQgfSBmcm9tICdAd29ya2Zsb3cvd29ybGQnO1xuXG4vKipcbiAqIFNjb3BlIGZvciB7QGxpbmsgY291bnRTdGVwU3RhcnRlZEV2ZW50c306XG4gKiAtIGB7IHR5cGU6ICdvd25lZEJ5JywgbWVzc2FnZUlkIH1gIGNvdW50cyBvbmx5IHN0YXJ0cyB3aG9zZVxuICogICBgZXZlbnREYXRhLm93bmVyTWVzc2FnZUlkYCBtYXRjaGVzLCBpLmUuIGF0dGVtcHRzIHBlcmZvcm1lZCBieSB0aGF0XG4gKiAgIG93bmluZyBxdWV1ZSBtZXNzYWdlIChpbmxpbmUgbGF6eSBzdGFydHMgYW5kIG93bmVkLXJlY292ZXJ5IHJlLXN0YW1wcykuXG4gKiAtIGB7IHR5cGU6ICd0b3RhbEF0dGVtcHRzJyB9YCBlc3RpbWF0ZXMgdGhlIHN0ZXAncyBnZW51aW5lIGF0dGVtcHQgdG90YWxcbiAqICAgYWNyb3NzIGl0cyB3aG9sZSBsaWZlY3ljbGU6IHVuc3RhbXBlZCAoYmFyZSkgc3RhcnRzLCB3aGljaCBvbmx5IHJlYWxcbiAqICAgcXVldWUtZGlzcGF0Y2hlZCBiYWNrZ3JvdW5kIGRlbGl2ZXJpZXMgd3JpdGUsIHBsdXMgdGhlIHN0YXJ0cyBvZiB0aGVcbiAqICAgc2luZ2xlIG1vc3Qtc3RhcnRlZCBvd25lci4gQSBnZW51aW5lIGxpZmVjeWNsZSBoYXMgYXQgbW9zdCBvbmUgaW5saW5lXG4gKiAgIG93bmVyIHBoYXNlIChvd25lcnNoaXAgaXMgY2xhaW1lZCBhdG9taWNhbGx5IGF0IHN0ZXAgY3JlYXRpb24gYW5kXG4gKiAgIGxhcHNlcyBwZXJtYW5lbnRseSBhdCBgc3RlcF9yZXRyeWluZ2Agb3Igb24gYW55IGJhcmUgc3RhcnQpLCBzbyB0YWtpbmdcbiAqICAgdGhlIG1heCBvdmVyIG93bmVycyBjb3VudHMgdGhhdCBwaGFzZSdzIHJlYWwgYXR0ZW1wdHMgd2hpbGUgaW52b2NhdGlvbnNcbiAqICAgcmFjaW5nIG9uIHRoZSBzYW1lIGJhdGNoLCB3aGljaCBzdGFtcCB0aGVpciBvd24gb25lLW9mZiBtZXNzYWdlIElEcyxcbiAqICAgY29udHJpYnV0ZSBhdCBtb3N0IHRoZWlyIHNpbmdsZSBsYXJnZXN0IGNvdW50IGluc3RlYWQgb2YgYWNjdW11bGF0aW5nLlxuICovXG5leHBvcnQgdHlwZSBTdGVwU3RhcnRTY29wZSA9XG4gIHwgeyB0eXBlOiAnb3duZWRCeSc7IG1lc3NhZ2VJZDogc3RyaW5nIH1cbiAgfCB7IHR5cGU6ICd0b3RhbEF0dGVtcHRzJyB9O1xuXG5jb25zdCBvd25lck9mID0gKGU6IEV2ZW50KTogc3RyaW5nIHwgdW5kZWZpbmVkID0+XG4gICdldmVudERhdGEnIGluIGUgJiZcbiAgZS5ldmVudERhdGEgJiZcbiAgJ293bmVyTWVzc2FnZUlkJyBpbiBlLmV2ZW50RGF0YSAmJlxuICB0eXBlb2YgZS5ldmVudERhdGEub3duZXJNZXNzYWdlSWQgPT09ICdzdHJpbmcnXG4gICAgPyBlLmV2ZW50RGF0YS5vd25lck1lc3NhZ2VJZFxuICAgIDogdW5kZWZpbmVkO1xuXG4vKipcbiAqIE51bWJlciBvZiBgc3RlcF9zdGFydGVkYCBldmVudHMgYWxyZWFkeSByZWNvcmRlZCBmb3IgYSBzdGVwLCB1c2VkIGFzIHRoZVxuICogYXV0aG9yaXRhdGl2ZSBhdHRlbXB0IGNvdW50IGZvciB0aGUgbWF4UmV0cmllcyBjZWlsaW5nICh0aGUgb25seSBib3VuZCBmb3JcbiAqIHN0ZXBzIHRoYXQgdGltZSBvdXQgd2l0aG91dCB3cml0aW5nIGEgYHN0ZXBfZmFpbGVkYCkuXG4gKlxuICogSU1QT1JUQU5UOiB0aGUgcmF3ICh1bnNjb3BlZCkgY291bnQgaXMgTk9UIGEgcmVsaWFibGUgYXR0ZW1wdCBudW1iZXIuXG4gKiBDb25jdXJyZW50IGludm9jYXRpb25zIHJhY2luZyBvbiB0aGUgc2FtZSBwZW5kaW5nIGJhdGNoIChzdGFsZSByZXBsYXlzLFxuICogd2FrZSByZXBsYXlzLCBhIHN0ZXAgbWVzc2FnZSBkaXNwYXRjaGVkIGJ5IGEgcmVwbGF5IHRoYXQgbG9zdCB0aGVcbiAqIGNyZWF0ZS1jbGFpbSByYWNlLCAuLi4pIGNhbiBlYWNoIHdyaXRlIGEgYHN0ZXBfc3RhcnRlZGAgZm9yIHRoZSBzYW1lXG4gKiBsb2dpY2FsIGF0dGVtcHQuIFdvcmxkcyB3aXRob3V0IGFuIGF0b21pYyBzdGFydCBndWFyZCAod29ybGQtbG9jYWwpIGxldFxuICogYWxsIG9mIHRoZW0gdGhyb3VnaC4gQ291bnRpbmcgdGhvc2UgZHVwbGljYXRlcyBhcyBcImF0dGVtcHRzXCIgbWFkZSB0aGVcbiAqIG1heFJldHJpZXMgY2VpbGluZyBmaXJlIG9uIGhlYWx0aHkgcnVucyBhbmQgZmFpbCB0aGVtIHdpdGggYSBmYWxzZVxuICogXCJleGNlZWRlZCBtYXggcmV0cmllc1wiIChzZWUgd29ya2Zsb3cjMzA2OSkuXG4gKlxuICogQ2FsbGVycyB0aGVyZWZvcmUgc2NvcGUgdGhlIGNvdW50IHRvIHRoZSBzdGFydHMgdGhlaXIgY2VpbGluZyBpcyBhY3R1YWxseVxuICogYWJvdXQgdmlhIGBzY29wZWA6XG4gKiAtIHRoZSBpbmxpbmUgb3duZWQtcmVjb3ZlcnkgY2VpbGluZyBjb3VudHMgb25seSBUSElTIG1lc3NhZ2UncyBzdGFydHNcbiAqICAgKGBvd25lZEJ5YCk6IGVhY2ggcmVhbCAocmUpZGVsaXZlcnkgb2YgdGhlIG93bmluZyBtZXNzYWdlIHN0YW1wcyBpdHNcbiAqICAgYG93bmVyTWVzc2FnZUlkYCBvbiB0aGUgc3RhcnQgaXQgd3JpdGVzLCB3aGlsZSByYWNpbmcgaW52b2NhdGlvbnMgc3RhbXBcbiAqICAgdGhlaXIgb3duIElEcyAob3Igbm9uZSksIHNvIHRoZXkgbm8gbG9uZ2VyIGluZmxhdGUgdGhlIGNvdW50O1xuICogLSB0aGUgYmFja2dyb3VuZC1zdGVwIGNlaWxpbmcgY291bnRzIHRoZSBsaWZlY3ljbGUgYXR0ZW1wdCB0b3RhbFxuICogICAoYHRvdGFsQXR0ZW1wdHNgOiBiYXJlIHN0YXJ0cyBwbHVzIHRoZSBsYXJnZXN0IHNpbmdsZSBvd25lcidzIHN0YXJ0cyksXG4gKiAgIHNvIGEgc3RlcCB0aGF0IGV4aGF1c3RlZCBwYXJ0IG9mIGl0cyBidWRnZXQgdW5kZXIgaW5saW5lIG93bmVyc2hpcFxuICogICBiZWZvcmUgdHJhbnNpdGlvbmluZyB0byBxdWV1ZWQvYmFyZSByZXRyaWVzIHN0aWxsIHRyaXBzIHRoZSBjb21iaW5lZFxuICogICBjZWlsaW5nLCB3aGlsZSByYWNlcnMnIG9uZS1vZmYgc3RhbXBlZCBkdXBsaWNhdGVzIGRvbid0IGFjY3VtdWxhdGUsIGFuZFxuICogICB0aHJvdHRsZS90b28tZWFybHkgcmVkZWxpdmVyaWVzICh3aGljaCB3cml0ZSBubyBzdGFydCBhdCBhbGwpIHN0YXlcbiAqICAgZXhjbHVkZWQgYXMgYmVmb3JlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY291bnRTdGVwU3RhcnRlZEV2ZW50cyhcbiAgZXZlbnRzOiBFdmVudFtdIHwgbnVsbCB8IHVuZGVmaW5lZCxcbiAgc3RlcElkOiBzdHJpbmcsXG4gIHNjb3BlPzogU3RlcFN0YXJ0U2NvcGVcbik6IG51bWJlciB7XG4gIGlmICghZXZlbnRzKSB7XG4gICAgcmV0dXJuIDA7XG4gIH1cbiAgbGV0IGJhcmUgPSAwO1xuICBjb25zdCBieU93bmVyID0gbmV3IE1hcDxzdHJpbmcsIG51bWJlcj4oKTtcbiAgZm9yIChjb25zdCBlIG9mIGV2ZW50cykge1xuICAgIGlmIChlLmV2ZW50VHlwZSAhPT0gJ3N0ZXBfc3RhcnRlZCcgfHwgZS5jb3JyZWxhdGlvbklkICE9PSBzdGVwSWQpIHtcbiAgICAgIGNvbnRpbnVlO1xuICAgIH1cbiAgICBjb25zdCBvd25lciA9IG93bmVyT2YoZSk7XG4gICAgaWYgKG93bmVyID09PSB1bmRlZmluZWQpIHtcbiAgICAgIGJhcmUrKztcbiAgICB9IGVsc2Uge1xuICAgICAgYnlPd25lci5zZXQob3duZXIsIChieU93bmVyLmdldChvd25lcikgPz8gMCkgKyAxKTtcbiAgICB9XG4gIH1cbiAgaWYgKHNjb3BlID09PSB1bmRlZmluZWQpIHtcbiAgICBsZXQgdG90YWwgPSBiYXJlO1xuICAgIGZvciAoY29uc3QgY291bnQgb2YgYnlPd25lci52YWx1ZXMoKSkge1xuICAgICAgdG90YWwgKz0gY291bnQ7XG4gICAgfVxuICAgIHJldHVybiB0b3RhbDtcbiAgfVxuICBpZiAoc2NvcGUudHlwZSA9PT0gJ293bmVkQnknKSB7XG4gICAgcmV0dXJuIGJ5T3duZXIuZ2V0KHNjb3BlLm1lc3NhZ2VJZCkgPz8gMDtcbiAgfVxuICAvLyB0b3RhbEF0dGVtcHRzXG4gIGxldCBtYXhPd25lciA9IDA7XG4gIGZvciAoY29uc3QgY291bnQgb2YgYnlPd25lci52YWx1ZXMoKSkge1xuICAgIGlmIChjb3VudCA+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'`). 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'`). 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 canceled/expired), so 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'`). 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 canceled/expired), so 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

@@ -7,4 +7,19 @@
  * 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 `portState.inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `portState.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

@@ -1 +1 @@
-{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkB/D"}
+{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA8BH,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

@@ -8,9 +8,39 @@
  */
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
-let _getPort;
+import { globalSingleton } from '@workflow/utils';
+// All three live on `globalThis` (see `globalSingleton`) rather than at module
+// scope. The resolved port is a fact about the process, not about one copy of
+// this module, and per-copy caches would each pay the ~60ms `lsof` discovery
+// and could each pin their own answer.
+const portState = globalSingleton('@workflow/core//devServerPort', 1, () => ({
+    getPort: undefined,
+    cachedPort: undefined,
+    inFlight: undefined,
+}));
+// 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. `portState.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.
 export async function getPortLazy() {
-    if (!_getPort) {
+    // Fast path: already resolved a concrete port for this process.
+    if (portState.cachedPort !== undefined) {
+        return portState.cachedPort;
+    }
+    // A discovery is already running, so share it rather than starting a second.
+    if (portState.inFlight) {
+        return portState.inFlight;
+    }
+    if (!portState.getPort) {
         try {
             // Construct specifier at runtime to defeat bundler static analysis.
             const spec = ['@workflow/utils', 'get-port'].join('/');
@@ -18,13 +48,52 @@ export async function getPortLazy() {
             // 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;
+            portState.getPort = mod.getPort;
         }
         catch {
             // Module not available (e.g., in a browser or minimal bundle)
-            _getPort = async () => undefined;
+            portState.getPort = async () => undefined;
         }
     }
-    return _getPort();
+    // `portState.getPort` is always assigned by the block above; the fallback keeps the
+    // type non-nullable without a non-null assertion.
+    const resolver = portState.getPort ?? (async () => undefined);
+    portState.inFlight = resolver()
+        .then((port) => {
+        // Only cache a concrete port. A transient `undefined` (e.g. the server is
+        // not listening yet on the first replay) must not poison the cache:
+        // leaving it unset lets the next call retry discovery.
+        if (typeof port === 'number') {
+            portState.cachedPort = port;
+        }
+        return port;
+    })
+        .finally(() => {
+        portState.inFlight = undefined;
+    });
+    return portState.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 `portState.inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `portState.cachedPort` after the reset and bleed into the next test.
+ */
+export function resetPortCacheForTesting() {
+    portState.getPort = undefined;
+    portState.cachedPort = undefined;
+    portState.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) {
+    portState.getPort = fn;
+    portState.cachedPort = undefined;
+    portState.inFlight = undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-port-lazy.js","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,+EAA+E;AAC/E,8EAA8E;AAC9E,6EAA6E;AAC7E,uCAAuC;AACvC,MAAM,SAAS,GAAG,eAAe,CAAC,+BAA+B,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IAC3E,OAAO,EAAE,SAA4D;IACrE,UAAU,EAAE,SAA+B;IAC3C,QAAQ,EAAE,SAAoD;CAC/D,CAAC,CAAC,CAAC;AAEJ,2EAA2E;AAC3E,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,8DAA8D;AAC9D,yEAAyE;AACzE,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,+EAA+E;AAC/E,+EAA+E;AAC/E,UAAU;AAEV,MAAM,CAAC,KAAK,UAAU,WAAW;IAC/B,gEAAgE;IAChE,IAAI,SAAS,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO,SAAS,CAAC,UAAU,CAAC;IAC9B,CAAC;IACD,6EAA6E;IAC7E,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC;YACH,oEAAoE;YACpE,MAAM,IAAI,GAAG,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACvD,mEAAmE;YACnE,4DAA4D;YAC5D,MAAM,QAAQ,GAAG,aAAa,CAC5B,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC,CAAC,IAAI,CACpD,CAAC;YACF,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC3B,SAAS,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,8DAA8D;YAC9D,SAAS,CAAC,OAAO,GAAG,KAAK,IAAI,EAAE,CAAC,SAAS,CAAC;QAC5C,CAAC;IACH,CAAC;IAED,oFAAoF;IACpF,kDAAkD;IAClD,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC;IAC9D,SAAS,CAAC,QAAQ,GAAG,QAAQ,EAAE;SAC5B,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QACb,0EAA0E;QAC1E,oEAAoE;QACpE,uDAAuD;QACvD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC;QAC9B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;SACD,OAAO,CAAC,GAAG,EAAE;QACZ,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC;IACjC,CAAC,CAAC,CAAC;IACL,OAAO,SAAS,CAAC,QAAQ,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB;IACtC,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC;IAC9B,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACvC,EAAqC;IAErC,SAAS,CAAC,OAAO,GAAG,EAAE,CAAC;IACvB,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC;AACjC,CAAC","sourcesContent":["/**\n * Lazy loader for getPort that prevents bundlers (Turbopack, esbuild)\n * from statically tracing @workflow/utils/get-port and its filesystem\n * operations (readdir, readFile, readlink) into the flow route bundle.\n *\n * Uses createRequire with a dynamically constructed specifier so the\n * dependency is invisible to bundler static analysis.\n */\n\nimport { createRequire } from 'node:module';\nimport { pathToFileURL } from 'node:url';\nimport { globalSingleton } from '@workflow/utils';\n\n// All three live on `globalThis` (see `globalSingleton`) rather than at module\n// scope. The resolved port is a fact about the process, not about one copy of\n// this module, and per-copy caches would each pay the ~60ms `lsof` discovery\n// and could each pin their own answer.\nconst portState = globalSingleton('@workflow/core//devServerPort', 1, () => ({\n  getPort: undefined as (() => Promise<number | undefined>) | undefined,\n  cachedPort: undefined as number | undefined,\n  inFlight: undefined as Promise<number | undefined> | undefined,\n}));\n\n// Per-process cache of the resolved port. The workflow server listens on a\n// stable port for the lifetime of the process, but `getPort()` rediscovers it\n// on every call by querying the OS for the process's listening sockets. On\n// macOS that shells out to `lsof` (~60ms), which the runtime pays on EVERY\n// workflow replay or step invocation. Since the port does not change within a\n// process, resolve it once and reuse it. `portState.inFlight`\n// dedupes concurrent first calls so discovery never runs more than once.\n//\n// The first concrete port is pinned for the lifetime of the process: there is\n// no per-call re-resolution. This is safe because the runtime only runs inside\n// the already-listening dev-server process, and `getPort()` -> `getAllPorts()`\n// returns a deterministic order, so repeated calls would resolve the same port\n// anyway.\n\nexport async function getPortLazy(): Promise<number | undefined> {\n  // Fast path: already resolved a concrete port for this process.\n  if (portState.cachedPort !== undefined) {\n    return portState.cachedPort;\n  }\n  // A discovery is already running, so share it rather than starting a second.\n  if (portState.inFlight) {\n    return portState.inFlight;\n  }\n\n  if (!portState.getPort) {\n    try {\n      // Construct specifier at runtime to defeat bundler static analysis.\n      const spec = ['@workflow/utils', 'get-port'].join('/');\n      // Use process.cwd()-based createRequire for CJS/ESM compatibility.\n      // import.meta.url is unavailable in CJS re-bundled outputs.\n      const _require = createRequire(\n        pathToFileURL(process.cwd() + '/package.json').href\n      );\n      const mod = _require(spec);\n      portState.getPort = mod.getPort;\n    } catch {\n      // Module not available (e.g., in a browser or minimal bundle)\n      portState.getPort = async () => undefined;\n    }\n  }\n\n  // `portState.getPort` is always assigned by the block above; the fallback keeps the\n  // type non-nullable without a non-null assertion.\n  const resolver = portState.getPort ?? (async () => undefined);\n  portState.inFlight = resolver()\n    .then((port) => {\n      // Only cache a concrete port. A transient `undefined` (e.g. the server is\n      // not listening yet on the first replay) must not poison the cache:\n      // leaving it unset lets the next call retry discovery.\n      if (typeof port === 'number') {\n        portState.cachedPort = port;\n      }\n      return port;\n    })\n    .finally(() => {\n      portState.inFlight = undefined;\n    });\n  return portState.inFlight;\n}\n\n/**\n * Resets the per-process port cache. Intended for tests; not used on the hot\n * path. Callers must let any in-flight lookup settle (await the pending\n * `getPortLazy()` call) before resetting: clearing `portState.inFlight` here does not\n * cancel an already-scheduled resolution, so a late `.then` could otherwise\n * repopulate `portState.cachedPort` after the reset and bleed into the next test.\n */\nexport function resetPortCacheForTesting(): void {\n  portState.getPort = undefined;\n  portState.cachedPort = undefined;\n  portState.inFlight = undefined;\n}\n\n/**\n * Installs a fake port resolver and clears the cache. Test-only seam: the real\n * resolver is loaded via `createRequire` with a runtime-built specifier (to\n * hide it from bundlers), which also defeats module mocking, so injection is\n * the only deterministic way to exercise the caching contract.\n */\nexport function setPortResolverForTesting(\n  fn: () => Promise<number | undefined>\n): void {\n  portState.getPort = fn;\n  portState.cachedPort = undefined;\n  portState.inFlight = undefined;\n}\n"]}

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

@@ -9,23 +9,14 @@
  *
  * Resolution order, in priority:
  *
- * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ * 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
+ * 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/api` (which imports
+ *    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
- *    `start` without any prior workflow run.
- * 3. Dynamic `import('./world.js')` — last-resort fallback for
- *    environments where neither (1) nor (2) is available (CJS test
- *    runners, scripts that import deeply into `@workflow/core` without
- *    going through `workflow/api`, future bundlers we haven't validated).
- *    The specifier is built at runtime so esbuild can't trace it into
- *    step bundles. Note: this branch is unreliable in webpack-bundled
- *    routes because webpack inlines this module into the route file and
- *    the relative path resolves against the bundle location — paths (1)
- *    and (2) cover those cases instead.
+ *    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>;

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

@@ -1 +1 @@
-{"version":3,"file":"get-world-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-world-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAM7C,wBAAsB,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC,CAoBnD"}
+{"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"}