@trigger.dev/core 0.0.0-buffer-fix-20231206151546 → 0.0.0-bun-prerelease-20260909132648

package/dist/commonjs/v3/lifecycleHooks/types.d.ts

@@ -0,0 +1,208 @@
+import type { RetryOptions, TaskRunContext } from "../schemas/index.js";
+import type { HandleErrorResult } from "../types/index.js";
+export type TaskInitOutput = Record<string, any> | void | undefined;
+export type TaskInitHookParams<TPayload = unknown> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+};
+export type OnInitHookFunction<TPayload, TInitOutput extends TaskInitOutput> = (params: TaskInitHookParams<TPayload>) => TInitOutput | undefined | void | Promise<TInitOutput | undefined | void>;
+export type AnyOnInitHookFunction = OnInitHookFunction<unknown, TaskInitOutput>;
+export type TaskStartHookParams<TPayload = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnStartHookFunction<TPayload, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskStartHookParams<TPayload, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnStartHookFunction = OnStartHookFunction<unknown, TaskInitOutput>;
+type TaskStartAttemptHookParams<TPayload = unknown> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+};
+export type OnStartAttemptHookFunction<TPayload> = (params: TaskStartAttemptHookParams<TPayload>) => undefined | void | Promise<undefined | void>;
+export type AnyOnStartAttemptHookFunction = OnStartAttemptHookFunction<unknown>;
+export type TaskWait = {
+    type: "duration";
+    date: Date;
+} | {
+    type: "token";
+    token: string;
+} | {
+    type: "task";
+    runId: string;
+} | {
+    type: "batch";
+    batchId: string;
+    runCount: number;
+};
+export type TaskWaitHookParams<TPayload = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    wait: TaskWait;
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnWaitHookFunction<TPayload, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskWaitHookParams<TPayload, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnWaitHookFunction = OnWaitHookFunction<unknown, TaskInitOutput>;
+export type TaskResumeHookParams<TPayload = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    wait: TaskWait;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnResumeHookFunction<TPayload, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskResumeHookParams<TPayload, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnResumeHookFunction = OnResumeHookFunction<unknown, TaskInitOutput>;
+export type TaskFailureHookParams<TPayload = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    error: unknown;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnFailureHookFunction<TPayload, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskFailureHookParams<TPayload, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnFailureHookFunction = OnFailureHookFunction<unknown, TaskInitOutput>;
+export type TaskSuccessHookParams<TPayload = unknown, TOutput = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    output: TOutput;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnSuccessHookFunction<TPayload, TOutput, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskSuccessHookParams<TPayload, TOutput, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnSuccessHookFunction = OnSuccessHookFunction<unknown, unknown, TaskInitOutput>;
+type TaskCompleteSuccessResult<TOutput> = {
+    ok: true;
+    data: TOutput;
+};
+type TaskCompleteErrorResult = {
+    ok: false;
+    error: unknown;
+};
+export type TaskCompleteResult<TOutput> = TaskCompleteSuccessResult<TOutput> | TaskCompleteErrorResult;
+export type TaskCompleteHookParams<TPayload = unknown, TOutput = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    result: TaskCompleteResult<TOutput>;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnCompleteHookFunction<TPayload, TOutput, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskCompleteHookParams<TPayload, TOutput, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnCompleteHookFunction = OnCompleteHookFunction<unknown, unknown, TaskInitOutput>;
+export type RegisterHookFunctionParams<THookFunction extends (params: any) => any> = {
+    id?: string;
+    fn: THookFunction;
+};
+export type RegisteredHookFunction<THookFunction extends (params: any) => any> = {
+    id: string;
+    name?: string;
+    fn: THookFunction;
+};
+export type TaskCatchErrorHookParams<TPayload = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    error: unknown;
+    retry?: RetryOptions;
+    retryAt?: Date;
+    retryDelayInMs?: number;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnCatchErrorHookFunction<TPayload, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskCatchErrorHookParams<TPayload, TInitOutput>) => HandleErrorResult;
+export type AnyOnCatchErrorHookFunction = OnCatchErrorHookFunction<unknown, TaskInitOutput>;
+export type TaskMiddlewareHookParams<TPayload = unknown> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+    next: () => Promise<void>;
+};
+export type OnMiddlewareHookFunction<TPayload> = (params: TaskMiddlewareHookParams<TPayload>) => Promise<void>;
+export type AnyOnMiddlewareHookFunction = OnMiddlewareHookFunction<unknown>;
+export type TaskCleanupHookParams<TPayload = unknown, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    signal: AbortSignal;
+    init?: TInitOutput;
+};
+export type OnCleanupHookFunction<TPayload, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskCleanupHookParams<TPayload, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnCleanupHookFunction = OnCleanupHookFunction<unknown, TaskInitOutput>;
+export type TaskCancelHookParams<TPayload = unknown, TRunOutput = any, TInitOutput extends TaskInitOutput = TaskInitOutput> = {
+    ctx: TaskRunContext;
+    payload: TPayload;
+    task: string;
+    runPromise: Promise<TRunOutput>;
+    init?: TInitOutput;
+    signal: AbortSignal;
+};
+export type OnCancelHookFunction<TPayload, TRunOutput = any, TInitOutput extends TaskInitOutput = TaskInitOutput> = (params: TaskCancelHookParams<TPayload, TRunOutput, TInitOutput>) => undefined | void | Promise<undefined | void>;
+export type AnyOnCancelHookFunction = OnCancelHookFunction<unknown, unknown, TaskInitOutput>;
+export interface LifecycleHooksManager {
+    registerGlobalInitHook(hook: RegisterHookFunctionParams<AnyOnInitHookFunction>): void;
+    registerTaskInitHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnInitHookFunction>): void;
+    getTaskInitHook(taskId: string): AnyOnInitHookFunction | undefined;
+    getGlobalInitHooks(): RegisteredHookFunction<AnyOnInitHookFunction>[];
+    registerGlobalStartHook(hook: RegisterHookFunctionParams<AnyOnStartHookFunction>): void;
+    registerTaskStartHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnStartHookFunction>): void;
+    getTaskStartHook(taskId: string): AnyOnStartHookFunction | undefined;
+    getGlobalStartHooks(): RegisteredHookFunction<AnyOnStartHookFunction>[];
+    registerGlobalStartAttemptHook(hook: RegisterHookFunctionParams<AnyOnStartAttemptHookFunction>): void;
+    registerTaskStartAttemptHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnStartAttemptHookFunction>): void;
+    getTaskStartAttemptHook(taskId: string): AnyOnStartAttemptHookFunction | undefined;
+    getGlobalStartAttemptHooks(): RegisteredHookFunction<AnyOnStartAttemptHookFunction>[];
+    registerGlobalFailureHook(hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>): void;
+    registerTaskFailureHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>): void;
+    getTaskFailureHook(taskId: string): AnyOnFailureHookFunction | undefined;
+    getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[];
+    registerGlobalSuccessHook(hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>): void;
+    registerTaskSuccessHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>): void;
+    getTaskSuccessHook(taskId: string): AnyOnSuccessHookFunction | undefined;
+    getGlobalSuccessHooks(): RegisteredHookFunction<AnyOnSuccessHookFunction>[];
+    registerGlobalCompleteHook(hook: RegisterHookFunctionParams<AnyOnCompleteHookFunction>): void;
+    registerTaskCompleteHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnCompleteHookFunction>): void;
+    getTaskCompleteHook(taskId: string): AnyOnCompleteHookFunction | undefined;
+    getGlobalCompleteHooks(): RegisteredHookFunction<AnyOnCompleteHookFunction>[];
+    registerGlobalWaitHook(hook: RegisterHookFunctionParams<AnyOnWaitHookFunction>): void;
+    registerTaskWaitHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnWaitHookFunction>): void;
+    getTaskWaitHook(taskId: string): AnyOnWaitHookFunction | undefined;
+    getGlobalWaitHooks(): RegisteredHookFunction<AnyOnWaitHookFunction>[];
+    registerGlobalResumeHook(hook: RegisterHookFunctionParams<AnyOnResumeHookFunction>): void;
+    registerTaskResumeHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnResumeHookFunction>): void;
+    getTaskResumeHook(taskId: string): AnyOnResumeHookFunction | undefined;
+    getGlobalResumeHooks(): RegisteredHookFunction<AnyOnResumeHookFunction>[];
+    registerGlobalCatchErrorHook(hook: RegisterHookFunctionParams<AnyOnCatchErrorHookFunction>): void;
+    registerTaskCatchErrorHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnCatchErrorHookFunction>): void;
+    getTaskCatchErrorHook(taskId: string): AnyOnCatchErrorHookFunction | undefined;
+    getGlobalCatchErrorHooks(): RegisteredHookFunction<AnyOnCatchErrorHookFunction>[];
+    registerGlobalMiddlewareHook(hook: RegisterHookFunctionParams<AnyOnMiddlewareHookFunction>): void;
+    registerTaskMiddlewareHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnMiddlewareHookFunction>): void;
+    getTaskMiddlewareHook(taskId: string): AnyOnMiddlewareHookFunction | undefined;
+    getGlobalMiddlewareHooks(): RegisteredHookFunction<AnyOnMiddlewareHookFunction>[];
+    registerGlobalCleanupHook(hook: RegisterHookFunctionParams<AnyOnCleanupHookFunction>): void;
+    registerTaskCleanupHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnCleanupHookFunction>): void;
+    getTaskCleanupHook(taskId: string): AnyOnCleanupHookFunction | undefined;
+    getGlobalCleanupHooks(): RegisteredHookFunction<AnyOnCleanupHookFunction>[];
+    callOnWaitHookListeners(wait: TaskWait): Promise<void>;
+    registerOnWaitHookListener(listener: (wait: TaskWait) => Promise<void>): void;
+    callOnResumeHookListeners(wait: TaskWait): Promise<void>;
+    registerOnResumeHookListener(listener: (wait: TaskWait) => Promise<void>): void;
+    registerGlobalCancelHook(hook: RegisterHookFunctionParams<AnyOnCancelHookFunction>): void;
+    registerTaskCancelHook(taskId: string, hook: RegisterHookFunctionParams<AnyOnCancelHookFunction>): void;
+    getGlobalCancelHooks(): RegisteredHookFunction<AnyOnCancelHookFunction>[];
+    getTaskCancelHook(taskId: string): AnyOnCancelHookFunction | undefined;
+    registerOnCancelHookListener(listener: () => Promise<void>): void;
+    callOnCancelHookListeners(): Promise<void>;
+}
+export {};

