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

package/dist/commonjs/v3/utils/imageRef.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDockerImageReference = parseDockerImageReference;
+exports.rebuildDockerImageReference = rebuildDockerImageReference;
+function parseDockerImageReference(imageReference) {
+    const parts = { repo: "" }; // Initialize with an empty repo
+    // Splitting by '@' to separate the digest (if exists)
+    const atSplit = imageReference.split("@");
+    if (atSplit.length > 1) {
+        parts.digest = atSplit[1];
+        imageReference = atSplit[0];
+    }
+    // Splitting by ':' to separate the tag (if exists) and to ensure it's not part of a port
+    let colonSplit = imageReference.split(":");
+    if (colonSplit.length > 2 ||
+        (colonSplit.length === 2 && !colonSplit[1].includes("/"))) {
+        // It's a tag if there's no '/' in the second part (after colon), or there are more than 2 parts (implying a port number in registry)
+        parts.tag = colonSplit.pop(); // The last part is the tag
+        imageReference = colonSplit.join(":"); // Join back in case it was a port number
+    }
+    // Check for registry
+    let slashIndex = imageReference.indexOf("/");
+    if (slashIndex !== -1) {
+        let potentialRegistry = imageReference.substring(0, slashIndex);
+        // Validate if the first part is a valid hostname-like string (registry), otherwise treat the entire string as the repo
+        if (potentialRegistry.includes(".") ||
+            potentialRegistry === "localhost" ||
+            potentialRegistry.includes(":")) {
+            parts.registry = potentialRegistry;
+            parts.repo = imageReference.substring(slashIndex + 1);
+        }
+        else {
+            parts.repo = imageReference; // No valid registry found, treat as repo
+        }
+    }
+    else {
+        parts.repo = imageReference; // Only repo is present
+    }
+    return parts;
+}
+function rebuildDockerImageReference(parts) {
+    let imageReference = "";
+    if (parts.registry) {
+        imageReference += `${parts.registry}/`;
+    }
+    imageReference += parts.repo; // Repo is now guaranteed to be defined
+    if (parts.tag) {
+        imageReference += `:${parts.tag}`;
+    }
+    if (parts.digest) {
+        imageReference += `@${parts.digest}`;
+    }
+    return imageReference;
+}
+//# sourceMappingURL=imageRef.js.map

package/dist/commonjs/v3/utils/imageRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageRef.js","sourceRoot":"","sources":["../../../../src/v3/utils/imageRef.ts"],"names":[],"mappings":";;;;AAOA,mCAA0C,cAAsB;IAC9D,MAAM,KAAK,GAAqB,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,gCAAgC;IAE9E,sDAAsD;IACtD,MAAM,OAAO,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC1C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAC1B,cAAc,GAAG,OAAO,CAAC,CAAC,CAAW,CAAC;IACxC,CAAC;IAED,yFAAyF;IACzF,IAAI,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3C,IACE,UAAU,CAAC,MAAM,GAAG,CAAC;QACrB,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,CAAE,UAAU,CAAC,CAAC,CAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EACrE,CAAC;QACD,qIAAqI;QACrI,KAAK,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,2BAA2B;QACzD,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,yCAAyC;IAClF,CAAC;IAED,qBAAqB;IACrB,IAAI,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7C,IAAI,UAAU,KAAK,CAAC,CAAC,EAAE,CAAC;QACtB,IAAI,iBAAiB,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAChE,uHAAuH;QACvH,IACE,iBAAiB,CAAC,QAAQ,CAAC,GAAG,CAAC;YAC/B,iBAAiB,KAAK,WAAW;YACjC,iBAAiB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAC/B,CAAC;YACD,KAAK,CAAC,QAAQ,GAAG,iBAAiB,CAAC;YACnC,KAAK,CAAC,IAAI,GAAG,cAAc,CAAC,SAAS,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;QACxD,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,GAAG,cAAc,CAAC,CAAC,yCAAyC;QACxE,CAAC;IACH,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,GAAG,cAAc,CAAC,CAAC,uBAAuB;IACtD,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,qCAA4C,KAAuB;IACjE,IAAI,cAAc,GAAG,EAAE,CAAC;IAExB,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACnB,cAAc,IAAI,GAAG,KAAK,CAAC,QAAQ,GAAG,CAAC;IACzC,CAAC;IAED,cAAc,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,uCAAuC;IAErE,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;QACd,cAAc,IAAI,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;IACpC,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,cAAc,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;IACvC,CAAC;IAED,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/commonjs/v3/utils/interval.d.ts

