@trigger.dev/core 0.0.0-python-preview-20250226140121 → 0.0.0-rc-4-8-0-20261021151928

package/dist/esm/v3/apiClient/runStream.js

@@ -1,22 +1,34 @@
 import { EventSourceParserStream } from "eventsource-parser/stream";
 import { createJsonErrorObject } from "../errors.js";
-import { SubscribeRealtimeStreamChunkRawShape, SubscribeRunRawShape, } from "../schemas/api.js";
+import { SubscribeRunRawShape } from "../schemas/api.js";
+import { createAsyncIterableReadable } from "../streams/asyncIterableStream.js";
 import { getEnvVar } from "../utils/getEnv.js";
-import { conditionallyImportAndParsePacket, parsePacket, } from "../utils/ioSerialization.js";
-import { ApiError } from "./errors.js";
-import { createAsyncIterableReadable, LineTransformStream, zodShapeStream, } from "./stream.js";
+import { conditionallyImportAndParsePacket, parsePacket } from "../utils/ioSerialization.js";
+import { ApiError, isTriggerRealtimeAuthError } from "./errors.js";
+import { zodShapeStream } from "./stream.js";
+/**
+ * Request header carrying the start position for a fresh realtime-stream
+ * subscription. Value `"latest"` asks the server to start at the current tail
+ * (only records appended after connect). Only sent when there is no
+ * `Last-Event-ID`. Read by the realtime streams route on the server.
+ */
+export const STREAM_START_HEADER = "X-Trigger-Stream-Start";
 export function runShapeStream(url, options) {
     const abortController = new AbortController();
     const streamFactory = new SSEStreamSubscriptionFactory(getEnvVar("TRIGGER_STREAM_URL", getEnvVar("TRIGGER_API_URL")) ?? "https://api.trigger.dev", {
         headers: options?.headers,
+        resolveHeaders: options?.resolveHeaders,
         signal: abortController.signal,
     });
     // If the user supplied AbortSignal is aborted, we should abort the internal controller
-    options?.signal?.addEventListener("abort", () => {
+    const onSignalAbort = () => {
         if (!abortController.signal.aborted) {
             abortController.abort();
         }
-    }, { once: true });
+    };
+    options?.signal?.addEventListener("abort", onSignalAbort, { once: true });
+    // If the subscription ends first, don't leave the listener on a possibly long-lived signal
+    abortController.signal.addEventListener("abort", () => options?.signal?.removeEventListener("abort", onSignalAbort), { once: true });
     const runStreamInstance = zodShapeStream(SubscribeRunRawShape, url, {
         ...options,
         signal: abortController.signal,
@@ -37,35 +49,419 @@ export function runShapeStream(url, options) {
 export class SSEStreamSubscription {
     url;
     options;
+    lastEventId;
+    from;
+    retryCount = 0;
+    stallCount = 0;
+    maxRetries;
+    maxStallRetries;
+    retryDelayMs;
+    maxRetryDelayMs;
+    retryJitter;
+    fetchTimeoutMs;
+    stallTimeoutMs;
+    nonRetryableStatuses;
+    retryNowController = null;
+    internalAbort = null;
+    cancelledByConsumer = false;
+    completeNotified = false;
+    /** Headers for the next attempt. Replaced by `resolveHeaders` after an auth failure. */
+    currentHeaders;
+    /** A refresh has already been tried on this connection; a second auth failure is terminal. */
+    authRefreshed = false;
+    /** Headers were just refreshed for the auth error now unwinding; retry once instead of failing. */
+    retryAfterAuthRefresh = false;
+    /**
+     * True when the most recent response carried `X-Session-Settled: true` —
+     * the server has no more records coming, so a clean end of the body is
+     * terminal rather than the end of a long-poll window.
+     */
+    sessionSettled = false;
     constructor(url, options) {
         this.url = url;
         this.options = options;
+        this.currentHeaders = options.headers;
+        this.lastEventId = options.lastEventId;
+        this.from = options.from ?? "beginning";
+        this.maxRetries = options.maxRetries ?? Infinity;
+        this.maxStallRetries = options.maxStallRetries ?? Infinity;
+        this.retryDelayMs = options.retryDelayMs ?? 100;
+        this.maxRetryDelayMs = options.maxRetryDelayMs ?? 5000;
+        this.retryJitter = options.retryJitter ?? 0.5;
+        this.fetchTimeoutMs = options.fetchTimeoutMs ?? 30_000;
+        this.stallTimeoutMs = options.stallTimeoutMs ?? 0;
+        this.nonRetryableStatuses = new Set(options.nonRetryableStatuses ?? [400, 404, 409, 410, 422]);
+    }
+    /**
+     * Wake an in-flight retry backoff and reconnect immediately.
+     *
+     * No-op if no retry is currently waiting (i.e. we're already
+     * connected and reading). Use this for cheap "hint" wakeups like
+     * the `online` event or a short-hidden visibility return —
+     * `forceReconnect()` is the heavier hammer.
+     */
+    retryNow() {
+        this.retryNowController?.abort();
+    }
+    /**
+     * Drop the current connection (or wake a pending backoff) and
+     * reconnect.
+     *
+     * Use when the existing TCP socket is suspected dead but the reader
+     * hasn't noticed yet — common after a mobile tab background-kill or
+     * a Safari bfcache restore. Aborts the in-flight fetch / read so
+     * the catch path takes us through `retryConnection` and re-fetches
+     * with `Last-Event-ID`.
+     */
+    forceReconnect() {
+        this.internalAbort?.abort();
+        this.retryNowController?.abort();
+    }
+    /** Fire `onComplete` at most once, even if both the drain and cancel paths reach it. */
+    notifyComplete() {
+        if (this.completeNotified)
+            return;
+        this.completeNotified = true;
+        this.options.onComplete?.();
     }
+    /**
+     * The transport pumps decoded records into an internal stream; the returned
+     * stream drains it on demand.
+     */
     async subscribe() {
-        return fetch(this.url, {
-            headers: {
-                Accept: "text/event-stream",
-                ...this.options.headers,
+        // eslint-disable-next-line no-this-alias
+        const self = this;
+        const internal = new ReadableStream({
+            async start(controller) {
+                await self.connectStream(controller);
+            },
+            cancel() {
+                self.cancelledByConsumer = true;
+                self.internalAbort?.abort();
+                self.retryNowController?.abort();
             },
-            signal: this.options.signal,
-        }).then((response) => {
+        });
+        const internalReader = internal.getReader();
+        return new ReadableStream({
+            async pull(controller) {
+                let result;
+                try {
+                    result = await internalReader.read();
+                }
+                catch (err) {
+                    controller.error(err);
+                    return;
+                }
+                if (result.done) {
+                    self.notifyComplete();
+                    try {
+                        controller.close();
+                    }
+                    catch { }
+                    return;
+                }
+                controller.enqueue(result.value.part);
+            },
+            cancel(reason) {
+                self.cancelledByConsumer = true;
+                self.notifyComplete();
+                internalReader.cancel(reason).catch(() => { });
+            },
+        }, { highWaterMark: 0 });
+    }
+    async connectStream(controller) {
+        // Two abort sources flow through `internalAbort.signal`:
+        //   - this.options.signal: caller cancel — bypass retry, exit cleanly.
+        //   - this.internalAbort: per-attempt force-reconnect / fetch-timeout
+        //     / stall-timeout — treated as a transient error, retry path runs.
+        // Use `this.options.signal?.aborted` in the catch to distinguish.
+        this.internalAbort = new AbortController();
+        const unlinkUserAbort = linkAbort(this.options.signal, this.internalAbort);
+        // Per-attempt fetch timeout. Cleared once response headers arrive;
+        // chunk-read latency is governed by `stallTimeoutMs` instead.
+        const fetchTimer = setTimeout(() => this.internalAbort?.abort(), this.fetchTimeoutMs);
+        let stallTimer;
+        const armStall = () => {
+            if (this.stallTimeoutMs <= 0)
+                return;
+            clearTimeout(stallTimer);
+            stallTimer = setTimeout(() => {
+                if (!this.internalAbort || this.internalAbort.signal.aborted)
+                    return;
+                this.stallCount++;
+                this.internalAbort.abort();
+            }, this.stallTimeoutMs);
+        };
+        // Idempotent — both the catch (before recursion) and the finally
+        // call this. Without the catch-side call, every retry leaks an
+        // abort listener on `this.options.signal` because the finally
+        // doesn't run until the entire recursion unwinds.
+        const cleanupAttempt = () => {
+            clearTimeout(fetchTimer);
+            clearTimeout(stallTimer);
+            unlinkUserAbort();
+            this.internalAbort = null;
+        };
+        try {
+            const headers = {
+                Accept: "text/event-stream",
+                ...this.currentHeaders,
+            };
+            if (this.lastEventId)
+                headers["Last-Event-ID"] = this.lastEventId;
+            else if (this.from === "latest")
+                headers[STREAM_START_HEADER] = "latest";
+            if (this.options.timeoutInSeconds) {
+                headers["Timeout-Seconds"] = this.options.timeoutInSeconds.toString();
+            }
+            const fetchClient = this.options.fetchClient ?? fetch;
+            const response = await fetchClient(this.url, {
+                headers,
+                signal: this.internalAbort.signal,
+            });
+            clearTimeout(fetchTimer);
             if (!response.ok) {
-                throw ApiError.generate(response.status, {}, "Could not subscribe to stream", Object.fromEntries(response.headers));
+                const error = ApiError.generate(response.status, {}, "Could not subscribe to stream", Object.fromEntries(response.headers));
+                if (this.nonRetryableStatuses.has(response.status)) {
+                    this.options.onError?.(error);
+                    controller.error(error);
+                    return;
+                }
+                if (!(await this.refreshHeadersForAuthError(response.status))) {
+                    this.options.onError?.(error);
+                }
+                throw error;
             }
             if (!response.body) {
-                throw new Error("No response body");
+                const error = new Error("No response body");
+                this.options.onError?.(error);
+                throw error;
             }
-            return response.body
+            const streamVersion = response.headers.get("X-Stream-Version") ?? "v1";
+            this.sessionSettled = response.headers.get("X-Session-Settled") === "true";
+            armStall();
+            // Dedup window for record ids. Bounded with FIFO eviction so a
+            // long-lived `watch: true` subscription (one connection across many
+            // turns) doesn't grow this set without bound. The window only needs
+            // to cover the overlap a reconnect/replay can re-deliver, so a few
+            // thousand ids is ample.
+            const SEEN_IDS_CAP = 5000;
+            const seenIds = new Set();
+            const rememberSeen = (id) => {
+                seenIds.add(id);
+                if (seenIds.size > SEEN_IDS_CAP) {
+                    const oldest = seenIds.values().next().value;
+                    if (oldest !== undefined)
+                        seenIds.delete(oldest);
+                }
+            };
+            const stream = response.body
                 .pipeThrough(new TextDecoderStream())
                 .pipeThrough(new EventSourceParserStream())
                 .pipeThrough(new TransformStream({
-                transform(chunk, controller) {
-                    controller.enqueue(safeParseJSON(chunk.data));
+                transform: (chunk, chunkController) => {
+                    if (streamVersion === "v1") {
+                        if (chunk.id) {
+                            this.lastEventId = chunk.id;
+                        }
+                        const timestamp = parseRedisStreamIdTimestamp(chunk.id);
+                        chunkController.enqueue({
+                            type: "part",
+                            part: {
+                                id: chunk.id ?? "unknown",
+                                chunk: safeParseJSON(chunk.data),
+                                timestamp,
+                            },
+                        });
+                    }
+                    else {
+                        if (chunk.event === "batch") {
+                            const data = safeParseJSON(chunk.data);
+                            if (!data || !Array.isArray(data.records))
+                                return;
+                            for (const record of data.records) {
+                                // Always advance the resume cursor — even for records we
+                                // skip — so a future Last-Event-ID reconnect lands past
+                                // them.
+                                this.lastEventId = record.seq_num.toString();
+                                // S2 command records (trim, fence) have a single header
+                                // with an empty name. They are S2-interpreted directives
+                                // that consume a seq_num but are not application data.
+                                // Skip enqueue; consumers shouldn't see them.
+                                if (record.headers?.[0]?.[0] === "") {
+                                    continue;
+                                }
+                                // Data record (and Trigger control records — see
+                                // `trigger-control` header in `client-protocol.mdx`).
+                                // Control records have an empty body; data records have a
+                                // JSON envelope. `safeParseJSON("")` returns undefined,
+                                // which is what we want for control records — downstream
+                                // consumers route by `headers` and ignore `chunk`.
+                                const parsedBody = safeParseJSON(record.body);
+                                if (parsedBody?.id) {
+                                    if (seenIds.has(parsedBody.id))
+                                        continue;
+                                    rememberSeen(parsedBody.id);
+                                }
+                                chunkController.enqueue({
+                                    type: "part",
+                                    part: {
+                                        recordId: parsedBody?.id,
+                                        id: record.seq_num.toString(),
+                                        chunk: parsedBody?.data,
+                                        timestamp: record.timestamp,
+                                        headers: record.headers ?? [],
+                                    },
+                                });
+                            }
+                        }
+                    }
                 },
             }));
+            const reader = stream.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        reader.releaseLock();
+                        this.notifyComplete();
+                        controller.close();
+                        return;
+                    }
+                    if (this.options.signal?.aborted) {
+                        reader.cancel();
+                        reader.releaseLock();
+                        this.notifyComplete();
+                        controller.close();
+                        return;
+                    }
+                    armStall(); // Each decoded record resets the silence timer.
+                    this.authRefreshed = false;
+                    // Headers alone do not establish stream recovery.
+                    this.retryCount = 0;
+                    this.stallCount = 0;
+                    controller.enqueue(value);
+                }
+            }
+            catch (error) {
+                reader.releaseLock();
+                throw error;
+            }
+        }
+        catch (error) {
+            if (this.options.signal?.aborted || this.cancelledByConsumer) {
+                // User cancel — exit cleanly, don't retry.
+                this.notifyComplete();
+                controller.close();
+                return;
+            }
+            if (isTriggerRealtimeAuthError(error)) {
+                if (this.retryAfterAuthRefresh) {
+                    this.retryAfterAuthRefresh = false;
+                }
+                else {
+                    // `onError` was already invoked in the `!response.ok` branch above
+                    // (where the auth ApiError was originally constructed and thrown).
+                    // Auth errors are non-retryable: terminate the stream cleanly.
+                    controller.error(error);
+                    return;
+                }
+            }
+            cleanupAttempt();
+            await this.retryConnection(controller, error);
+        }
+        finally {
+            cleanupAttempt();
+        }
+    }
+    /**
+     * Re-resolve the headers after a 401/403 so the retry carries a fresh token.
+     * At most once per live connection: if the refreshed token is rejected too,
+     * the auth error stays terminal. A refresher that can't mint leaves the
+     * rejected token in place so the auth error stays terminal too. Returns true
+     * when a retry should follow.
+     */
+    async refreshHeadersForAuthError(status) {
+        if (status !== 401 && status !== 403)
+            return false;
+        if (!this.options.resolveHeaders || this.authRefreshed)
+            return false;
+        this.authRefreshed = true;
+        try {
+            this.currentHeaders = await this.options.resolveHeaders();
+        }
+        catch {
+            return false;
+        }
+        this.retryAfterAuthRefresh = true;
+        return true;
+    }
+    async retryConnection(controller, error) {
+        if (this.options.signal?.aborted || this.cancelledByConsumer) {
+            this.notifyComplete();
+            controller.close();
+            return;
+        }
+        const stallsExhausted = this.stallCount > this.maxStallRetries;
+        if (this.retryCount >= this.maxRetries || stallsExhausted) {
+            // Internal timeouts are failures, not caller cancellation.
+            const finalError = stallsExhausted
+                ? new Error("Stream stalled: no records received")
+                : error?.name === "AbortError"
+                    ? new Error("Stream connection retries exhausted")
+                    : error || new Error("Max retries reached");
+            controller.error(finalError);
+            this.options.onError?.(finalError);
+            return;
+        }
+        this.retryCount++;
+        const baseDelay = Math.min(this.retryDelayMs * Math.pow(2, this.retryCount - 1), this.maxRetryDelayMs);
+        // Jitter scales the delay into [(1 - retryJitter) * base, base].
+        // E.g. retryJitter=0.5 → final delay is in [50%, 100%] of base.
+        // Spreads simultaneous reconnect attempts so many clients don't
+        // dogpile on the server right after a brief outage.
+        const delay = baseDelay * (1 - this.retryJitter * Math.random());
+        // Wait before retrying. The wait is wakeable: `retryNow()` aborts
+        // `retryNowController` so the timer resolves immediately and the
+        // next connect attempt starts now (e.g. on tab focus / `online`
+        // event from the browser layer).
+        this.retryNowController = new AbortController();
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.retryNowController?.signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, delay);
+            const onAbort = () => {
+                clearTimeout(timer);
+                resolve();
+            };
+            this.retryNowController.signal.addEventListener("abort", onAbort, { once: true });
         });
+        this.retryNowController = null;
+        if (this.options.signal?.aborted || this.cancelledByConsumer) {
+            controller.close();
+            return;
+        }
+        // Reconnect
+        await this.connectStream(controller);
     }
 }
+/**
+ * One-way abort link: when `parent` aborts, abort `child` too. Returns
+ * a cleanup that removes the listener so `parent` doesn't accumulate
+ * subscriptions across many connect attempts.
+ */
+function linkAbort(parent, child) {
+    if (!parent)
+        return () => { };
+    if (parent.aborted) {
+        child.abort();
+        return () => { };
+    }
+    const onAbort = () => child.abort();
+    parent.addEventListener("abort", onAbort, { once: true });
+    return () => parent.removeEventListener("abort", onAbort);
+}
 export class SSEStreamSubscriptionFactory {
     baseUrl;
     options;
@@ -73,37 +469,15 @@ export class SSEStreamSubscriptionFactory {
         this.baseUrl = baseUrl;
         this.options = options;
     }
-    createSubscription(runId, streamKey, baseUrl) {
+    createSubscription(runId, streamKey, options) {
         if (!runId || !streamKey) {
             throw new Error("runId and streamKey are required");
         }
-        const url = `${baseUrl ?? this.baseUrl}/realtime/v1/streams/${runId}/${streamKey}`;
-        return new SSEStreamSubscription(url, this.options);
-    }
-}
-// Real implementation for production
-export class ElectricStreamSubscription {
-    url;
-    options;
-    constructor(url, options) {
-        this.url = url;
-        this.options = options;
-    }
-    async subscribe() {
-        return zodShapeStream(SubscribeRealtimeStreamChunkRawShape, this.url, this.options)
-            .stream.pipeThrough(new TransformStream({
-            transform(chunk, controller) {
-                controller.enqueue(chunk.value);
-            },
-        }))
-            .pipeThrough(new LineTransformStream())
-            .pipeThrough(new TransformStream({
-            transform(chunk, controller) {
-                for (const line of chunk) {
-                    controller.enqueue(safeParseJSON(line));
-                }
-            },
-        }));
+        const url = `${options?.baseUrl ?? this.baseUrl}/realtime/v1/streams/${runId}/${streamKey}`;
+        return new SSEStreamSubscription(url, {
+            ...this.options,
+            ...options,
+        });
     }
 }
 export class RunSubscription {
@@ -128,7 +502,9 @@ export class RunSubscription {
                     this.options.stopRunShapeStream();
                 }
             },
-        }, this.options.abortController.signal);
+        }, this.options.abortController.signal, 
+        // A consumer `break` cancels the stream; unsubscribe so the shape stream stops polling
+        () => this.unsubscribe());
     }
     unsubscribe() {
         if (!this.options.abortController.signal.aborted) {
@@ -151,48 +527,52 @@ export class RunSubscription {
                     type: "run",
                     run,
                 });
+                const streams = getStreamsFromRunShape(run);
                 // Check for stream metadata
-                if (run.metadata &&
-                    "$$streams" in run.metadata &&
-                    Array.isArray(run.metadata.$$streams)) {
-                    for (const streamKey of run.metadata.$$streams) {
+                if (streams.length > 0) {
+                    for (const streamKey of streams) {
                         if (typeof streamKey !== "string") {
                             continue;
                         }
                         if (!activeStreams.has(streamKey)) {
                             activeStreams.add(streamKey);
-                            const subscription = this.options.streamFactory.createSubscription(run.id, streamKey, this.options.client?.baseUrl);
+                            const subscription = this.options.streamFactory.createSubscription(run.id, streamKey, {
+                                baseUrl: this.options.client?.baseUrl,
+                            });
+                            const signal = this.options.abortController.signal;
                             // Start stream processing in the background
                             subscription
                                 .subscribe()
-                                .then((stream) => {
-                                stream
-                                    .pipeThrough(new TransformStream({
-                                    transform(chunk, controller) {
-                                        controller.enqueue({
-                                            type: streamKey,
-                                            chunk: chunk,
-                                            run,
-                                        });
-                                    },
-                                }))
-                                    .pipeTo(new WritableStream({
-                                    write(chunk) {
+                                .then((stream) => stream
+                                .pipeThrough(new TransformStream({
+                                transform(chunk, controller) {
+                                    controller.enqueue({
+                                        type: streamKey,
+                                        chunk: chunk.chunk,
+                                        run,
+                                    });
+                                },
+                            }))
+                                .pipeTo(new WritableStream({
+                                write(chunk) {
+                                    try {
                                         controller.enqueue(chunk);
-                                    },
-                                }))
-                                    .catch((error) => {
-                                    console.error(`Error in stream ${streamKey}:`, error);
-                                });
-                            })
+                                    }
+                                    catch {
+                                        // The output already closed (consumer broke out or the run ended)
+                                    }
+                                },
+                            }), { signal }))
                                 .catch((error) => {
-                                console.error(`Error subscribing to stream ${streamKey}:`, error);
+                                // Rejections from tearing down the subscription are expected
+                                if (!signal.aborted)
+                                    throw error;
                             });
                         }
                     }
                 }
             },
-        }, this.options.abortController.signal);
+        }, this.options.abortController.signal, () => this.unsubscribe());
     }
     async transformRunShape(row) {
         const payloadPacket = row.payloadType
@@ -208,29 +588,40 @@ export class RunSubscription {
             if (!packet) {
                 return;
             }
-            const cachedResult = this.packetCache.get(`${row.friendlyId}/${key}`);
-            if (typeof cachedResult !== "undefined") {
-                return cachedResult;
+            const cacheKey = `${row.friendlyId}/${key}`;
+            const cachedResult = this.packetCache.get(cacheKey);
+            if (cachedResult &&
+                cachedResult.data === packet.data &&
+                cachedResult.dataType === packet.dataType) {
+                return cachedResult.value;
             }
-            const result = await conditionallyImportAndParsePacket(packet, this.options.client);
-            this.packetCache.set(`${row.friendlyId}/${key}`, result);
+            const field = key;
+            const result = await conditionallyImportAndParsePacket(packet, this.options.client, {
+                runId: row.friendlyId,
+                field,
+            });
+            this.packetCache.set(cacheKey, {
+                data: packet.data,
+                dataType: packet.dataType,
+                value: result,
+            });
             return result;
         }));
         const metadata = row.metadata && row.metadataType
             ? await parsePacket({ data: row.metadata, dataType: row.metadataType })
             : undefined;
