@workflow/core 5.0.0-beta.51 → 5.0.0-beta.53

package/dist/types.d.ts

@@ -1,5 +1,27 @@
 export declare function getErrorName(v: unknown): string;
 export declare function getErrorStack(v: unknown): string;
+/**
+ * Summarize the `cause` chain hanging off a thrown value, one link per line,
+ * outermost first. The value itself is skipped: whatever logs this already
+ * states it, in the message or in the stack header.
+ *
+ * `util.inspect` renders `[cause]` when Node prints an error, but the
+ * structured logs read `name` / `message` / `stack` and drop everything else
+ * — exactly the wrong half for errors that arrive pre-wrapped.
+ * `TypeError: fetch failed` is the canonical one: undici's wrapper says
+ * nothing on its own and its stack is all `node:internal/` frames, so the DNS,
+ * socket or TLS failure that actually happened is only readable one or two
+ * `cause` hops down. Same for the world layer's own wrapping, where the
+ * request that failed is on the wrapper and the reason it failed is on the
+ * cause.
+ *
+ * `AggregateError` also gets its `errors` summarized, because a
+ * happy-eyeballs connect reports every attempt there and leaves the
+ * `AggregateError` itself blank.
+ *
+ * Returns `''` when there is no cause, so callers can drop the field.
+ */
+export declare function formatErrorCauseChain(value: unknown): string;
 export declare function isAbortError(value: unknown): value is {
     name: 'AbortError';
     message: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAK/C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAKhD;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAYlE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUhE;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AA2CD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,sBAAsB,CAAC,CAmBjC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAK/C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAKhD;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CA4B5D;AAgBD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAYlE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAUhE;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AA2CD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,sBAAsB,CAAC,CAmBjC"}

package/dist/types.js

@@ -12,6 +12,78 @@ export function getErrorStack(v) {
     }
     return '';
 }