@@ -0,0 +1,25 @@
+type IntervalServiceOptions = {
+    onInterval: () => Promise<void>;
+    onError?: (error: unknown) => Promise<void>;
+    intervalMs?: number;
+    leadingEdge?: boolean;
+};
+export declare class IntervalService {
+    #private;
+    private _onInterval;
+    private _onError?;
+    private _intervalMs;
+    private _nextInterval;
+    private _leadingEdge;
+    private _isEnabled;
+    private _isExecuting;
+    constructor(opts: IntervalServiceOptions);
+    start(): void;
+    stop(): {
+        isExecuting: boolean;
+    };
+    resetCurrentInterval(): void;
+    updateInterval(intervalMs: number): void;
+    get intervalMs(): number;
+}
+export {};

package/dist/commonjs/v3/utils/interval.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntervalService = void 0;
+class IntervalService {
+    _onInterval;
+    _onError;
+    _intervalMs;
+    _nextInterval;
+    _leadingEdge;
+    _isEnabled;
+    _isExecuting;
+    constructor(opts) {
+        this._onInterval = opts.onInterval;
+        this._onError = opts.onError;
+        this._intervalMs = opts.intervalMs ?? 45_000;
+        this._nextInterval = undefined;
+        this._leadingEdge = opts.leadingEdge ?? false;
+        this._isEnabled = false;
+        this._isExecuting = false;
+    }
+    start() {
+        if (this._isEnabled) {
+            return;
+        }
+        this._isEnabled = true;
+        if (this._leadingEdge) {
+            this.#doInterval();
+        }
+        else {
+            this.#scheduleNextInterval();
+        }
+    }
+    stop() {
+        const returnValue = {
+            isExecuting: this._isExecuting,
+        };
+        if (!this._isEnabled) {
+            return returnValue;
+        }
+        this._isEnabled = false;
+        this.#clearNextInterval();
+        return returnValue;
+    }
+    resetCurrentInterval() {
+        if (!this._isEnabled) {
+            return;
+        }
+        if (this._isExecuting) {
+            return;
+        }
+        this.#clearNextInterval();
+        this.#scheduleNextInterval();
+    }
+    updateInterval(intervalMs) {
+        this._intervalMs = intervalMs;
+        this.resetCurrentInterval();
+    }
+    get intervalMs() {
+        return this._intervalMs;
+    }
+    #doInterval = async () => {
+        this.#clearNextInterval();
+        if (!this._isEnabled) {
+            return;
+        }
+        if (this._isExecuting) {
+            console.error("Interval handler already running, skipping");
+            return;
+        }
+        this._isExecuting = true;
+        try {
+            await this._onInterval();
+        }
+        catch (error) {
+            if (this._onError) {
+                try {
+                    await this._onError(error);
+                }
+                catch (error) {
+                    console.error("Error during interval error handler", error);
+                }
+            }
+        }
+        finally {
+            this.#scheduleNextInterval();
+            this._isExecuting = false;
+        }
+    };
+    #clearNextInterval() {
+        if (this._nextInterval) {
+            clearTimeout(this._nextInterval);
+        }
+    }
+    #scheduleNextInterval() {
+        this._nextInterval = setTimeout(this.#doInterval, this._intervalMs);
+    }
+}
+exports.IntervalService = IntervalService;
+//# sourceMappingURL=interval.js.map

package/dist/commonjs/v3/utils/interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.js","sourceRoot":"","sources":["../../../../src/v3/utils/interval.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/v3/utils/ioSerialization.d.ts