+        const status = apiStatusFromRunStatus(row.status);
         return {
             id: row.friendlyId,
-            payload,
-            output,
             createdAt: row.createdAt,
             updatedAt: row.updatedAt,
             taskIdentifier: row.taskIdentifier,
-            number: row.number,
-            status: apiStatusFromRunStatus(row.status),
-            durationMs: row.usageDurationMs,
-            costInCents: row.costInCents,
-            baseCostInCents: row.baseCostInCents,
+            status,
+            payload,
+            output,
+            durationMs: row.usageDurationMs ?? 0,
+            costInCents: row.costInCents ?? 0,
+            baseCostInCents: row.baseCostInCents ?? 0,
             tags: row.runTags ?? [],
             idempotencyKey: row.idempotencyKey ?? undefined,
             expiredAt: row.expiredAt ?? undefined,
@@ -239,29 +630,49 @@ export class RunSubscription {
             delayedUntil: row.delayUntil ?? undefined,
             queuedAt: row.queuedAt ?? undefined,
             error: row.error ? createJsonErrorObject(row.error) : undefined,
-            isTest: row.isTest,
+            isTest: row.isTest ?? false,
             metadata,
+            realtimeStreams: row.realtimeStreams ?? [],
+            ...booleanHelpersFromRunStatus(status),
         };
     }
 }