package/dist/commonjs/v3/lifecycleHooks/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/commonjs/v3/lifecycleHooks/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/v3/lifecycleHooks/types.ts"],"names":[],"mappings":""}

package/dist/commonjs/v3/limits.d.ts

@@ -0,0 +1,11 @@
+import type { Attributes } from "@opentelemetry/api";
+export declare const OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: number;
+export declare const OTEL_LOG_ATTRIBUTE_COUNT_LIMIT: number;
+export declare const OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT: number;
+export declare const OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT: number;
+export declare const OTEL_SPAN_EVENT_COUNT_LIMIT: number;
+export declare const OTEL_LINK_COUNT_LIMIT: number;
+export declare const OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT: number;
+export declare const OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT: number;
+export declare const OFFLOAD_IO_PACKET_LENGTH_LIMIT: number;
+export declare function imposeAttributeLimits(attributes: Attributes): Attributes;

package/dist/commonjs/v3/limits.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFLOAD_IO_PACKET_LENGTH_LIMIT = exports.OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = exports.OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = exports.OTEL_LINK_COUNT_LIMIT = exports.OTEL_SPAN_EVENT_COUNT_LIMIT = exports.OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = exports.OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = exports.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = void 0;
+exports.imposeAttributeLimits = imposeAttributeLimits;
+const getEnv_js_1 = require("./utils/getEnv.js");
+function getOtelEnvVarLimit(key, defaultValue) {
+    const value = (0, getEnv_js_1.getEnvVar)(key);
+    if (!value) {
+        return defaultValue;
+    }
+    return parseInt(value, 10);
+}
+exports.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT", 1024);
+exports.OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_LOG_ATTRIBUTE_COUNT_LIMIT", 1024);
+exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT", 131072);
+exports.OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT", 131072);
+exports.OTEL_SPAN_EVENT_COUNT_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_SPAN_EVENT_COUNT_LIMIT", 10);
+exports.OTEL_LINK_COUNT_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_LINK_COUNT_LIMIT", 2);
+exports.OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT", 10);
+exports.OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = getOtelEnvVarLimit("TRIGGER_OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT", 10);
+exports.OFFLOAD_IO_PACKET_LENGTH_LIMIT = 128 * 1024;
+function imposeAttributeLimits(attributes) {
+    const newAttributes = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (calculateAttributeValueLength(value) > exports.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT) {
+            continue;
+        }
+        newAttributes[key] = value;
+    }
+    return newAttributes;
+}
+function calculateAttributeValueLength(value) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (typeof value === "number") {
+        return 8;
+    }
+    if (typeof value === "boolean") {
+        return 4;
+    }
+    if (Array.isArray(value)) {
+        return value.reduce((acc, v) => acc + calculateAttributeValueLength(v), 0);
+    }
+    return 0;
+}
+//# sourceMappingURL=limits.js.map