+/** Upper bound on the links {@link formatErrorCauseChain} renders. */
+const MAX_CAUSE_LINKS = 4;
+/** One `Name: message (CODE)` line for a link in a cause chain. */
+function describeErrorLink(value) {
+    if (typeof value !== 'object' || value === null) {
+        return String(value);
+    }
+    const { name, message, code } = value;
+    const label = typeof name === 'string' && name ? name : 'Error';
+    const text = typeof message === 'string' && message ? `${label}: ${message}` : label;
+    return typeof code === 'string' && code && !text.includes(code)
+        ? `${text} (${code})`
+        : text;
+}
+/**
+ * Summarize the `cause` chain hanging off a thrown value, one link per line,
+ * outermost first. The value itself is skipped: whatever logs this already
+ * states it, in the message or in the stack header.
+ *
+ * `util.inspect` renders `[cause]` when Node prints an error, but the
+ * structured logs read `name` / `message` / `stack` and drop everything else
+ * — exactly the wrong half for errors that arrive pre-wrapped.
+ * `TypeError: fetch failed` is the canonical one: undici's wrapper says
+ * nothing on its own and its stack is all `node:internal/` frames, so the DNS,
+ * socket or TLS failure that actually happened is only readable one or two
+ * `cause` hops down. Same for the world layer's own wrapping, where the
+ * request that failed is on the wrapper and the reason it failed is on the
+ * cause.
+ *
+ * `AggregateError` also gets its `errors` summarized, because a
+ * happy-eyeballs connect reports every attempt there and leaves the
+ * `AggregateError` itself blank.
+ *
+ * Returns `''` when there is no cause, so callers can drop the field.
+ */
+export function formatErrorCauseChain(value) {
+    const lines = [];
+    const seen = new Set();
+    try {
+        for (let current = causeOf(value); current != null && lines.length <= MAX_CAUSE_LINKS; current = causeOf(current)) {
+            if (typeof current !== 'object') {
+                lines.push(String(current));
+                break;
+            }
+            // A cause chain can loop (`err.cause = err`) or repeat a shared error.
+            if (seen.has(current))
+                break;
+            seen.add(current);
+            lines.push(describeErrorLink(current), ...aggregatedLinks(current));
+        }
+    }
+    catch {
+        // Causes can contain getters or proxies that throw. Logging must not
+        // replace the original error or prevent the run_failed event from being written.
+        lines.push('[unavailable cause]');
+    }
+    return lines.length > MAX_CAUSE_LINKS
+        ? [...lines.slice(0, MAX_CAUSE_LINKS), '…'].join('\n')
+        : lines.join('\n');
+}
+function causeOf(value) {
+    return typeof value === 'object' && value !== null
+        ? value.cause
+        : undefined;
+}
+/** The attempts an `AggregateError` collected, if this link is one. */
+function aggregatedLinks(value) {
+    const errors = value.errors;
+    return Array.isArray(errors)
+        ? errors.slice(0, MAX_CAUSE_LINKS).map(describeErrorLink)
+        : [];
+}
 export function isAbortError(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -94,4 +166,4 @@ export async function normalizeUnknownError(value) {
     }
     return normalizeSyncError(value);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNsQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFOUMsTUFBTSxVQUFVLFlBQVksQ0FBQyxDQUFVO0lBQ3JDLElBQUksS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQzNCLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQztJQUNoQixDQUFDO0lBQ0QsT0FBTyxPQUFPLENBQUM7QUFDakIsQ0FBQztBQUVELE1BQU0sVUFBVSxhQUFhLENBQUMsQ0FBVTtJQUN0QyxJQUFJLEtBQUssQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUMzQixPQUFPLENBQUMsQ0FBQyxLQUFLLElBQUksRUFBRSxDQUFDO0lBQ3ZCLENBQUM7SUFDRCxPQUFPLEVBQUUsQ0FBQztBQUNaLENBQUM7QUFFRCxNQUFNLFVBQVUsWUFBWSxDQUMxQixLQUFjO0lBRWQsT0FBTyxDQUNMLE9BQU8sS0FBSyxLQUFLLFFBQVE7UUFDekIsS0FBSyxLQUFLLElBQUk7UUFDZCxNQUFNLElBQUksS0FBSztRQUNmLEtBQUssQ0FBQyxJQUFJLEtBQUssWUFBWTtRQUMzQixTQUFTLElBQUksS0FBSztRQUNsQixPQUFPLEtBQUssQ0FBQyxPQUFPLEtBQUssUUFBUTtRQUNqQyxDQUFDLENBQUMsQ0FBQyxPQUFPLElBQUksS0FBSyxDQUFDO1lBQ2xCLEtBQUssQ0FBQyxLQUFLLEtBQUssU0FBUztZQUN6QixPQUFPLEtBQUssQ0FBQyxLQUFLLEtBQUssUUFBUSxDQUFDLENBQ25DLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLHdCQUF3QixDQUFDLEtBQWM7SUFDckQsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsSUFBSSxVQUFVLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDakQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQsTUFBTSxVQUFVLEdBQUcsSUFBSSxVQUFVLENBQUMsWUFBWSxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUMvRCxJQUFJLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNoQixVQUFVLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUM7SUFDakMsQ0FBQztJQUNELE9BQU8sVUFBVSxDQUFDO0FBQ3BCLENBQUM7QUFRRCxTQUFTLFVBQVUsQ0FBQyxLQUFjO0lBQ2hDLE9BQU8sQ0FDTCxPQUFPLEtBQUssS0FBSyxRQUFRO1FBQ3pCLEtBQUssS0FBSyxJQUFJO1FBQ2QsTUFBTSxJQUFJLEtBQUs7UUFDZixPQUFRLEtBQTRCLENBQUMsSUFBSSxLQUFLLFVBQVUsQ0FDekQsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFTLGtCQUFrQixDQUFDLENBQVU7SUFDcEMsSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDM0IsT0FBTztZQUNMLElBQUksRUFBRSxDQUFDLENBQUMsSUFBSTtZQUNaLE9BQU8sRUFBRSxDQUFDLENBQUMsT0FBTztZQUNsQixLQUFLLEVBQUUsQ0FBQyxDQUFDLEtBQUssSUFBSSxFQUFFO1NBQ3JCLENBQUM7SUFDSixDQUFDO0lBRUQsSUFBSSxPQUFPLENBQUMsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUMxQixPQUFPO1lBQ0wsSUFBSSxFQUFFLE9BQU87WUFDYixPQUFPLEVBQUUsQ0FBQztZQUNWLEtBQUssRUFBRSxFQUFFO1NBQ1YsQ0FBQztJQUNKLENBQUM7SUFFRCxJQUFJLENBQUM7UUFDSCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE9BQU87WUFDYixPQUFPLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7WUFDMUIsS0FBSyxFQUFFLEVBQUU7U0FDVixDQUFDO0lBQ0osQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLE9BQU87WUFDTCxJQUFJLEVBQUUsT0FBTztZQUNiLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDO1lBQ2xCLEtBQUssRUFBRSxFQUFFO1NBQ1YsQ0FBQztJQUNKLENBQUM7QUFDSCxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUscUJBQXFCLENBQ3pDLEtBQWM7SUFFZCxJQUFJLFVBQVUsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3RCLElBQUksQ0FBQztZQUNILE1BQU0sUUFBUSxHQUFHLE1BQU0sS0FBSyxDQUFDO1lBQzdCLE1BQU0sVUFBVSxHQUFHLE1BQU0scUJBQXFCLENBQUMsUUFBUSxDQUFDLENBQUM7WUFDekQsT0FBTztnQkFDTCxHQUFHLFVBQVU7Z0JBQ2IsT0FBTyxFQUFFLHNCQUFzQixVQUFVLENBQUMsT0FBTyxFQUFFO2FBQ3BELENBQUM7UUFDSixDQUFDO1FBQUMsT0FBTyxTQUFTLEVBQUUsQ0FBQztZQUNuQixNQUFNLFVBQVUsR0FBRyxNQUFNLHFCQUFxQixDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQzFELE9BQU87Z0JBQ0wsR0FBRyxVQUFVO2dCQUNiLE9BQU8sRUFBRSxzQkFBc0IsVUFBVSxDQUFDLE9BQU8sRUFBRTthQUNwRCxDQUFDO1FBQ0osQ0FBQztJQUNILENBQUM7SUFFRCxPQUFPLGtCQUFrQixDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ25DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlcyB9IGZyb20gJ25vZGU6dXRpbCc7XG5pbXBvcnQgeyBGYXRhbEVycm9yIH0gZnJvbSAnQHdvcmtmbG93L2Vycm9ycyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRFcnJvck5hbWUodjogdW5rbm93bik6IHN0cmluZyB7XG4gIGlmICh0eXBlcy5pc05hdGl2ZUVycm9yKHYpKSB7XG4gICAgcmV0dXJuIHYubmFtZTtcbiAgfVxuICByZXR1cm4gJ0Vycm9yJztcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEVycm9yU3RhY2sodjogdW5rbm93bik6IHN0cmluZyB7XG4gIGlmICh0eXBlcy5pc05hdGl2ZUVycm9yKHYpKSB7XG4gICAgcmV0dXJuIHYuc3RhY2sgPz8gJyc7XG4gIH1cbiAgcmV0dXJuICcnO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNBYm9ydEVycm9yKFxuICB2YWx1ZTogdW5rbm93blxuKTogdmFsdWUgaXMgeyBuYW1lOiAnQWJvcnRFcnJvcic7IG1lc3NhZ2U6IHN0cmluZzsgc3RhY2s/OiBzdHJpbmcgfSB7XG4gIHJldHVybiAoXG4gICAgdHlwZW9mIHZhbHVlID09PSAnb2JqZWN0JyAmJlxuICAgIHZhbHVlICE9PSBudWxsICYmXG4gICAgJ25hbWUnIGluIHZhbHVlICYmXG4gICAgdmFsdWUubmFtZSA9PT0gJ0Fib3J0RXJyb3InICYmXG4gICAgJ21lc3NhZ2UnIGluIHZhbHVlICYmXG4gICAgdHlwZW9mIHZhbHVlLm1lc3NhZ2UgPT09ICdzdHJpbmcnICYmXG4gICAgKCEoJ3N0YWNrJyBpbiB2YWx1ZSkgfHxcbiAgICAgIHZhbHVlLnN0YWNrID09PSB1bmRlZmluZWQgfHxcbiAgICAgIHR5cGVvZiB2YWx1ZS5zdGFjayA9PT0gJ3N0cmluZycpXG4gICk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBwcm9tb3RlQWJvcnRFcnJvclRvRmF0YWwodmFsdWU6IHVua25vd24pOiB1bmtub3duIHtcbiAgaWYgKCFpc0Fib3J0RXJyb3IodmFsdWUpIHx8IEZhdGFsRXJyb3IuaXModmFsdWUpKSB7XG4gICAgcmV0dXJuIHZhbHVlO1xuICB9XG5cbiAgY29uc3QgZmF0YWxFcnJvciA9IG5ldyBGYXRhbEVycm9yKGBBYm9ydGVkOiAke3ZhbHVlLm1lc3NhZ2V9YCk7XG4gIGlmICh2YWx1ZS5zdGFjaykge1xuICAgIGZhdGFsRXJyb3Iuc3RhY2sgPSB2YWx1ZS5zdGFjaztcbiAgfVxuICByZXR1cm4gZmF0YWxFcnJvcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOb3JtYWxpemVkVW5rbm93bkVycm9yIHtcbiAgbmFtZTogc3RyaW5nO1xuICBtZXNzYWdlOiBzdHJpbmc7XG4gIHN0YWNrOiBzdHJpbmc7XG59XG5cbmZ1bmN0aW9uIGlzVGhlbmFibGUodmFsdWU6IHVua25vd24pOiB2YWx1ZSBpcyBQcm9taXNlPHVua25vd24+IHtcbiAgcmV0dXJuIChcbiAgICB0eXBlb2YgdmFsdWUgPT09ICdvYmplY3QnICYmXG4gICAgdmFsdWUgIT09IG51bGwgJiZcbiAgICAndGhlbicgaW4gdmFsdWUgJiZcbiAgICB0eXBlb2YgKHZhbHVlIGFzIHsgdGhlbj86IHVua25vd24gfSkudGhlbiA9PT0gJ2Z1bmN0aW9uJ1xuICApO1xufVxuXG5mdW5jdGlvbiBub3JtYWxpemVTeW5jRXJyb3IodjogdW5rbm93bik6IE5vcm1hbGl6ZWRVbmtub3duRXJyb3Ige1xuICBpZiAodHlwZXMuaXNOYXRpdmVFcnJvcih2KSkge1xuICAgIHJldHVybiB7XG4gICAgICBuYW1lOiB2Lm5hbWUsXG4gICAgICBtZXNzYWdlOiB2Lm1lc3NhZ2UsXG4gICAgICBzdGFjazogdi5zdGFjayA/PyAnJyxcbiAgICB9O1xuICB9XG5cbiAgaWYgKHR5cGVvZiB2ID09PSAnc3RyaW5nJykge1xuICAgIHJldHVybiB7XG4gICAgICBuYW1lOiAnRXJyb3InLFxuICAgICAgbWVzc2FnZTogdixcbiAgICAgIHN0YWNrOiAnJyxcbiAgICB9O1xuICB9XG5cbiAgdHJ5IHtcbiAgICByZXR1cm4ge1xuICAgICAgbmFtZTogJ0Vycm9yJyxcbiAgICAgIG1lc3NhZ2U6IEpTT04uc3RyaW5naWZ5KHYpLFxuICAgICAgc3RhY2s6ICcnLFxuICAgIH07XG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiB7XG4gICAgICBuYW1lOiAnRXJyb3InLFxuICAgICAgbWVzc2FnZTogU3RyaW5nKHYpLFxuICAgICAgc3RhY2s6ICcnLFxuICAgIH07XG4gIH1cbn1cblxuLyoqXG4gKiBOb3JtYWxpemVzIHVua25vd24gdGhyb3duIHZhbHVlcyBpbnRvIGEgc3RhYmxlIGVycm9yIHNoYXBlLlxuICogVGhpcyBoYW5kbGVzIFByb21pc2UvdGhlbmFibGUgdGhyb3cgdmFsdWVzIHNvIGxvZ3MvZXZlbnRzIG5ldmVyIGVuZCB1cFxuICogd2l0aCB1bmhlbHBmdWwgXCJbb2JqZWN0IFByb21pc2VdXCIgbWVzc2FnZXMuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBub3JtYWxpemVVbmtub3duRXJyb3IoXG4gIHZhbHVlOiB1bmtub3duXG4pOiBQcm9taXNlPE5vcm1hbGl6ZWRVbmtub3duRXJyb3I+IHtcbiAgaWYgKGlzVGhlbmFibGUodmFsdWUpKSB7XG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IHJlc29sdmVkID0gYXdhaXQgdmFsdWU7XG4gICAgICBjb25zdCBub3JtYWxpemVkID0gYXdhaXQgbm9ybWFsaXplVW5rbm93bkVycm9yKHJlc29sdmVkKTtcbiAgICAgIHJldHVybiB7XG4gICAgICAgIC4uLm5vcm1hbGl6ZWQsXG4gICAgICAgIG1lc3NhZ2U6IGBQcm9taXNlIHJlamVjdGlvbjogJHtub3JtYWxpemVkLm1lc3NhZ2V9YCxcbiAgICAgIH07XG4gICAgfSBjYXRjaCAocmVqZWN0aW9uKSB7XG4gICAgICBjb25zdCBub3JtYWxpemVkID0gYXdhaXQgbm9ybWFsaXplVW5rbm93bkVycm9yKHJlamVjdGlvbik7XG4gICAgICByZXR1cm4ge1xuICAgICAgICAuLi5ub3JtYWxpemVkLFxuICAgICAgICBtZXNzYWdlOiBgUHJvbWlzZSByZWplY3Rpb246ICR7bm9ybWFsaXplZC5tZXNzYWdlfWAsXG4gICAgICB9O1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBub3JtYWxpemVTeW5jRXJyb3IodmFsdWUpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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","sourcesContent":["import { types } from 'node:util';\nimport { FatalError } from '@workflow/errors';\n\nexport function getErrorName(v: unknown): string {\n  if (types.isNativeError(v)) {\n    return v.name;\n  }\n  return 'Error';\n}\n\nexport function getErrorStack(v: unknown): string {\n  if (types.isNativeError(v)) {\n    return v.stack ?? '';\n  }\n  return '';\n}\n\n/** Upper bound on the links {@link formatErrorCauseChain} renders. */\nconst MAX_CAUSE_LINKS = 4;\n\n/** One `Name: message (CODE)` line for a link in a cause chain. */\nfunction describeErrorLink(value: unknown): string {\n  if (typeof value !== 'object' || value === null) {\n    return String(value);\n  }\n  const { name, message, code } = value as {\n    name?: unknown;\n    message?: unknown;\n    code?: unknown;\n  };\n  const label = typeof name === 'string' && name ? name : 'Error';\n  const text =\n    typeof message === 'string' && message ? `${label}: ${message}` : label;\n  return typeof code === 'string' && code && !text.includes(code)\n    ? `${text} (${code})`\n    : text;\n}\n\n/**\n * Summarize the `cause` chain hanging off a thrown value, one link per line,\n * outermost first. The value itself is skipped: whatever logs this already\n * states it, in the message or in the stack header.\n *\n * `util.inspect` renders `[cause]` when Node prints an error, but the\n * structured logs read `name` / `message` / `stack` and drop everything else\n * — exactly the wrong half for errors that arrive pre-wrapped.\n * `TypeError: fetch failed` is the canonical one: undici's wrapper says\n * nothing on its own and its stack is all `node:internal/` frames, so the DNS,\n * socket or TLS failure that actually happened is only readable one or two\n * `cause` hops down. Same for the world layer's own wrapping, where the\n * request that failed is on the wrapper and the reason it failed is on the\n * cause.\n *\n * `AggregateError` also gets its `errors` summarized, because a\n * happy-eyeballs connect reports every attempt there and leaves the\n * `AggregateError` itself blank.\n *\n * Returns `''` when there is no cause, so callers can drop the field.\n */\nexport function formatErrorCauseChain(value: unknown): string {\n  const lines: string[] = [];\n  const seen = new Set<unknown>();\n\n  try {\n    for (\n      let current = causeOf(value);\n      current != null && lines.length <= MAX_CAUSE_LINKS;\n      current = causeOf(current)\n    ) {\n      if (typeof current !== 'object') {\n        lines.push(String(current));\n        break;\n      }\n      // A cause chain can loop (`err.cause = err`) or repeat a shared error.\n      if (seen.has(current)) break;\n      seen.add(current);\n      lines.push(describeErrorLink(current), ...aggregatedLinks(current));\n    }\n  } catch {\n    // Causes can contain getters or proxies that throw. Logging must not\n    // replace the original error or prevent the run_failed event from being written.\n    lines.push('[unavailable cause]');\n  }\n\n  return lines.length > MAX_CAUSE_LINKS\n    ? [...lines.slice(0, MAX_CAUSE_LINKS), '…'].join('\\n')\n    : lines.join('\\n');\n}\n\nfunction causeOf(value: unknown): unknown {\n  return typeof value === 'object' && value !== null\n    ? (value as { cause?: unknown }).cause\n    : undefined;\n}\n\n/** The attempts an `AggregateError` collected, if this link is one. */\nfunction aggregatedLinks(value: object): string[] {\n  const errors = (value as { errors?: unknown }).errors;\n  return Array.isArray(errors)\n    ? errors.slice(0, MAX_CAUSE_LINKS).map(describeErrorLink)\n    : [];\n}\n\nexport function isAbortError(\n  value: unknown\n): value is { name: 'AbortError'; message: string; stack?: string } {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'name' in value &&\n    value.name === 'AbortError' &&\n    'message' in value &&\n    typeof value.message === 'string' &&\n    (!('stack' in value) ||\n      value.stack === undefined ||\n      typeof value.stack === 'string')\n  );\n}\n\nexport function promoteAbortErrorToFatal(value: unknown): unknown {\n  if (!isAbortError(value) || FatalError.is(value)) {\n    return value;\n  }\n\n  const fatalError = new FatalError(`Aborted: ${value.message}`);\n  if (value.stack) {\n    fatalError.stack = value.stack;\n  }\n  return fatalError;\n}\n\nexport interface NormalizedUnknownError {\n  name: string;\n  message: string;\n  stack: string;\n}\n\nfunction isThenable(value: unknown): value is Promise<unknown> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'then' in value &&\n    typeof (value as { then?: unknown }).then === 'function'\n  );\n}\n\nfunction normalizeSyncError(v: unknown): NormalizedUnknownError {\n  if (types.isNativeError(v)) {\n    return {\n      name: v.name,\n      message: v.message,\n      stack: v.stack ?? '',\n    };\n  }\n\n  if (typeof v === 'string') {\n    return {\n      name: 'Error',\n      message: v,\n      stack: '',\n    };\n  }\n\n  try {\n    return {\n      name: 'Error',\n      message: JSON.stringify(v),\n      stack: '',\n    };\n  } catch {\n    return {\n      name: 'Error',\n      message: String(v),\n      stack: '',\n    };\n  }\n}\n\n/**\n * Normalizes unknown thrown values into a stable error shape.\n * This handles Promise/thenable throw values so logs/events never end up\n * with unhelpful \"[object Promise]\" messages.\n */\nexport async function normalizeUnknownError(\n  value: unknown\n): Promise<NormalizedUnknownError> {\n  if (isThenable(value)) {\n    try {\n      const resolved = await value;\n      const normalized = await normalizeUnknownError(resolved);\n      return {\n        ...normalized,\n        message: `Promise rejection: ${normalized.message}`,\n      };\n    } catch (rejection) {\n      const normalized = await normalizeUnknownError(rejection);\n      return {\n        ...normalized,\n        message: `Promise rejection: ${normalized.message}`,\n      };\n    }\n  }\n\n  return normalizeSyncError(value);\n}\n"]}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.51";
+export declare const version = "5.0.0-beta.53";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '5.0.0-beta.51';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC1iZXRhLjUxJ1xuIl19
+export const version = '5.0.0-beta.53';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC1iZXRhLjUzJ1xuIl19

package/docs/foundations/errors-and-retries.mdx

@@ -164,6 +164,16 @@ export async function myWorkflow(input: unknown) {
 
 Uncaught, the run fails immediately with the `USER_ERROR` code, without retrying. See [serialization-failed](/docs/errors/serialization-failed) for common causes and fixes.
 
+## Backend connection failures
+
+On Vercel, backend connection failures and interrupted event streams use the existing retry policies, even when their error codes are unrecognized. This lets workflows recover from network failures instead of immediately failing with `USER_ERROR`. Persistent failures can still exhaust the retry budget.
+
+The SDK also replaces its shared events connection pool after repeated HTTP/2 session failures. Invalid backend URLs, including unsupported protocols and embedded credentials, fail immediately. Fetch requests to blocked ports or with unsupported headers (such as `Expect`) also fail without retrying. Interrupted event writes retain their existing retries; caller cancellations do not trigger another write.
+
+A connection failure does not prove that the backend rejected a write: it may have accepted it before the response was lost. Continue to make step side effects [idempotent](/docs/foundations/idempotency).
+
+Failed-run logs include the underlying error causes and their codes, exposing socket, DNS, or TLS errors behind messages such as `TypeError: fetch failed`. If a cause cannot be read, the log includes `[unavailable cause]` and the run can still be recorded as failed.
+
 ## Error codes
 
 When a workflow run fails, the error includes an `errorCode` that classifies the failure, alongside the original thrown value (preserved as `cause`):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/core",
-  "version": "5.0.0-beta.51",
+  "version": "5.0.0-beta.53",
   "description": "Core runtime and engine for Workflow SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -88,9 +88,9 @@
     "@workflow/errors": "5.0.0-beta.21",
     "@workflow/serde": "5.0.0-beta.2",
     "@workflow/utils": "5.0.0-beta.10",
-    "@workflow/world": "5.0.0-beta.35",
-    "@workflow/world-local": "5.0.0-beta.44",
-    "@workflow/world-vercel": "5.0.0-beta.46",
+    "@workflow/world": "5.0.0-beta.36",
+    "@workflow/world-local": "5.0.0-beta.45",
+    "@workflow/world-vercel": "5.0.0-beta.48",
     "debug": "4.4.3",
     "devalue": "5.9.2",
     "ms": "2.1.3",