+const queuedStatuses = ["PENDING_VERSION", "QUEUED", "PENDING", "DELAYED"];
+const waitingStatuses = ["WAITING"];
+const executingStatuses = ["DEQUEUED", "EXECUTING"];
+const failedStatuses = ["FAILED", "CRASHED", "SYSTEM_FAILURE", "EXPIRED", "TIMED_OUT"];
+const successfulStatuses = ["COMPLETED"];
+function booleanHelpersFromRunStatus(status) {
+    return {
+        isQueued: queuedStatuses.includes(status),
+        isWaiting: waitingStatuses.includes(status),
+        isExecuting: executingStatuses.includes(status),
+        isCompleted: successfulStatuses.includes(status) || failedStatuses.includes(status),
+        isFailed: failedStatuses.includes(status),
+        isSuccess: successfulStatuses.includes(status),
+        isCancelled: status === "CANCELED",
+    };
+}
 function apiStatusFromRunStatus(status) {
     switch (status) {
         case "DELAYED": {
             return "DELAYED";
         }
-        case "WAITING_FOR_DEPLOY": {
-            return "WAITING_FOR_DEPLOY";
+        case "WAITING_FOR_DEPLOY":
+        case "PENDING_VERSION": {
+            return "PENDING_VERSION";
         }
         case "PENDING": {
             return "QUEUED";
         }
         case "PAUSED":
         case "WAITING_TO_RESUME": {
-            return "FROZEN";
+            return "WAITING";
         }
-        case "RETRYING_AFTER_FAILURE": {
-            return "REATTEMPTING";
+        case "DEQUEUED": {
+            return "DEQUEUED";
         }
+        case "RETRYING_AFTER_FAILURE":
         case "EXECUTING": {
             return "EXECUTING";
         }
@@ -274,12 +685,10 @@ function apiStatusFromRunStatus(status) {
         case "SYSTEM_FAILURE": {
             return "SYSTEM_FAILURE";
         }
-        case "INTERRUPTED": {
-            return "INTERRUPTED";
-        }
         case "CRASHED": {
             return "CRASHED";
         }
+        case "INTERRUPTED":
         case "COMPLETED_WITH_ERRORS": {
             return "FAILED";
         }
@@ -290,7 +699,7 @@ function apiStatusFromRunStatus(status) {
             return "TIMED_OUT";
         }
         default: {
-            throw new Error(`Unknown status: ${status}`);
+            return "QUEUED";
         }
     }
 }
@@ -298,7 +707,7 @@ function safeParseJSON(data) {
     try {
         return JSON.parse(data);
     }
-    catch (error) {
+    catch (_error) {
         return data;
     }
 }
@@ -336,7 +745,10 @@ if (isSafari()) {
                     if (result.done) {
                         reader.releaseLock();
                     }
-                    return result;
+                    return {
+                        done: result.done,
+                        value: result.value,
+                    };
                 }
                 catch (e) {
                     reader.releaseLock();
@@ -362,4 +774,28 @@ if (isSafari()) {
     // @ts-ignore-error
     ReadableStream.prototype[Symbol.asyncIterator] ??= ReadableStream.prototype.values;
 }
+function getStreamsFromRunShape(run) {
+    const metadataStreams = run.metadata &&
+        "$$streams" in run.metadata &&
+        Array.isArray(run.metadata.$$streams) &&
+        run.metadata.$$streams.length > 0 &&
+        run.metadata.$$streams.every((stream) => typeof stream === "string")
+        ? run.metadata.$$streams
+        : undefined;
+    if (metadataStreams) {
+        return metadataStreams;
+    }
+    return run.realtimeStreams;
+}
+// Redis stream IDs are in the format: <timestamp>-<sequence>
+function parseRedisStreamIdTimestamp(id) {
+    if (!id) {
+        return Date.now();
+    }
+    const timestamp = parseInt(id.split("-")[0], 10);
+    if (isNaN(timestamp)) {
+        return Date.now();
+    }
+    return timestamp;
+}
 //# sourceMappingURL=runStream.js.map