package/dist/commonjs/v3/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","sourceRoot":"","sources":["../../../src/v3/limits.ts"],"names":[],"mappings":";;;;AACA,iDAA8C;AAE9C,SAAS,kBAAkB,CAAC,GAAW,EAAE,YAAoB;IAC3D,MAAM,KAAK,GAAG,IAAA,qBAAS,EAAC,GAAG,CAAC,CAAC;IAE7B,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,OAAO,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAC7B,CAAC;AAEY,QAAA,+BAA+B,GAAG,kBAAkB,CAC/D,yCAAyC,EACzC,IAAI,CACL,CAAC;AACW,QAAA,8BAA8B,GAAG,kBAAkB,CAC9D,wCAAwC,EACxC,IAAI,CACL,CAAC;AACW,QAAA,sCAAsC,GAAG,kBAAkB,CACtE,gDAAgD,EAChD,MAAM,CACP,CAAC;AACW,QAAA,qCAAqC,GAAG,kBAAkB,CACrE,+CAA+C,EAC/C,MAAM,CACP,CAAC;AACW,QAAA,2BAA2B,GAAG,kBAAkB,CAC3D,qCAAqC,EACrC,EAAE,CACH,CAAC;AACW,QAAA,qBAAqB,GAAG,kBAAkB,CAAC,+BAA+B,EAAE,CAAC,CAAC,CAAC;AAC/E,QAAA,mCAAmC,GAAG,kBAAkB,CACnE,6CAA6C,EAC7C,EAAE,CACH,CAAC;AACW,QAAA,oCAAoC,GAAG,kBAAkB,CACpE,8CAA8C,EAC9C,EAAE,CACH,CAAC;AAEW,QAAA,8BAA8B,GAAG,GAAG,GAAG,IAAI,CAAC;AAEzD,+BAAsC,UAAsB;IAC1D,MAAM,aAAa,GAAe,EAAE,CAAC;IAErC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACtD,IAAI,6BAA6B,CAAC,KAAK,CAAC,GAAG,QAAA,sCAAsC,EAAE,CAAC;YAClF,SAAS;QACX,CAAC;QAED,aAAa,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,SAAS,6BAA6B,CAAC,KAAwC;IAC7E,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC,MAAM,CAAC;IACtB,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,CAAC,CAAC;IACX,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,6BAA6B,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACrF,CAAC;IAED,OAAO,CAAC,CAAC;AACX,CAAC"}