@@ -1,6 +1,6 @@
-import { Attributes } from "@opentelemetry/api";
-import { TriggerTracer } from "../tracer.js";
-import { ApiClient } from "../apiClient/index.js";
+import type { Attributes } from "@opentelemetry/api";
+import type { ApiClient } from "../apiClient/index.js";
+import type { TriggerTracer } from "../tracer.js";
 export type IOPacket = {
     data?: string | undefined;
     dataType: string;
@@ -8,21 +8,53 @@ export type IOPacket = {
 export type ParsePacketOptions = {
     filteredKeys?: string[];
 };
+export type RunPacketContext = {
+    runId: string;
+    field: "payload" | "output";
+};
 export declare function parsePacket(value: IOPacket, options?: ParsePacketOptions): Promise<any>;
-export declare function conditionallyImportAndParsePacket(value: IOPacket, client?: ApiClient): Promise<any>;
+export declare function parsePacketAsJson(value: IOPacket, options?: ParsePacketOptions): Promise<any>;
+export declare function conditionallyImportAndParsePacket(value: IOPacket, client?: ApiClient, runPacket?: RunPacketContext): Promise<any>;
 export declare function stringifyIO(value: any): Promise<IOPacket>;
-export declare function conditionallyExportPacket(packet: IOPacket, pathPrefix: string, tracer?: TriggerTracer): Promise<IOPacket>;
+/**
+ * Offloads a packet to object storage when it exceeds the size limit.
+ *
+ * @param client - Optional API client to use for the upload presign request. When
+ * omitted, falls back to the global `apiClientManager.client`. Pass an explicit client
+ * (e.g. one built from a custom `clientConfig`) to ensure the payload is uploaded using
+ * the same configuration as the accompanying trigger API call.
+ */
+export declare function conditionallyExportPacket(packet: IOPacket, pathPrefix: string, tracer?: TriggerTracer, client?: ApiClient): Promise<IOPacket>;
 export declare function packetRequiresOffloading(packet: IOPacket, lengthLimit?: number): {
     needsOffloading: boolean;
     size: number;
 };
-export declare function conditionallyImportPacket(packet: IOPacket, tracer?: TriggerTracer, client?: ApiClient): Promise<IOPacket>;
+export declare function conditionallyImportPacket(packet: IOPacket, tracer?: TriggerTracer, client?: ApiClient, runPacket?: RunPacketContext): Promise<IOPacket>;
 export declare function resolvePresignedPacketUrl(url: string, tracer?: TriggerTracer): Promise<any | undefined>;
 export declare function createPacketAttributes(packet: IOPacket, dataKey: string, dataTypeKey: string): Promise<Attributes | undefined>;
 export declare function createPacketAttributesAsJson(data: any, dataType: string): Promise<Attributes>;
 export declare function prettyPrintPacket(rawData: any, dataType?: string, options?: ReplacerOptions): Promise<string>;
 interface ReplacerOptions {
     filteredKeys?: string[];
+    cloneReferences?: boolean;
 }
-export declare function replaceSuperJsonPayload(original: string, newPayload: string): Promise<unknown>;
+/**
+ * Replaces the data in a SuperJSON-serialized string with new payload data while preserving
+ * the original type metadata (Dates, BigInts, Sets, Maps, etc.).
+ *
+ * It is primarily useful for our run replay functionality where we want to preserve the original
+ * type metadata for the new payload.
+ *
+ * Note that `undefined` type metadata is ignored when the corresponding field is overriden in the
+ * new payload, i.e., fields which were previously undefined in the original payload are restored into
+ * the primitive type they have in the new payload, instead of `undefined`.
+ * This is a workaround for https://github.com/triggerdotdev/trigger.dev/issues/1968.
+ *
+ * @param original - A SuperJSON-serialized string containing the original data with type metadata
+ * @param newPayload - A JSON string containing the new data to replace the original payload
+ * @returns The deserialized object with new data but original type metadata preserved
+ *
+ * @throws {Error} If the newPayload is not valid JSON
+ */
+export declare function replaceSuperJsonPayload(original: string, newPayload: string): Promise<any>;
 export {};

package/dist/commonjs/v3/utils/ioSerialization.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePacket = parsePacket;
+exports.parsePacketAsJson = parsePacketAsJson;
 exports.conditionallyImportAndParsePacket = conditionallyImportAndParsePacket;
 exports.stringifyIO = stringifyIO;
 exports.conditionallyExportPacket = conditionallyExportPacket;
@@ -11,12 +15,14 @@ exports.createPacketAttributes = createPacketAttributes;
 exports.createPacketAttributesAsJson = createPacketAttributesAsJson;
 exports.prettyPrintPacket = prettyPrintPacket;
 exports.replaceSuperJsonPayload = replaceSuperJsonPayload;
+const path_1 = require("@jsonhero/path");
+const v4_1 = require("zod/v4");
+const apiClientManager_api_js_1 = require("../apiClientManager-api.js");
 const limits_js_1 = require("../limits.js");
 const semanticInternalAttributes_js_1 = require("../semanticInternalAttributes.js");
-const flattenAttributes_js_1 = require("./flattenAttributes.js");
-const apiClientManager_api_js_1 = require("../apiClientManager-api.js");
 const zodfetch_js_1 = require("../zodfetch.js");
-const zod_1 = require("zod");
+const flattenAttributes_js_1 = require("./flattenAttributes.js");
+const superjson_js_1 = __importDefault(require("../imports/superjson.js"));
 async function parsePacket(value, options) {
     if (!value.data) {
         return undefined;
@@ -25,8 +31,7 @@ async function parsePacket(value, options) {
         case "application/json":
             return JSON.parse(value.data, makeSafeReviver(options));
         case "application/super+json":
-            const { parse } = await loadSuperJSON();
-            return parse(value.data);
+            return superjson_js_1.default.parse(value.data);
         case "text/plain":
             return value.data;
         case "application/store":
@@ -35,8 +40,27 @@ async function parsePacket(value, options) {
             return value.data;
     }
 }
-async function conditionallyImportAndParsePacket(value, client) {
-    const importedPacket = await conditionallyImportPacket(value, undefined, client);
+async function parsePacketAsJson(value, options) {
+    if (!value.data) {
+        return undefined;
+    }
+    switch (value.dataType) {
+        case "application/json":
+            return JSON.parse(value.data, makeSafeReviver(options));
+        case "application/super+json":
+            const superJsonResult = superjson_js_1.default.parse(value.data);
+            const { json } = superjson_js_1.default.serialize(superJsonResult);
+            return json;
+        case "text/plain":
+            return value.data;
+        case "application/store":
+            throw new Error(`Cannot parse an application/store packet (${value.data}). Needs to be imported first.`);
+        default:
+            return value.data;
+    }
+}
+async function conditionallyImportAndParsePacket(value, client, runPacket) {
+    const importedPacket = await conditionallyImportPacket(value, undefined, client, runPacket);
     return await parsePacket(importedPacket);
 }
 async function stringifyIO(value) {
@@ -47,24 +71,32 @@ async function stringifyIO(value) {
         return { data: value, dataType: "text/plain" };
     }
     try {
-        const { stringify } = await loadSuperJSON();
-        const data = stringify(value);
+        const data = superjson_js_1.default.stringify(value);
         return { data, dataType: "application/super+json" };
     }
     catch {
         return { data: value, dataType: "application/json" };
     }
 }
-async function conditionallyExportPacket(packet, pathPrefix, tracer) {
-    if (apiClientManager_api_js_1.apiClientManager.client) {
+/**
+ * Offloads a packet to object storage when it exceeds the size limit.
+ *
+ * @param client - Optional API client to use for the upload presign request. When
+ * omitted, falls back to the global `apiClientManager.client`. Pass an explicit client
+ * (e.g. one built from a custom `clientConfig`) to ensure the payload is uploaded using
+ * the same configuration as the accompanying trigger API call.
+ */
+async function conditionallyExportPacket(packet, pathPrefix, tracer, client) {
+    const $client = client ?? apiClientManager_api_js_1.apiClientManager.client;
+    if ($client) {
         const { needsOffloading, size } = packetRequiresOffloading(packet);
         if (needsOffloading) {
             if (!tracer) {
-                return await exportPacket(packet, pathPrefix);
+                return await exportPacket(packet, pathPrefix, $client);
             }
             else {
                 const result = await tracer.startActiveSpan("store.uploadOutput", async (span) => {
-                    return await exportPacket(packet, pathPrefix);
+                    return await exportPacket(packet, pathPrefix, $client);
                 }, {
                     attributes: {
                         byteLength: size,
@@ -97,11 +129,14 @@ const ioRetryOptions = {
     factor: 2,
     randomize: true,
 };
-async function exportPacket(packet, pathPrefix) {
+async function exportPacket(packet, pathPrefix, client) {
     // Offload the output
     const filename = `${pathPrefix}.${getPacketExtension(packet.dataType)}`;
-    const presignedResponse = await apiClientManager_api_js_1.apiClientManager.client.createUploadPayloadUrl(filename);
-    const uploadResponse = await (0, zodfetch_js_1.zodfetch)(zod_1.z.any(), presignedResponse.presignedUrl, {
+    const presignedResponse = await client.createUploadPayloadUrl(filename);
+    if (!presignedResponse.storagePath) {
+        throw new Error("Packet upload presign response missing storagePath; ensure the server supports /api/v2/packets");
+    }
+    const uploadResponse = await (0, zodfetch_js_1.zodfetch)(v4_1.z.any(), presignedResponse.presignedUrl, {
         method: "PUT",
         headers: {
             "Content-Type": packet.dataType,
@@ -114,20 +149,20 @@ async function exportPacket(packet, pathPrefix) {
         throw new Error(`Failed to upload output to ${presignedResponse.presignedUrl}: ${uploadResponse.statusText}`);
     }
     return {
-        data: filename,
+        data: presignedResponse.storagePath,
         dataType: "application/store",
     };
 }
-async function conditionallyImportPacket(packet, tracer, client) {
+async function conditionallyImportPacket(packet, tracer, client, runPacket) {
     if (packet.dataType !== "application/store") {
         return packet;
     }
     if (!tracer) {
-        return await importPacket(packet, undefined, client);
+        return await importPacket(packet, undefined, client, runPacket);
     }
     else {
         const result = await tracer.startActiveSpan("store.downloadPayload", async (span) => {
-            return await importPacket(packet, span, client);
+            return await importPacket(packet, span, client, runPacket);
         }, {
             attributes: {
                 [semanticInternalAttributes_js_1.SemanticInternalAttributes.STYLE_ICON]: "cloud-download",
@@ -150,11 +185,11 @@ async function resolvePresignedPacketUrl(url, tracer) {
         };
         return await parsePacket(packet);
     }
-    catch (error) {
+    catch (_error) {
         return;
     }
 }
-async function importPacket(packet, span, client) {
+async function importPacket(packet, span, client, runPacket) {
     if (!packet.data) {
         return packet;
     }
@@ -162,8 +197,10 @@ async function importPacket(packet, span, client) {
     if (!$client) {
         return packet;
     }
-    const presignedResponse = await $client.getPayloadUrl(packet.data);
-    const response = await (0, zodfetch_js_1.zodfetch)(zod_1.z.any(), presignedResponse.presignedUrl, undefined, {
+    const presignedResponse = runPacket
+        ? await $client.getRunPacketUrl(runPacket.runId, runPacket.field, packet.data)
+        : await $client.getPayloadUrl(packet.data);
+    const response = await (0, zodfetch_js_1.zodfetch)(v4_1.z.any(), presignedResponse.presignedUrl, undefined, {
         retry: ioRetryOptions,
     }).asResponse();
     if (!response.ok) {
@@ -187,12 +224,11 @@ async function createPacketAttributes(packet, dataKey, dataTypeKey) {
                 [dataTypeKey]: packet.dataType,
             };
         case "application/super+json":
-            const { parse } = await loadSuperJSON();
             if (typeof packet.data === "undefined" || packet.data === null) {
                 return;
             }
             try {
-                const parsed = parse(packet.data);
+                const parsed = superjson_js_1.default.parse(packet.data);
                 const jsonified = JSON.parse(JSON.stringify(parsed, makeSafeReplacer()));
                 const result = {
                     ...(0, flattenAttributes_js_1.flattenAttributes)(jsonified, dataKey),
@@ -200,7 +236,7 @@ async function createPacketAttributes(packet, dataKey, dataTypeKey) {
                 };
                 return result;
             }
-            catch (e) {
+            catch (_e) {
                 return;
             }
         case "application/store":
@@ -226,17 +262,20 @@ async function createPacketAttributesAsJson(data, dataType) {
         return data;
     }
     switch (dataType) {
-        case "application/json":
-            return (0, limits_js_1.imposeAttributeLimits)((0, flattenAttributes_js_1.flattenAttributes)(data, undefined));
-        case "application/super+json":
-            const { deserialize } = await loadSuperJSON();
-            const deserialized = deserialize(data);
+        case "application/json": {
+            return (0, limits_js_1.imposeAttributeLimits)((0, flattenAttributes_js_1.flattenAttributes)(data, undefined, limits_js_1.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT));
+        }
+        case "application/super+json": {
+            const deserialized = superjson_js_1.default.deserialize(data);
             const jsonify = safeJsonParse(JSON.stringify(deserialized, makeSafeReplacer()));
-            return (0, limits_js_1.imposeAttributeLimits)((0, flattenAttributes_js_1.flattenAttributes)(jsonify, undefined));
-        case "application/store":
+            return (0, limits_js_1.imposeAttributeLimits)((0, flattenAttributes_js_1.flattenAttributes)(jsonify, undefined, limits_js_1.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT));
+        }
+        case "application/store": {
             return data;
-        default:
+        }
+        default: {
             return {};
+        }
     }
 }
 async function prettyPrintPacket(rawData, dataType, options) {
@@ -247,14 +286,33 @@ async function prettyPrintPacket(rawData, dataType, options) {
         if (typeof rawData === "string") {
             rawData = safeJsonParse(rawData);
         }
-        const { deserialize } = await loadSuperJSON();
-        return await prettyPrintPacket(deserialize(rawData), "application/json");
+        const hasCircularReferences = rawData && rawData.meta && hasCircularReference(rawData.meta);
+        if (hasCircularReferences) {
+            return await prettyPrintPacket(superjson_js_1.default.deserialize(rawData), "application/json", {
+                ...options,
+                cloneReferences: false,
+            });
+        }
+        return await prettyPrintPacket(superjson_js_1.default.deserialize(rawData), "application/json", {
+            ...options,
+            cloneReferences: true,
+        });
     }
     if (dataType === "application/json") {
         if (typeof rawData === "string") {
             rawData = safeJsonParse(rawData);
         }
-        return JSON.stringify(rawData, makeSafeReplacer(options), 2);
+        try {
+            return JSON.stringify(rawData, makeSafeReplacer(options), 2);
+        }
+        catch (error) {
+            // If cloneReferences is true, it's possible if our hasCircularReference logic is incorrect that stringifying the data will fail with a circular reference error
+            // So we will try to stringify the data with cloneReferences set to false
+            if (options?.cloneReferences) {
+                return JSON.stringify(rawData, makeSafeReplacer({ ...options, cloneReferences: false }), 2);
+            }
+            throw error;
+        }
     }
     if (typeof rawData === "string") {
         return rawData;
@@ -262,7 +320,17 @@ async function prettyPrintPacket(rawData, dataType, options) {
     return JSON.stringify(rawData, makeSafeReplacer(options), 2);
 }
 function makeSafeReplacer(options) {
+    const seen = new WeakSet();
     return function replacer(key, value) {
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                if (options?.cloneReferences) {
+                    return structuredClone(value);
+                }
+                return "[Circular]";
+            }
+            seen.add(value);
+        }
         // Check if the key should be filtered out
         if (options?.filteredKeys?.includes(key)) {
             return undefined;
@@ -314,15 +382,6 @@ function getPacketExtension(outputType) {
             return "txt";
     }
 }
-async function loadSuperJSON() {
-    const superjson = await import("superjson");
-    superjson.registerCustom({
-        isApplicable: (v) => typeof Buffer === "function" && Buffer.isBuffer(v),
-        serialize: (v) => [...v],
-        deserialize: (v) => Buffer.from(v),
-    }, "buffer");
-    return superjson;
-}
 function safeJsonParse(value) {
     try {
         return JSON.parse(value);
@@ -331,14 +390,111 @@ function safeJsonParse(value) {
         return;
     }
 }
+/**
+ * Replaces the data in a SuperJSON-serialized string with new payload data while preserving
+ * the original type metadata (Dates, BigInts, Sets, Maps, etc.).
+ *
+ * It is primarily useful for our run replay functionality where we want to preserve the original
+ * type metadata for the new payload.
+ *
+ * Note that `undefined` type metadata is ignored when the corresponding field is overriden in the
+ * new payload, i.e., fields which were previously undefined in the original payload are restored into
+ * the primitive type they have in the new payload, instead of `undefined`.
+ * This is a workaround for https://github.com/triggerdotdev/trigger.dev/issues/1968.
+ *
+ * @param original - A SuperJSON-serialized string containing the original data with type metadata
+ * @param newPayload - A JSON string containing the new data to replace the original payload
+ * @returns The deserialized object with new data but original type metadata preserved
+ *
+ * @throws {Error} If the newPayload is not valid JSON
+ */
 async function replaceSuperJsonPayload(original, newPayload) {
-    const superjson = await loadSuperJSON();
-    const originalObject = superjson.parse(original);
-    const { meta } = superjson.serialize(originalObject);
+    const originalObject = superjson_js_1.default.parse(original);
+    const newPayloadObject = JSON.parse(newPayload);
+    const { meta } = superjson_js_1.default.serialize(originalObject);
+    if (meta?.values) {
+        const originalUndefinedKeys = Object.entries(meta.values)
+            .filter(([, value]) => Array.isArray(value) && value.at(0) === "undefined")
+            .map(([key]) => key);
+        const overridenUndefinedKeys = originalUndefinedKeys.filter((key) => getKeyFromObject(newPayloadObject, key) !== undefined);
+        overridenUndefinedKeys.forEach((key) => {
+            delete meta.values[key];
+        });
+    }
     const newSuperJson = {
-        json: JSON.parse(newPayload),
+        json: newPayloadObject,
         meta,
     };
-    return superjson.deserialize(newSuperJson);
+    return superjson_js_1.default.deserialize(newSuperJson);
+}
+function getKeyFromObject(object, key) {
+    const jsonHeroPath = new path_1.JSONHeroPath(key);
+    return jsonHeroPath.first(object);
+}
+/**
+ * Detects if a superjson serialization contains circular references
+ * by analyzing the meta.referentialEqualities structure.
+ *
+ * Based on superjson's ReferentialEqualityAnnotations type:
+ * Record<string, string[]> | [string[]] | [string[], Record<string, string[]>]
+ *
+ * Circular references are represented as:
+ * - [string[]] where strings are paths that reference back to root or ancestors
+ * - The first element in [string[], Record<string, string[]>] format
+ */
+function hasCircularReference(meta) {
+    if (!meta?.referentialEqualities) {
+        return false;
+    }
+    const re = meta.referentialEqualities;
+    // Case 1: [string[]] - array containing only circular references
+    if (Array.isArray(re) && re.length === 1 && Array.isArray(re[0])) {
+        return re[0].length > 0; // Has circular references
+    }
+    // Case 2: [string[], Record<string, string[]>] - mixed format
+    if (Array.isArray(re) && re.length === 2 && Array.isArray(re[0])) {
+        return re[0].length > 0; // First element contains circular references
+    }
+    // Case 3: Record<string, string[]> - check for circular patterns in shared references
+    if (!Array.isArray(re) && typeof re === "object") {
+        // Check if any reference path points to an ancestor path
+        for (const [targetPath, referencePaths] of Object.entries(re)) {
+            for (const refPath of referencePaths) {
+                if (isCircularPattern(targetPath, refPath)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    return false;
+}
+/**
+ * Checks if a reference pattern represents a circular reference
+ * by analyzing if the reference path points back to an ancestor of the target path
+ */
+function isCircularPattern(targetPath, referencePath) {
+    const targetParts = targetPath.split(".");
+    const refParts = referencePath.split(".");
+    // For circular references, the reference path often contains the target path as a prefix
+    // Example: targetPath="user", referencePath="user.details.user"
+    // This means user.details.user points back to user (circular)
+    // Check if reference path starts with target path + additional segments that loop back
+    if (refParts.length > targetParts.length) {
+        // Check if reference path starts with target path
+        let isPrefix = true;
+        for (let i = 0; i < targetParts.length; i++) {
+            if (targetParts[i] !== refParts[i]) {
+                isPrefix = false;
+                break;
+            }
+        }
+        // If reference path starts with target path and ends with target path,
+        // it's likely a circular reference (e.g., "user" -> "user.details.user")
+        if (isPrefix && refParts[refParts.length - 1] === targetParts[targetParts.length - 1]) {
+            return true;
+        }
+    }
+    return false;
 }
 //# sourceMappingURL=ioSerialization.js.map