package/dist/commonjs/v3/links.d.ts

@@ -0,0 +1,32 @@
+export declare const links: {
+    docs: {
+        config: {
+            home: string;
+            additionalPackages: string;
+            extensions: string;
+            prisma: string;
+        };
+        machines: {
+            home: string;
+        };
+        upgrade: {
+            beta: string;
+        };
+        troubleshooting: {
+            concurrentWaits: string;
+            stalledExecution: string;
+            uncaughtException: string;
+        };
+        concurrency: {
+            recursiveDeadlock: string;
+            deadlock: string;
+        };
+        gitHubActions: {
+            personalAccessToken: string;
+        };
+    };
+    site: {
+        home: string;
+        contact: string;
+    };
+};

package/dist/commonjs/v3/links.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.links = void 0;
+exports.links = {
+    docs: {
+        config: {
+            home: "https://trigger.dev/docs/config/config-file",
+            additionalPackages: "https://trigger.dev/docs/config/config-file#additionalpackages",
+            extensions: "https://trigger.dev/docs/config/config-file#extensions",
+            prisma: "https://trigger.dev/docs/config/config-file#prisma",
+        },
+        machines: {
+            home: "https://trigger.dev/docs/v3/machines",
+        },
+        upgrade: {
+            beta: "https://trigger.dev/docs/upgrading-beta",
+        },
+        troubleshooting: {
+            concurrentWaits: "https://trigger.dev/docs/troubleshooting#parallel-waits-are-not-supported",
+            stalledExecution: "https://trigger.dev/docs/troubleshooting#task-run-stalled-executing",
+            uncaughtException: "https://trigger.dev/docs/troubleshooting#uncaught-exceptions",
+        },
+        concurrency: {
+            recursiveDeadlock: "https://trigger.dev/docs/queue-concurrency#waiting-for-a-subtask-on-the-same-queue",
+            deadlock: "https://trigger.dev/docs/queue-concurrency#deadlock",
+        },
+        gitHubActions: {
+            personalAccessToken: "https://trigger.dev/docs/github-actions#creating-a-personal-access-token",
+        },
+    },
+    site: {
+        home: "https://trigger.dev",
+        contact: "https://trigger.dev/contact",
+    },
+};
+//# sourceMappingURL=links.js.map

package/dist/commonjs/v3/links.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.js","sourceRoot":"","sources":["../../../src/v3/links.ts"],"names":[],"mappings":";;;AAAa,QAAA,KAAK,GAAG;IACnB,IAAI,EAAE;QACJ,MAAM,EAAE;YACN,IAAI,EAAE,6CAA6C;YACnD,kBAAkB,EAAE,gEAAgE;YACpF,UAAU,EAAE,wDAAwD;YACpE,MAAM,EAAE,oDAAoD;SAC7D;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,sCAAsC;SAC7C;QACD,OAAO,EAAE;YACP,IAAI,EAAE,yCAAyC;SAChD;QACD,eAAe,EAAE;YACf,eAAe,EAAE,2EAA2E;YAC5F,gBAAgB,EAAE,qEAAqE;YACvF,iBAAiB,EAAE,8DAA8D;SAClF;QACD,WAAW,EAAE;YACX,iBAAiB,EACf,oFAAoF;YACtF,QAAQ,EAAE,qDAAqD;SAChE;QACD,aAAa,EAAE;YACb,mBAAmB,EACjB,0EAA0E;SAC7E;KACF;IACD,IAAI,EAAE;QACJ,IAAI,EAAE,qBAAqB;QAC3B,OAAO,EAAE,6BAA6B;KACvC;CACF,CAAC"}

package/dist/commonjs/v3/locals/index.d.ts

@@ -0,0 +1,12 @@
+import { type LocalsKey, type LocalsManager } from "./types.js";
+export declare class LocalsAPI implements LocalsManager {
+    #private;
+    private static _instance?;
+    private constructor();
+    static getInstance(): LocalsAPI;
+    setGlobalLocalsManager(localsManager: LocalsManager): boolean;
+    disable(): void;
+    createLocal<T>(id: string): LocalsKey<T>;
+    getLocal<T>(key: LocalsKey<T>): T | undefined;
+    setLocal<T>(key: LocalsKey<T>, value: T): void;
+}

package/dist/commonjs/v3/locals/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalsAPI = void 0;
+const API_NAME = "locals";
+const globals_js_1 = require("../utils/globals.js");
+const manager_js_1 = require("./manager.js");
+const NOOP_LOCALS_MANAGER = new manager_js_1.NoopLocalsManager();
+class LocalsAPI {
+    static _instance;
+    constructor() { }
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new LocalsAPI();
+        }
+        return this._instance;
+    }
+    setGlobalLocalsManager(localsManager) {
+        return (0, globals_js_1.registerGlobal)(API_NAME, localsManager);
+    }
+    disable() {
+        (0, globals_js_1.unregisterGlobal)(API_NAME);
+    }
+    createLocal(id) {
+        return this.#getManager().createLocal(id);
+    }
+    getLocal(key) {
+        return this.#getManager().getLocal(key);
+    }
+    setLocal(key, value) {
+        return this.#getManager().setLocal(key, value);
+    }
+    #getManager() {
+        return (0, globals_js_1.getGlobal)(API_NAME) ?? NOOP_LOCALS_MANAGER;
+    }
+}
+exports.LocalsAPI = LocalsAPI;
+//# sourceMappingURL=index.js.map

package/dist/commonjs/v3/locals/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/v3/locals/index.ts"],"names":[],"mappings":";;;AAAA,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAE1B,oDAAkF;AAClF,6CAAiD;AAGjD,MAAM,mBAAmB,GAAG,IAAI,8BAAiB,EAAE,CAAC;AAEpD;IACU,MAAM,CAAC,SAAS,CAAa;IAErC,gBAAuB,CAAC;IAEjB,MAAM,CAAC,WAAW;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;QACnC,CAAC;QAED,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAEM,sBAAsB,CAAC,aAA4B;QACxD,OAAO,IAAA,2BAAc,EAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IACjD,CAAC;IAEM,OAAO;QACZ,IAAA,6BAAgB,EAAC,QAAQ,CAAC,CAAC;IAC7B,CAAC;IAEM,WAAW,CAAI,EAAU;QAC9B,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAEM,QAAQ,CAAI,GAAiB;QAClC,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC1C,CAAC;IAEM,QAAQ,CAAI,GAAiB,EAAE,KAAQ;QAC5C,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACjD,CAAC;IAED,WAAW;QACT,OAAO,IAAA,sBAAS,EAAC,QAAQ,CAAC,IAAI,mBAAmB,CAAC;IACpD,CAAC;CACF"}

package/dist/commonjs/v3/locals/manager.d.ts

@@ -0,0 +1,13 @@
+import type { LocalsKey, LocalsManager } from "./types.js";
+export declare class NoopLocalsManager implements LocalsManager {
+    createLocal<T>(id: string): LocalsKey<T>;
+    getLocal<T>(key: LocalsKey<T>): T | undefined;
+    setLocal<T>(key: LocalsKey<T>, value: T): void;
+}
+export declare class StandardLocalsManager implements LocalsManager {
+    private store;
+    createLocal<T>(id: string): LocalsKey<T>;
+    getLocal<T>(key: LocalsKey<T>): T | undefined;
+    setLocal<T>(key: LocalsKey<T>, value: T): void;
+    reset(): void;
+}

package/dist/commonjs/v3/locals/manager.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardLocalsManager = exports.NoopLocalsManager = void 0;
+class NoopLocalsManager {
+    createLocal(id) {
+        return {
+            __type: Symbol(id),
+            id,
+        };
+    }
+    getLocal(key) {
+        return undefined;
+    }
+    setLocal(key, value) { }
+}
+exports.NoopLocalsManager = NoopLocalsManager;
+class StandardLocalsManager {
+    store = new Map();
+    createLocal(id) {
+        const key = Symbol.for(id);
+        return {
+            __type: key,
+            id,
+        };
+    }
+    getLocal(key) {
+        return this.store.get(key.__type);
+    }
+    setLocal(key, value) {
+        this.store.set(key.__type, value);
+    }
+    reset() {
+        this.store.clear();
+    }
+}
+exports.StandardLocalsManager = StandardLocalsManager;
+//# sourceMappingURL=manager.js.map

package/dist/commonjs/v3/locals/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../../src/v3/locals/manager.ts"],"names":[],"mappings":";;;AAEA;IACE,WAAW,CAAI,EAAU;QACvB,OAAO;YACL,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;YAClB,EAAE;SACH,CAAC;IACJ,CAAC;IAED,QAAQ,CAAI,GAAiB;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,QAAQ,CAAI,GAAiB,EAAE,KAAQ,IAAS,CAAC;CAClD;;AAED;IACU,KAAK,GAAyB,IAAI,GAAG,EAAE,CAAC;IAEhD,WAAW,CAAI,EAAU;QACvB,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3B,OAAO;YACL,MAAM,EAAE,GAAG;YACX,EAAE;SACH,CAAC;IACJ,CAAC;IAED,QAAQ,CAAI,GAAiB;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAkB,CAAC;IACrD,CAAC;IAED,QAAQ,CAAI,GAAiB,EAAE,KAAQ;QACrC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;CACF"}

package/dist/commonjs/v3/locals/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A type-safe key for `locals`. Carries the value type `T` as a phantom
+ * marker on the optional `__valueType` field so two keys with different
+ * value types are distinguishable at the type level.
+ *
+ * The phantom field is intentionally not anchored to a `unique symbol`:
+ * dual-package builds (`tshy`) emit separate `.d.ts` files for ESM and
+ * CJS outputs, and each `unique symbol` declaration in a `.d.ts` is its
+ * own nominal type. If a single compilation ever resolves `LocalsKey`
+ * from both the ESM and CJS paths — which happens under certain pnpm
+ * hoisting layouts — `unique symbol` brands produce structurally
+ * incompatible variants of the same type. A plain string brand avoids
+ * the hazard.
+ */
+export type LocalsKey<T> = {
+    readonly id: string;
+    readonly __type: symbol;
+    /** Phantom carrier for the value type — never read at runtime. */
+    readonly __valueType?: T;
+};
+export interface LocalsManager {
+    createLocal<T>(id: string): LocalsKey<T>;
+    getLocal<T>(key: LocalsKey<T>): T | undefined;
+    setLocal<T>(key: LocalsKey<T>, value: T): void;
+}

package/dist/commonjs/v3/locals/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/commonjs/v3/locals/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/v3/locals/types.ts"],"names":[],"mappings":""}

package/dist/commonjs/v3/locals-api.d.ts

@@ -0,0 +1,12 @@
+import { LocalsAPI } from "./locals/index.js";
+import type { LocalsKey } from "./locals/types.js";
+/** Entrypoint for runtime API */
+export declare const localsAPI: LocalsAPI;
+export declare const locals: {
+    create<T>(id: string): LocalsKey<T>;
+    get<T>(key: LocalsKey<T>): T | undefined;
+    getOrThrow<T>(key: LocalsKey<T>): T;
+    set<T>(key: LocalsKey<T>, value: T): T;
+};
+export type Locals = typeof locals;
+export type { LocalsKey };

package/dist/commonjs/v3/locals-api.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locals = exports.localsAPI = void 0;
+// Split module-level variable definition into separate files to allow
+// tree-shaking on each api instance.
+const index_js_1 = require("./locals/index.js");
+/** Entrypoint for runtime API */
+exports.localsAPI = index_js_1.LocalsAPI.getInstance();
+exports.locals = {
+    create(id) {
+        return exports.localsAPI.createLocal(id);
+    },
+    get(key) {
+        return exports.localsAPI.getLocal(key);
+    },
+    getOrThrow(key) {
+        const value = exports.localsAPI.getLocal(key);
+        if (!value) {
+            throw new Error(`Local with id ${key.id} not found`);
+        }
+        return value;
+    },
+    set(key, value) {
+        exports.localsAPI.setLocal(key, value);
+        return value;
+    },
+};
+//# sourceMappingURL=locals-api.js.map

package/dist/commonjs/v3/locals-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locals-api.js","sourceRoot":"","sources":["../../../src/v3/locals-api.ts"],"names":[],"mappings":";;;AAAA,sEAAsE;AACtE,qCAAqC;AACrC,gDAA8C;AAE9C,iCAAiC;AACpB,QAAA,SAAS,GAAG,oBAAS,CAAC,WAAW,EAAE,CAAC;AAEpC,QAAA,MAAM,GAAG;IACpB,MAAM,CAAI,EAAU;QAClB,OAAO,QAAA,SAAS,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IACnC,CAAC;IACD,GAAG,CAAI,GAAiB;QACtB,OAAO,QAAA,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,UAAU,CAAI,GAAiB;QAC7B,MAAM,KAAK,GAAG,QAAA,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,iBAAiB,GAAG,CAAC,EAAE,YAAY,CAAC,CAAC;QACvD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,GAAG,CAAI,GAAiB,EAAE,KAAQ;QAChC,QAAA,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAC"}

package/dist/commonjs/v3/logger/index.d.ts

@@ -0,0 +1,17 @@
+import type { TaskLogger, TraceOptions } from "./taskLogger.js";
+import type { Span } from "@opentelemetry/api";
+export declare class LoggerAPI implements TaskLogger {
+    #private;
+    private static _instance?;
+    private constructor();
+    static getInstance(): LoggerAPI;
+    disable(): void;
+    setGlobalTaskLogger(taskLogger: TaskLogger): boolean;
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    log(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    trace<T>(name: string, fn: (span: Span) => Promise<T>, options?: TraceOptions): Promise<T>;
+    startSpan(name: string, options?: TraceOptions): Span;
+}

package/dist/commonjs/v3/logger/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerAPI = void 0;
+const taskLogger_js_1 = require("./taskLogger.js");
+const globals_js_1 = require("../utils/globals.js");
+const API_NAME = "logger";
+const NOOP_TASK_LOGGER = new taskLogger_js_1.NoopTaskLogger();
+class LoggerAPI {
+    static _instance;
+    constructor() { }
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new LoggerAPI();
+        }
+        return this._instance;
+    }
+    disable() {
+        (0, globals_js_1.unregisterGlobal)(API_NAME);
+    }
+    setGlobalTaskLogger(taskLogger) {
+        return (0, globals_js_1.registerGlobal)(API_NAME, taskLogger);
+    }
+    debug(message, metadata) {
+        this.#getTaskLogger().debug(message, metadata);
+    }
+    log(message, metadata) {
+        this.#getTaskLogger().log(message, metadata);
+    }
+    info(message, metadata) {
+        this.#getTaskLogger().info(message, metadata);
+    }
+    warn(message, metadata) {
+        this.#getTaskLogger().warn(message, metadata);
+    }
+    error(message, metadata) {
+        this.#getTaskLogger().error(message, metadata);
+    }
+    trace(name, fn, options) {
+        return this.#getTaskLogger().trace(name, fn, options);
+    }
+    startSpan(name, options) {
+        return this.#getTaskLogger().startSpan(name, options);
+    }
+    #getTaskLogger() {
+        return (0, globals_js_1.getGlobal)(API_NAME) ?? NOOP_TASK_LOGGER;
+    }
+}
+exports.LoggerAPI = LoggerAPI;
+//# sourceMappingURL=index.js.map

package/dist/commonjs/v3/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/v3/logger/index.ts"],"names":[],"mappings":";;;AACA,mDAAiD;AACjD,oDAAkF;AAGlF,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAE1B,MAAM,gBAAgB,GAAG,IAAI,8BAAc,EAAE,CAAC;AAE9C;IACU,MAAM,CAAC,SAAS,CAAa;IAErC,gBAAuB,CAAC;IAEjB,MAAM,CAAC,WAAW;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;QACnC,CAAC;QAED,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAEM,OAAO;QACZ,IAAA,6BAAgB,EAAC,QAAQ,CAAC,CAAC;IAC7B,CAAC;IAEM,mBAAmB,CAAC,UAAsB;QAC/C,OAAO,IAAA,2BAAc,EAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAC9C,CAAC;IAEM,KAAK,CAAC,OAAe,EAAE,QAAkC;QAC9D,IAAI,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAEM,GAAG,CAAC,OAAe,EAAE,QAAkC;QAC5D,IAAI,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAEM,IAAI,CAAC,OAAe,EAAE,QAAkC;QAC7D,IAAI,CAAC,cAAc,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;IAEM,IAAI,CAAC,OAAe,EAAE,QAAkC;QAC7D,IAAI,CAAC,cAAc,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;IAEM,KAAK,CAAC,OAAe,EAAE,QAAkC;QAC9D,IAAI,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAEM,KAAK,CACV,IAAY,EACZ,EAA8B,EAC9B,OAAsB;QAEtB,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC;IACxD,CAAC;IAEM,SAAS,CAAC,IAAY,EAAE,OAAsB;QACnD,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACxD,CAAC;IAED,cAAc;QACZ,OAAO,IAAA,sBAAS,EAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC;IACjD,CAAC;CACF"}